zzy34407230
/
mindspore2022
Not watched
1
0
Fork 0
Code
Releases 22 Wiki evaluate Activity
Issues 0 Pull Requests 0 Datasets Model Cloudbrain HPC
You can not select more than 25 topics Topics must start with a chinese character,a letter or number, can include dashes ('-') and can be up to 35 characters long.
Tree: f27a16c8f8
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from 'f27a16c8f8'
${ noResults }
mindspore2022/third_party/patch/projectq/projectq.patch001

970 lines
53 kB
Raw Blame History 

  1. diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel1.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel1.hpp

  2. --- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel1.hpp	2020-06-05 21:07:57.000000000 +0800

  3. +++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel1.hpp	2021-04-19 18:04:05.541802882 +0800

  4. @@ -17,18 +17,18 @@

  5.  {

  6.      __m256d v[2];

  7.  

  8. -    v[0] = load2(&psi[I]);

  9. -    v[1] = load2(&psi[I + d0]);

  10. +    v[0] = load2(psi + 2 * I);

  11. +    v[1] = load2(psi + 2 * (I + d0));

  12.  

  13. -    _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(mul(v[0], m[0], mt[0]), mul(v[1], m[1], mt[1])));

  14. +    _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(mul(v[0], m[0], mt[0]), mul(v[1], m[1], mt[1])));

  15.  

  16.  }

  17.  

  18.  // bit indices id[.] are given from high to low (e.g. control first for CNOT)

  19.  template <class V, class M>

  20. -void kernel(V &psi, unsigned id0, M const& m, std::size_t ctrlmask)

  21. +void kernel(V &psi, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)

  22.  {

  23. -    std::size_t n = psi.size();

  24. +    std::size_t n = len;

  25.      std::size_t d0 = 1UL << id0;

  26.  

  27.      __m256d mm[] = {load(&m[0][0], &m[1][0]), load(&m[0][1], &m[1][1])};

  28. diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel2.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel2.hpp

  29. --- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel2.hpp	2020-06-05 21:07:57.000000000 +0800

  30. +++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel2.hpp	2021-04-19 18:04:05.541802882 +0800

  31. @@ -17,21 +17,21 @@

  32.  {

  33.      __m256d v[4];

  34.  

  35. -    v[0] = load2(&psi[I]);

  36. -    v[1] = load2(&psi[I + d0]);

  37. -    v[2] = load2(&psi[I + d1]);

  38. -    v[3] = load2(&psi[I + d0 + d1]);

  39. +    v[0] = load2(psi + 2 * I);

  40. +    v[1] = load2(psi + 2 * (I + d0));

  41. +    v[2] = load2(psi + 2 * (I + d1));

  42. +    v[3] = load2(psi + 2 * (I + d0 + d1));

  43.  

  44. -    _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(mul(v[0], m[0], mt[0]), add(mul(v[1], m[1], mt[1]), add(mul(v[2], m[2], mt[2]), mul(v[3], m[3], mt[3])))));

  45. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1], (double*)&psi[I + d1], add(mul(v[0], m[4], mt[4]), add(mul(v[1], m[5], mt[5]), add(mul(v[2], m[6], mt[6]), mul(v[3], m[7], mt[7])))));

  46. +    _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(mul(v[0], m[0], mt[0]), add(mul(v[1], m[1], mt[1]), add(mul(v[2], m[2], mt[2]), mul(v[3], m[3], mt[3])))));

  47. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1), psi + 2 * (I + d1), add(mul(v[0], m[4], mt[4]), add(mul(v[1], m[5], mt[5]), add(mul(v[2], m[6], mt[6]), mul(v[3], m[7], mt[7])))));

  48.  

  49.  }

  50.  

  51.  // bit indices id[.] are given from high to low (e.g. control first for CNOT)

  52.  template <class V, class M>

  53. -void kernel(V &psi, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask)

  54. +void kernel(V &psi, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)

  55.  {

  56. -    std::size_t n = psi.size();

  57. +    std::size_t n = len;

  58.      std::size_t d0 = 1UL << id0;

  59.      std::size_t d1 = 1UL << id1;

  60.  

  61. diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel3.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel3.hpp

  62. --- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel3.hpp	2020-06-05 21:07:57.000000000 +0800

  63. +++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel3.hpp	2021-04-19 18:04:05.541802882 +0800

  64. @@ -17,10 +17,10 @@

  65.  {

  66.      __m256d v[4];

  67.  

  68. -    v[0] = load2(&psi[I]);

  69. -    v[1] = load2(&psi[I + d0]);

  70. -    v[2] = load2(&psi[I + d1]);

  71. -    v[3] = load2(&psi[I + d0 + d1]);

  72. +    v[0] = load2(psi + 2 * I);

  73. +    v[1] = load2(psi + 2 * (I + d0));

  74. +    v[2] = load2(psi + 2 * (I + d1));

  75. +    v[3] = load2(psi + 2 * (I + d0 + d1));

  76.  

  77.      __m256d tmp[4];

  78.  

  79. @@ -29,23 +29,23 @@

  80.      tmp[2] = add(mul(v[0], m[8], mt[8]), add(mul(v[1], m[9], mt[9]), add(mul(v[2], m[10], mt[10]), mul(v[3], m[11], mt[11]))));

  81.      tmp[3] = add(mul(v[0], m[12], mt[12]), add(mul(v[1], m[13], mt[13]), add(mul(v[2], m[14], mt[14]), mul(v[3], m[15], mt[15]))));

  82.  

  83. -    v[0] = load2(&psi[I + d2]);

  84. -    v[1] = load2(&psi[I + d0 + d2]);

  85. -    v[2] = load2(&psi[I + d1 + d2]);

  86. -    v[3] = load2(&psi[I + d0 + d1 + d2]);

  87. -

  88. -    _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(tmp[0], add(mul(v[0], m[16], mt[16]), add(mul(v[1], m[17], mt[17]), add(mul(v[2], m[18], mt[18]), mul(v[3], m[19], mt[19]))))));

  89. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1], (double*)&psi[I + d1], add(tmp[1], add(mul(v[0], m[20], mt[20]), add(mul(v[1], m[21], mt[21]), add(mul(v[2], m[22], mt[22]), mul(v[3], m[23], mt[23]))))));

  90. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d2], (double*)&psi[I + d2], add(tmp[2], add(mul(v[0], m[24], mt[24]), add(mul(v[1], m[25], mt[25]), add(mul(v[2], m[26], mt[26]), mul(v[3], m[27], mt[27]))))));

  91. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2], (double*)&psi[I + d1 + d2], add(tmp[3], add(mul(v[0], m[28], mt[28]), add(mul(v[1], m[29], mt[29]), add(mul(v[2], m[30], mt[30]), mul(v[3], m[31], mt[31]))))));

  92. +    v[0] = load2(psi + 2 * (I + d2));

  93. +    v[1] = load2(psi + 2 * (I + d0 + d2));

  94. +    v[2] = load2(psi + 2 * (I + d1 + d2));

  95. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d2));

  96. +

  97. +    _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(tmp[0], add(mul(v[0], m[16], mt[16]), add(mul(v[1], m[17], mt[17]), add(mul(v[2], m[18], mt[18]), mul(v[3], m[19], mt[19]))))));

  98. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1), psi + 2 * (I + d1), add(tmp[1], add(mul(v[0], m[20], mt[20]), add(mul(v[1], m[21], mt[21]), add(mul(v[2], m[22], mt[22]), mul(v[3], m[23], mt[23]))))));

  99. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2), psi + 2 * (I + d2), add(tmp[2], add(mul(v[0], m[24], mt[24]), add(mul(v[1], m[25], mt[25]), add(mul(v[2], m[26], mt[26]), mul(v[3], m[27], mt[27]))))));

  100. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2), psi + 2 * (I + d1 + d2), add(tmp[3], add(mul(v[0], m[28], mt[28]), add(mul(v[1], m[29], mt[29]), add(mul(v[2], m[30], mt[30]), mul(v[3], m[31], mt[31]))))));

  101.  

  102.  }

  103.  

  104.  // bit indices id[.] are given from high to low (e.g. control first for CNOT)

  105.  template <class V, class M>

  106. -void kernel(V &psi, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask)

  107. +void kernel(V &psi, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)

  108.  {

  109. -    std::size_t n = psi.size();

  110. +    std::size_t n = len;

  111.      std::size_t d0 = 1UL << id0;

  112.      std::size_t d1 = 1UL << id1;

  113.      std::size_t d2 = 1UL << id2;

  114. diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel4.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel4.hpp

  115. --- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel4.hpp	2020-06-05 21:07:57.000000000 +0800

  116. +++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel4.hpp	2021-04-19 18:04:05.541802882 +0800

  117. @@ -17,10 +17,10 @@

  118.  {

  119.      __m256d v[4];

  120.  

  121. -    v[0] = load2(&psi[I]);

  122. -    v[1] = load2(&psi[I + d0]);

  123. -    v[2] = load2(&psi[I + d1]);

  124. -    v[3] = load2(&psi[I + d0 + d1]);

  125. +    v[0] = load2(psi + 2 * I);

  126. +    v[1] = load2(psi + 2 * (I + d0));

  127. +    v[2] = load2(psi + 2 * (I + d1));

  128. +    v[3] = load2(psi + 2 * (I + d0 + d1));

  129.  

  130.      __m256d tmp[8];

  131.  

  132. @@ -33,10 +33,10 @@

  133.      tmp[6] = add(mul(v[0], m[24], mt[24]), add(mul(v[1], m[25], mt[25]), add(mul(v[2], m[26], mt[26]), mul(v[3], m[27], mt[27]))));

  134.      tmp[7] = add(mul(v[0], m[28], mt[28]), add(mul(v[1], m[29], mt[29]), add(mul(v[2], m[30], mt[30]), mul(v[3], m[31], mt[31]))));

  135.  

  136. -    v[0] = load2(&psi[I + d2]);

  137. -    v[1] = load2(&psi[I + d0 + d2]);

  138. -    v[2] = load2(&psi[I + d1 + d2]);

  139. -    v[3] = load2(&psi[I + d0 + d1 + d2]);

  140. +    v[0] = load2(psi + 2 * (I + d2));

  141. +    v[1] = load2(psi + 2 * (I + d0 + d2));

  142. +    v[2] = load2(psi + 2 * (I + d1 + d2));

  143. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d2));

  144.  

  145.      tmp[0] = add(tmp[0], add(mul(v[0], m[32], mt[32]), add(mul(v[1], m[33], mt[33]), add(mul(v[2], m[34], mt[34]), mul(v[3], m[35], mt[35])))));

  146.      tmp[1] = add(tmp[1], add(mul(v[0], m[36], mt[36]), add(mul(v[1], m[37], mt[37]), add(mul(v[2], m[38], mt[38]), mul(v[3], m[39], mt[39])))));

  147. @@ -47,10 +47,10 @@

  148.      tmp[6] = add(tmp[6], add(mul(v[0], m[56], mt[56]), add(mul(v[1], m[57], mt[57]), add(mul(v[2], m[58], mt[58]), mul(v[3], m[59], mt[59])))));

  149.      tmp[7] = add(tmp[7], add(mul(v[0], m[60], mt[60]), add(mul(v[1], m[61], mt[61]), add(mul(v[2], m[62], mt[62]), mul(v[3], m[63], mt[63])))));

  150.  

  151. -    v[0] = load2(&psi[I + d3]);

  152. -    v[1] = load2(&psi[I + d0 + d3]);

  153. -    v[2] = load2(&psi[I + d1 + d3]);

  154. -    v[3] = load2(&psi[I + d0 + d1 + d3]);

  155. +    v[0] = load2(psi + 2 * (I + d3));

  156. +    v[1] = load2(psi + 2 * (I + d0 + d3));

  157. +    v[2] = load2(psi + 2 * (I + d1 + d3));

  158. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d3));

  159.  

  160.      tmp[0] = add(tmp[0], add(mul(v[0], m[64], mt[64]), add(mul(v[1], m[65], mt[65]), add(mul(v[2], m[66], mt[66]), mul(v[3], m[67], mt[67])))));

  161.      tmp[1] = add(tmp[1], add(mul(v[0], m[68], mt[68]), add(mul(v[1], m[69], mt[69]), add(mul(v[2], m[70], mt[70]), mul(v[3], m[71], mt[71])))));

  162. @@ -61,27 +61,27 @@

  163.      tmp[6] = add(tmp[6], add(mul(v[0], m[88], mt[88]), add(mul(v[1], m[89], mt[89]), add(mul(v[2], m[90], mt[90]), mul(v[3], m[91], mt[91])))));

  164.      tmp[7] = add(tmp[7], add(mul(v[0], m[92], mt[92]), add(mul(v[1], m[93], mt[93]), add(mul(v[2], m[94], mt[94]), mul(v[3], m[95], mt[95])))));

  165.  

  166. -    v[0] = load2(&psi[I + d2 + d3]);

  167. -    v[1] = load2(&psi[I + d0 + d2 + d3]);

  168. -    v[2] = load2(&psi[I + d1 + d2 + d3]);

  169. -    v[3] = load2(&psi[I + d0 + d1 + d2 + d3]);

  170. -

  171. -    _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(tmp[0], add(mul(v[0], m[96], mt[96]), add(mul(v[1], m[97], mt[97]), add(mul(v[2], m[98], mt[98]), mul(v[3], m[99], mt[99]))))));

  172. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1], (double*)&psi[I + d1], add(tmp[1], add(mul(v[0], m[100], mt[100]), add(mul(v[1], m[101], mt[101]), add(mul(v[2], m[102], mt[102]), mul(v[3], m[103], mt[103]))))));

  173. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d2], (double*)&psi[I + d2], add(tmp[2], add(mul(v[0], m[104], mt[104]), add(mul(v[1], m[105], mt[105]), add(mul(v[2], m[106], mt[106]), mul(v[3], m[107], mt[107]))))));

  174. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2], (double*)&psi[I + d1 + d2], add(tmp[3], add(mul(v[0], m[108], mt[108]), add(mul(v[1], m[109], mt[109]), add(mul(v[2], m[110], mt[110]), mul(v[3], m[111], mt[111]))))));

  175. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d3], (double*)&psi[I + d3], add(tmp[4], add(mul(v[0], m[112], mt[112]), add(mul(v[1], m[113], mt[113]), add(mul(v[2], m[114], mt[114]), mul(v[3], m[115], mt[115]))))));

  176. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d3], (double*)&psi[I + d1 + d3], add(tmp[5], add(mul(v[0], m[116], mt[116]), add(mul(v[1], m[117], mt[117]), add(mul(v[2], m[118], mt[118]), mul(v[3], m[119], mt[119]))))));

  177. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d2 + d3], (double*)&psi[I + d2 + d3], add(tmp[6], add(mul(v[0], m[120], mt[120]), add(mul(v[1], m[121], mt[121]), add(mul(v[2], m[122], mt[122]), mul(v[3], m[123], mt[123]))))));

  178. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2 + d3], (double*)&psi[I + d1 + d2 + d3], add(tmp[7], add(mul(v[0], m[124], mt[124]), add(mul(v[1], m[125], mt[125]), add(mul(v[2], m[126], mt[126]), mul(v[3], m[127], mt[127]))))));

  179. +    v[0] = load2(psi + 2 * (I + d2 + d3));

  180. +    v[1] = load2(psi + 2 * (I + d0 + d2 + d3));

  181. +    v[2] = load2(psi + 2 * (I + d1 + d2 + d3));

  182. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d2 + d3));

  183. +

  184. +    _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(tmp[0], add(mul(v[0], m[96], mt[96]), add(mul(v[1], m[97], mt[97]), add(mul(v[2], m[98], mt[98]), mul(v[3], m[99], mt[99]))))));

  185. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1), psi + 2 * (I + d1), add(tmp[1], add(mul(v[0], m[100], mt[100]), add(mul(v[1], m[101], mt[101]), add(mul(v[2], m[102], mt[102]), mul(v[3], m[103], mt[103]))))));

  186. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2), psi + 2 * (I + d2), add(tmp[2], add(mul(v[0], m[104], mt[104]), add(mul(v[1], m[105], mt[105]), add(mul(v[2], m[106], mt[106]), mul(v[3], m[107], mt[107]))))));

  187. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2), psi + 2 * (I + d1 + d2), add(tmp[3], add(mul(v[0], m[108], mt[108]), add(mul(v[1], m[109], mt[109]), add(mul(v[2], m[110], mt[110]), mul(v[3], m[111], mt[111]))))));

  188. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d3), psi + 2 * (I + d3), add(tmp[4], add(mul(v[0], m[112], mt[112]), add(mul(v[1], m[113], mt[113]), add(mul(v[2], m[114], mt[114]), mul(v[3], m[115], mt[115]))))));

  189. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d3), psi + 2 * (I + d1 + d3), add(tmp[5], add(mul(v[0], m[116], mt[116]), add(mul(v[1], m[117], mt[117]), add(mul(v[2], m[118], mt[118]), mul(v[3], m[119], mt[119]))))));

  190. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2 + d3), psi + 2 * (I + d2 + d3), add(tmp[6], add(mul(v[0], m[120], mt[120]), add(mul(v[1], m[121], mt[121]), add(mul(v[2], m[122], mt[122]), mul(v[3], m[123], mt[123]))))));

  191. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2 + d3), psi + 2 * (I + d1 + d2 + d3), add(tmp[7], add(mul(v[0], m[124], mt[124]), add(mul(v[1], m[125], mt[125]), add(mul(v[2], m[126], mt[126]), mul(v[3], m[127], mt[127]))))));

  192.  

  193.  }

  194.  

  195.  // bit indices id[.] are given from high to low (e.g. control first for CNOT)

  196.  template <class V, class M>

  197. -void kernel(V &psi, unsigned id3, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask)

  198. +void kernel(V &psi, unsigned id3, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)

  199.  {

  200. -    std::size_t n = psi.size();

  201. +    std::size_t n = len;

  202.      std::size_t d0 = 1UL << id0;

  203.      std::size_t d1 = 1UL << id1;

  204.      std::size_t d2 = 1UL << id2;

  205. diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel5.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel5.hpp

  206. --- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/intrin/kernel5.hpp	2020-06-05 21:07:57.000000000 +0800

  207. +++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/intrin/kernel5.hpp	2021-04-19 18:04:05.541802882 +0800

  208. @@ -17,10 +17,10 @@

  209.  {

  210.      __m256d v[4];

  211.  

  212. -    v[0] = load2(&psi[I]);

  213. -    v[1] = load2(&psi[I + d0]);

  214. -    v[2] = load2(&psi[I + d1]);

  215. -    v[3] = load2(&psi[I + d0 + d1]);

  216. +    v[0] = load2(psi + 2 * I);

  217. +    v[1] = load2(psi + 2 * (I + d0));

  218. +    v[2] = load2(psi + 2 * (I + d1));

  219. +    v[3] = load2(psi + 2 * (I + d0 + d1));

  220.  

  221.      __m256d tmp[16];

  222.  

  223. @@ -41,10 +41,10 @@

  224.      tmp[14] = add(mul(v[0], m[56], mt[56]), add(mul(v[1], m[57], mt[57]), add(mul(v[2], m[58], mt[58]), mul(v[3], m[59], mt[59]))));

  225.      tmp[15] = add(mul(v[0], m[60], mt[60]), add(mul(v[1], m[61], mt[61]), add(mul(v[2], m[62], mt[62]), mul(v[3], m[63], mt[63]))));

  226.  

  227. -    v[0] = load2(&psi[I + d2]);

  228. -    v[1] = load2(&psi[I + d0 + d2]);

  229. -    v[2] = load2(&psi[I + d1 + d2]);

  230. -    v[3] = load2(&psi[I + d0 + d1 + d2]);

  231. +    v[0] = load2(psi + 2 * (I + d2));

  232. +    v[1] = load2(psi + 2 * (I + d0 + d2));

  233. +    v[2] = load2(psi + 2 * (I + d1 + d2));

  234. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d2));

  235.  

  236.      tmp[0] = add(tmp[0], add(mul(v[0], m[64], mt[64]), add(mul(v[1], m[65], mt[65]), add(mul(v[2], m[66], mt[66]), mul(v[3], m[67], mt[67])))));

  237.      tmp[1] = add(tmp[1], add(mul(v[0], m[68], mt[68]), add(mul(v[1], m[69], mt[69]), add(mul(v[2], m[70], mt[70]), mul(v[3], m[71], mt[71])))));

  238. @@ -63,10 +63,10 @@

  239.      tmp[14] = add(tmp[14], add(mul(v[0], m[120], mt[120]), add(mul(v[1], m[121], mt[121]), add(mul(v[2], m[122], mt[122]), mul(v[3], m[123], mt[123])))));

  240.      tmp[15] = add(tmp[15], add(mul(v[0], m[124], mt[124]), add(mul(v[1], m[125], mt[125]), add(mul(v[2], m[126], mt[126]), mul(v[3], m[127], mt[127])))));

  241.  

  242. -    v[0] = load2(&psi[I + d3]);

  243. -    v[1] = load2(&psi[I + d0 + d3]);

  244. -    v[2] = load2(&psi[I + d1 + d3]);

  245. -    v[3] = load2(&psi[I + d0 + d1 + d3]);

  246. +    v[0] = load2(psi + 2 * (I + d3));

  247. +    v[1] = load2(psi + 2 * (I + d0 + d3));

  248. +    v[2] = load2(psi + 2 * (I + d1 + d3));

  249. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d3));

  250.  

  251.      tmp[0] = add(tmp[0], add(mul(v[0], m[128], mt[128]), add(mul(v[1], m[129], mt[129]), add(mul(v[2], m[130], mt[130]), mul(v[3], m[131], mt[131])))));

  252.      tmp[1] = add(tmp[1], add(mul(v[0], m[132], mt[132]), add(mul(v[1], m[133], mt[133]), add(mul(v[2], m[134], mt[134]), mul(v[3], m[135], mt[135])))));

  253. @@ -85,10 +85,10 @@

  254.      tmp[14] = add(tmp[14], add(mul(v[0], m[184], mt[184]), add(mul(v[1], m[185], mt[185]), add(mul(v[2], m[186], mt[186]), mul(v[3], m[187], mt[187])))));

  255.      tmp[15] = add(tmp[15], add(mul(v[0], m[188], mt[188]), add(mul(v[1], m[189], mt[189]), add(mul(v[2], m[190], mt[190]), mul(v[3], m[191], mt[191])))));

  256.  

  257. -    v[0] = load2(&psi[I + d2 + d3]);

  258. -    v[1] = load2(&psi[I + d0 + d2 + d3]);

  259. -    v[2] = load2(&psi[I + d1 + d2 + d3]);

  260. -    v[3] = load2(&psi[I + d0 + d1 + d2 + d3]);

  261. +    v[0] = load2(psi + 2 * (I + d2 + d3));

  262. +    v[1] = load2(psi + 2 * (I + d0 + d2 + d3));

  263. +    v[2] = load2(psi + 2 * (I + d1 + d2 + d3));

  264. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d2 + d3));

  265.  

  266.      tmp[0] = add(tmp[0], add(mul(v[0], m[192], mt[192]), add(mul(v[1], m[193], mt[193]), add(mul(v[2], m[194], mt[194]), mul(v[3], m[195], mt[195])))));

  267.      tmp[1] = add(tmp[1], add(mul(v[0], m[196], mt[196]), add(mul(v[1], m[197], mt[197]), add(mul(v[2], m[198], mt[198]), mul(v[3], m[199], mt[199])))));

  268. @@ -107,10 +107,10 @@

  269.      tmp[14] = add(tmp[14], add(mul(v[0], m[248], mt[248]), add(mul(v[1], m[249], mt[249]), add(mul(v[2], m[250], mt[250]), mul(v[3], m[251], mt[251])))));

  270.      tmp[15] = add(tmp[15], add(mul(v[0], m[252], mt[252]), add(mul(v[1], m[253], mt[253]), add(mul(v[2], m[254], mt[254]), mul(v[3], m[255], mt[255])))));

  271.  

  272. -    v[0] = load2(&psi[I + d4]);

  273. -    v[1] = load2(&psi[I + d0 + d4]);

  274. -    v[2] = load2(&psi[I + d1 + d4]);

  275. -    v[3] = load2(&psi[I + d0 + d1 + d4]);

  276. +    v[0] = load2(psi + 2 * (I + d4));

  277. +    v[1] = load2(psi + 2 * (I + d0 + d4));

  278. +    v[2] = load2(psi + 2 * (I + d1 + d4));

  279. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d4));

  280.  

  281.      tmp[0] = add(tmp[0], add(mul(v[0], m[256], mt[256]), add(mul(v[1], m[257], mt[257]), add(mul(v[2], m[258], mt[258]), mul(v[3], m[259], mt[259])))));

  282.      tmp[1] = add(tmp[1], add(mul(v[0], m[260], mt[260]), add(mul(v[1], m[261], mt[261]), add(mul(v[2], m[262], mt[262]), mul(v[3], m[263], mt[263])))));

  283. @@ -129,10 +129,10 @@

  284.      tmp[14] = add(tmp[14], add(mul(v[0], m[312], mt[312]), add(mul(v[1], m[313], mt[313]), add(mul(v[2], m[314], mt[314]), mul(v[3], m[315], mt[315])))));

  285.      tmp[15] = add(tmp[15], add(mul(v[0], m[316], mt[316]), add(mul(v[1], m[317], mt[317]), add(mul(v[2], m[318], mt[318]), mul(v[3], m[319], mt[319])))));

  286.  

  287. -    v[0] = load2(&psi[I + d2 + d4]);

  288. -    v[1] = load2(&psi[I + d0 + d2 + d4]);

  289. -    v[2] = load2(&psi[I + d1 + d2 + d4]);

  290. -    v[3] = load2(&psi[I + d0 + d1 + d2 + d4]);

  291. +    v[0] = load2(psi + 2 * (I + d2 + d4));

  292. +    v[1] = load2(psi + 2 * (I + d0 + d2 + d4));

  293. +    v[2] = load2(psi + 2 * (I + d1 + d2 + d4));

  294. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d2 + d4));

  295.  

  296.      tmp[0] = add(tmp[0], add(mul(v[0], m[320], mt[320]), add(mul(v[1], m[321], mt[321]), add(mul(v[2], m[322], mt[322]), mul(v[3], m[323], mt[323])))));

  297.      tmp[1] = add(tmp[1], add(mul(v[0], m[324], mt[324]), add(mul(v[1], m[325], mt[325]), add(mul(v[2], m[326], mt[326]), mul(v[3], m[327], mt[327])))));

  298. @@ -151,10 +151,10 @@

  299.      tmp[14] = add(tmp[14], add(mul(v[0], m[376], mt[376]), add(mul(v[1], m[377], mt[377]), add(mul(v[2], m[378], mt[378]), mul(v[3], m[379], mt[379])))));

  300.      tmp[15] = add(tmp[15], add(mul(v[0], m[380], mt[380]), add(mul(v[1], m[381], mt[381]), add(mul(v[2], m[382], mt[382]), mul(v[3], m[383], mt[383])))));

  301.  

  302. -    v[0] = load2(&psi[I + d3 + d4]);

  303. -    v[1] = load2(&psi[I + d0 + d3 + d4]);

  304. -    v[2] = load2(&psi[I + d1 + d3 + d4]);

  305. -    v[3] = load2(&psi[I + d0 + d1 + d3 + d4]);

  306. +    v[0] = load2(psi + 2 * (I + d3 + d4));

  307. +    v[1] = load2(psi + 2 * (I + d0 + d3 + d4));

  308. +    v[2] = load2(psi + 2 * (I + d1 + d3 + d4));

  309. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d3 + d4));

  310.  

  311.      tmp[0] = add(tmp[0], add(mul(v[0], m[384], mt[384]), add(mul(v[1], m[385], mt[385]), add(mul(v[2], m[386], mt[386]), mul(v[3], m[387], mt[387])))));

  312.      tmp[1] = add(tmp[1], add(mul(v[0], m[388], mt[388]), add(mul(v[1], m[389], mt[389]), add(mul(v[2], m[390], mt[390]), mul(v[3], m[391], mt[391])))));

  313. @@ -173,35 +173,35 @@

  314.      tmp[14] = add(tmp[14], add(mul(v[0], m[440], mt[440]), add(mul(v[1], m[441], mt[441]), add(mul(v[2], m[442], mt[442]), mul(v[3], m[443], mt[443])))));

  315.      tmp[15] = add(tmp[15], add(mul(v[0], m[444], mt[444]), add(mul(v[1], m[445], mt[445]), add(mul(v[2], m[446], mt[446]), mul(v[3], m[447], mt[447])))));

  316.  

  317. -    v[0] = load2(&psi[I + d2 + d3 + d4]);

  318. -    v[1] = load2(&psi[I + d0 + d2 + d3 + d4]);

  319. -    v[2] = load2(&psi[I + d1 + d2 + d3 + d4]);

  320. -    v[3] = load2(&psi[I + d0 + d1 + d2 + d3 + d4]);

  321. -

  322. -    _mm256_storeu2_m128d((double*)&psi[I + d0], (double*)&psi[I], add(tmp[0], add(mul(v[0], m[448], mt[448]), add(mul(v[1], m[449], mt[449]), add(mul(v[2], m[450], mt[450]), mul(v[3], m[451], mt[451]))))));

  323. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1], (double*)&psi[I + d1], add(tmp[1], add(mul(v[0], m[452], mt[452]), add(mul(v[1], m[453], mt[453]), add(mul(v[2], m[454], mt[454]), mul(v[3], m[455], mt[455]))))));

  324. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d2], (double*)&psi[I + d2], add(tmp[2], add(mul(v[0], m[456], mt[456]), add(mul(v[1], m[457], mt[457]), add(mul(v[2], m[458], mt[458]), mul(v[3], m[459], mt[459]))))));

  325. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2], (double*)&psi[I + d1 + d2], add(tmp[3], add(mul(v[0], m[460], mt[460]), add(mul(v[1], m[461], mt[461]), add(mul(v[2], m[462], mt[462]), mul(v[3], m[463], mt[463]))))));

  326. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d3], (double*)&psi[I + d3], add(tmp[4], add(mul(v[0], m[464], mt[464]), add(mul(v[1], m[465], mt[465]), add(mul(v[2], m[466], mt[466]), mul(v[3], m[467], mt[467]))))));

  327. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d3], (double*)&psi[I + d1 + d3], add(tmp[5], add(mul(v[0], m[468], mt[468]), add(mul(v[1], m[469], mt[469]), add(mul(v[2], m[470], mt[470]), mul(v[3], m[471], mt[471]))))));

  328. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d2 + d3], (double*)&psi[I + d2 + d3], add(tmp[6], add(mul(v[0], m[472], mt[472]), add(mul(v[1], m[473], mt[473]), add(mul(v[2], m[474], mt[474]), mul(v[3], m[475], mt[475]))))));

  329. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2 + d3], (double*)&psi[I + d1 + d2 + d3], add(tmp[7], add(mul(v[0], m[476], mt[476]), add(mul(v[1], m[477], mt[477]), add(mul(v[2], m[478], mt[478]), mul(v[3], m[479], mt[479]))))));

  330. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d4], (double*)&psi[I + d4], add(tmp[8], add(mul(v[0], m[480], mt[480]), add(mul(v[1], m[481], mt[481]), add(mul(v[2], m[482], mt[482]), mul(v[3], m[483], mt[483]))))));

  331. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d4], (double*)&psi[I + d1 + d4], add(tmp[9], add(mul(v[0], m[484], mt[484]), add(mul(v[1], m[485], mt[485]), add(mul(v[2], m[486], mt[486]), mul(v[3], m[487], mt[487]))))));

  332. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d2 + d4], (double*)&psi[I + d2 + d4], add(tmp[10], add(mul(v[0], m[488], mt[488]), add(mul(v[1], m[489], mt[489]), add(mul(v[2], m[490], mt[490]), mul(v[3], m[491], mt[491]))))));

  333. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2 + d4], (double*)&psi[I + d1 + d2 + d4], add(tmp[11], add(mul(v[0], m[492], mt[492]), add(mul(v[1], m[493], mt[493]), add(mul(v[2], m[494], mt[494]), mul(v[3], m[495], mt[495]))))));

  334. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d3 + d4], (double*)&psi[I + d3 + d4], add(tmp[12], add(mul(v[0], m[496], mt[496]), add(mul(v[1], m[497], mt[497]), add(mul(v[2], m[498], mt[498]), mul(v[3], m[499], mt[499]))))));

  335. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d3 + d4], (double*)&psi[I + d1 + d3 + d4], add(tmp[13], add(mul(v[0], m[500], mt[500]), add(mul(v[1], m[501], mt[501]), add(mul(v[2], m[502], mt[502]), mul(v[3], m[503], mt[503]))))));

  336. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d2 + d3 + d4], (double*)&psi[I + d2 + d3 + d4], add(tmp[14], add(mul(v[0], m[504], mt[504]), add(mul(v[1], m[505], mt[505]), add(mul(v[2], m[506], mt[506]), mul(v[3], m[507], mt[507]))))));

  337. -    _mm256_storeu2_m128d((double*)&psi[I + d0 + d1 + d2 + d3 + d4], (double*)&psi[I + d1 + d2 + d3 + d4], add(tmp[15], add(mul(v[0], m[508], mt[508]), add(mul(v[1], m[509], mt[509]), add(mul(v[2], m[510], mt[510]), mul(v[3], m[511], mt[511]))))));

  338. +    v[0] = load2(psi + 2 * (I + d2 + d3 + d4));

  339. +    v[1] = load2(psi + 2 * (I + d0 + d2 + d3 + d4));

  340. +    v[2] = load2(psi + 2 * (I + d1 + d2 + d3 + d4));

  341. +    v[3] = load2(psi + 2 * (I + d0 + d1 + d2 + d3 + d4));

  342. +

  343. +    _mm256_storeu2_m128d(psi + 2 * (I + d0), psi + 2 * I, add(tmp[0], add(mul(v[0], m[448], mt[448]), add(mul(v[1], m[449], mt[449]), add(mul(v[2], m[450], mt[450]), mul(v[3], m[451], mt[451]))))));

  344. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1), psi + 2 * (I + d1), add(tmp[1], add(mul(v[0], m[452], mt[452]), add(mul(v[1], m[453], mt[453]), add(mul(v[2], m[454], mt[454]), mul(v[3], m[455], mt[455]))))));

  345. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2), psi + 2 * (I + d2), add(tmp[2], add(mul(v[0], m[456], mt[456]), add(mul(v[1], m[457], mt[457]), add(mul(v[2], m[458], mt[458]), mul(v[3], m[459], mt[459]))))));

  346. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2), psi + 2 * (I + d1 + d2), add(tmp[3], add(mul(v[0], m[460], mt[460]), add(mul(v[1], m[461], mt[461]), add(mul(v[2], m[462], mt[462]), mul(v[3], m[463], mt[463]))))));

  347. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d3), psi + 2 * (I + d3), add(tmp[4], add(mul(v[0], m[464], mt[464]), add(mul(v[1], m[465], mt[465]), add(mul(v[2], m[466], mt[466]), mul(v[3], m[467], mt[467]))))));

  348. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d3), psi + 2 * (I + d1 + d3), add(tmp[5], add(mul(v[0], m[468], mt[468]), add(mul(v[1], m[469], mt[469]), add(mul(v[2], m[470], mt[470]), mul(v[3], m[471], mt[471]))))));

  349. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2 + d3), psi + 2 * (I + d2 + d3), add(tmp[6], add(mul(v[0], m[472], mt[472]), add(mul(v[1], m[473], mt[473]), add(mul(v[2], m[474], mt[474]), mul(v[3], m[475], mt[475]))))));

  350. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2 + d3), psi + 2 * (I + d1 + d2 + d3), add(tmp[7], add(mul(v[0], m[476], mt[476]), add(mul(v[1], m[477], mt[477]), add(mul(v[2], m[478], mt[478]), mul(v[3], m[479], mt[479]))))));

  351. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d4), psi + 2 * (I + d4), add(tmp[8], add(mul(v[0], m[480], mt[480]), add(mul(v[1], m[481], mt[481]), add(mul(v[2], m[482], mt[482]), mul(v[3], m[483], mt[483]))))));

  352. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d4), psi + 2 * (I + d1 + d4), add(tmp[9], add(mul(v[0], m[484], mt[484]), add(mul(v[1], m[485], mt[485]), add(mul(v[2], m[486], mt[486]), mul(v[3], m[487], mt[487]))))));

  353. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2 + d4), psi + 2 * (I + d2 + d4), add(tmp[10], add(mul(v[0], m[488], mt[488]), add(mul(v[1], m[489], mt[489]), add(mul(v[2], m[490], mt[490]), mul(v[3], m[491], mt[491]))))));

  354. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2 + d4), psi + 2 * (I + d1 + d2 + d4), add(tmp[11], add(mul(v[0], m[492], mt[492]), add(mul(v[1], m[493], mt[493]), add(mul(v[2], m[494], mt[494]), mul(v[3], m[495], mt[495]))))));

  355. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d3 + d4), psi + 2 * (I + d3 + d4), add(tmp[12], add(mul(v[0], m[496], mt[496]), add(mul(v[1], m[497], mt[497]), add(mul(v[2], m[498], mt[498]), mul(v[3], m[499], mt[499]))))));

  356. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d3 + d4), psi + 2 * (I + d1 + d3 + d4), add(tmp[13], add(mul(v[0], m[500], mt[500]), add(mul(v[1], m[501], mt[501]), add(mul(v[2], m[502], mt[502]), mul(v[3], m[503], mt[503]))))));

  357. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d2 + d3 + d4), psi + 2 * (I + d2 + d3 + d4), add(tmp[14], add(mul(v[0], m[504], mt[504]), add(mul(v[1], m[505], mt[505]), add(mul(v[2], m[506], mt[506]), mul(v[3], m[507], mt[507]))))));

  358. +    _mm256_storeu2_m128d(psi + 2 * (I + d0 + d1 + d2 + d3 + d4), psi + 2 * (I + d1 + d2 + d3 + d4), add(tmp[15], add(mul(v[0], m[508], mt[508]), add(mul(v[1], m[509], mt[509]), add(mul(v[2], m[510], mt[510]), mul(v[3], m[511], mt[511]))))));

  359.  

  360.  }

  361.  

  362.  // bit indices id[.] are given from high to low (e.g. control first for CNOT)

  363.  template <class V, class M>

  364. -void kernel(V &psi, unsigned id4, unsigned id3, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask)

  365. +void kernel(V &psi, unsigned id4, unsigned id3, unsigned id2, unsigned id1, unsigned id0, M const& m, std::size_t ctrlmask, unsigned len)

  366.  {

  367. -    std::size_t n = psi.size();

  368. +    std::size_t n = len;

  369.      std::size_t d0 = 1UL << id0;

  370.      std::size_t d1 = 1UL << id1;

  371.      std::size_t d2 = 1UL << id2;

  372. diff --color -aur ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/simulator.hpp ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/simulator.hpp

  373. --- ProjectQ-0.5.1/projectq/backends/_sim/_cppkernels/simulator.hpp	2020-06-05 21:07:57.000000000 +0800

  374. +++ ProjectQ-0.5.1_new/projectq/backends/_sim/_cppkernels/simulator.hpp	2021-04-20 11:46:27.115554725 +0800

  375. @@ -18,11 +18,7 @@

  376.  #include <vector>

  377.  #include <complex>

  378.  

  379. -#if defined(NOINTRIN) || !defined(INTRIN)

  380. -#include "nointrin/kernels.hpp"

  381. -#else

  382.  #include "intrin/kernels.hpp"

  383. -#endif

  384.  

  385.  #include "intrin/alignedallocator.hpp"

  386.  #include "fusion.hpp"

  387. @@ -32,173 +28,29 @@

  388.  #include <tuple>

  389.  #include <random>

  390.  #include <functional>

  391. -

  392. +#include <cstring>

  393.  

  394.  class Simulator{

  395.  public:

  396.      using calc_type = double;

  397.      using complex_type = std::complex<calc_type>;

  398. -    using StateVector = std::vector<complex_type, aligned_allocator<complex_type,512>>;

  399. +    using StateVector = calc_type *;

  400.      using Map = std::map<unsigned, unsigned>;

  401.      using RndEngine = std::mt19937;

  402.      using Term = std::vector<std::pair<unsigned, char>>;

  403.      using TermsDict = std::vector<std::pair<Term, calc_type>>;

  404.      using ComplexTermsDict = std::vector<std::pair<Term, complex_type>>;

  405. +    StateVector vec_;

  406.  

  407. -    Simulator(unsigned seed = 1) : N_(0), vec_(1,0.), fusion_qubits_min_(4),

  408. +    Simulator(unsigned seed = 1, unsigned N = 0) : N_(N), fusion_qubits_min_(4),

  409.                                     fusion_qubits_max_(5), rnd_eng_(seed) {

  410. +        len_ = 1UL << (N_ + 1);

  411. +        vec_ = (StateVector)calloc(len_, sizeof(calc_type));

  412.          vec_[0]=1.; // all-zero initial state

  413.          std::uniform_real_distribution<double> dist(0., 1.);

  414.          rng_ = std::bind(dist, std::ref(rnd_eng_));

  415. -    }

  416. -

  417. -    void allocate_qubit(unsigned id){

  418. -        if (map_.count(id) == 0){

  419. -            map_[id] = N_++;

  420. -            StateVector newvec; // avoid large memory allocations

  421. -            if( tmpBuff1_.capacity() >= (1UL << N_) )

  422. -              std::swap(newvec, tmpBuff1_);

  423. -            newvec.resize(1UL << N_);

  424. -#pragma omp parallel for schedule(static)

  425. -            for (std::size_t i = 0; i < newvec.size(); ++i)

  426. -                newvec[i] = (i < vec_.size())?vec_[i]:0.;

  427. -            std::swap(vec_, newvec);

  428. -            // recycle large memory

  429. -            std::swap(tmpBuff1_, newvec);

  430. -            if( tmpBuff1_.capacity() < tmpBuff2_.capacity() )

  431. -              std::swap(tmpBuff1_, tmpBuff2_);

  432. -        }

  433. -        else

  434. -            throw(std::runtime_error(

  435. -                "AllocateQubit: ID already exists. Qubit IDs should be unique."));

  436. -    }

  437. -

  438. -    bool get_classical_value(unsigned id, calc_type tol = 1.e-12){

  439. -        run();

  440. -        unsigned pos = map_[id];

  441. -        std::size_t delta = (1UL << pos);

  442. -

  443. -        for (std::size_t i = 0; i < vec_.size(); i += 2*delta){

  444. -            for (std::size_t j = 0; j < delta; ++j){

  445. -                if (std::norm(vec_[i+j]) > tol)

  446. -                    return false;

  447. -                if (std::norm(vec_[i+j+delta]) > tol)

  448. -                    return true;

  449. -            }

  450. -        }

  451. -        assert(false); // this will never happen

  452. -        return false; // suppress 'control reaches end of non-void...'

  453. -    }

  454. -

  455. -    bool is_classical(unsigned id, calc_type tol = 1.e-12){

  456. -        run();

  457. -        unsigned pos = map_[id];

  458. -        std::size_t delta = (1UL << pos);

  459. -

  460. -        short up = 0, down = 0;

  461. -        #pragma omp parallel for schedule(static) reduction(|:up,down)

  462. -        for (std::size_t i = 0; i < vec_.size(); i += 2*delta){

  463. -            for (std::size_t j = 0; j < delta; ++j){

  464. -                up = up | ((std::norm(vec_[i+j]) > tol)&1);

  465. -                down = down | ((std::norm(vec_[i+j+delta]) > tol)&1);

  466. -            }

  467. -        }

  468. -

  469. -        return 1 == (up^down);

  470. -    }

  471. -

  472. -    void collapse_vector(unsigned id, bool value = false, bool shrink = false){

  473. -        run();

  474. -        unsigned pos = map_[id];

  475. -        std::size_t delta = (1UL << pos);

  476. -

  477. -        if (!shrink){

  478. -            #pragma omp parallel for schedule(static)

  479. -            for (std::size_t i = 0; i < vec_.size(); i += 2*delta){

  480. -                for (std::size_t j = 0; j < delta; ++j)

  481. -                    vec_[i+j+static_cast<std::size_t>(!value)*delta] = 0.;

  482. -            }

  483. -        }

  484. -        else{

  485. -            StateVector newvec; // avoid costly memory reallocations

  486. -            if( tmpBuff1_.capacity() >= (1UL << (N_-1)) )

  487. -              std::swap(tmpBuff1_, newvec);

  488. -            newvec.resize((1UL << (N_-1)));

  489. -            #pragma omp parallel for schedule(static) if(0)

  490. -            for (std::size_t i = 0; i < vec_.size(); i += 2*delta)

  491. -                std::copy_n(&vec_[i + static_cast<std::size_t>(value)*delta],

  492. -                            delta, &newvec[i/2]);

  493. -            std::swap(vec_, newvec);

  494. -            std::swap(tmpBuff1_, newvec);

  495. -            if( tmpBuff1_.capacity() < tmpBuff2_.capacity() )

  496. -              std::swap(tmpBuff1_, tmpBuff2_);

  497. -

  498. -            for (auto& p : map_){

  499. -                if (p.second > pos)

  500. -                    p.second--;

  501. -            }

  502. -            map_.erase(id);

  503. -            N_--;

  504. -        }

  505. -    }

  506. -

  507. -    void measure_qubits(std::vector<unsigned> const& ids, std::vector<bool> &res){

  508. -        run();

  509. -

  510. -        std::vector<unsigned> positions(ids.size());

  511. -        for (unsigned i = 0; i < ids.size(); ++i)

  512. -            positions[i] = map_[ids[i]];

  513. -

  514. -        calc_type P = 0.;

  515. -        calc_type rnd = rng_();

  516. -

  517. -        // pick entry at random with probability |entry|^2

  518. -        std::size_t pick = 0;

  519. -        while (P < rnd && pick < vec_.size())

  520. -            P += std::norm(vec_[pick++]);

  521. -

  522. -        pick--;

  523. -        // determine result vector (boolean values for each qubit)

  524. -        // and create mask to detect bad entries (i.e., entries that don't agree with measurement)

  525. -        res = std::vector<bool>(ids.size());

  526. -        std::size_t mask = 0;

  527. -        std::size_t val = 0;

  528. -        for (unsigned i = 0; i < ids.size(); ++i){

  529. -            bool r = ((pick >> positions[i]) & 1) == 1;

  530. -            res[i] = r;

  531. -            mask |= (1UL << positions[i]);

  532. -            val |= (static_cast<std::size_t>(r&1) << positions[i]);

  533. -        }

  534. -        // set bad entries to 0

  535. -        calc_type N = 0.;

  536. -        #pragma omp parallel for reduction(+:N) schedule(static)

  537. -        for (std::size_t i = 0; i < vec_.size(); ++i){

  538. -            if ((i & mask) != val)

  539. -                vec_[i] = 0.;

  540. -            else

  541. -                N += std::norm(vec_[i]);

  542. -        }

  543. -        // re-normalize

  544. -        N = 1./std::sqrt(N);

  545. -        #pragma omp parallel for schedule(static)

  546. -        for (std::size_t i = 0; i < vec_.size(); ++i)

  547. -            vec_[i] *= N;

  548. -    }

  549. -

  550. -    std::vector<bool> measure_qubits_return(std::vector<unsigned> const& ids){

  551. -        std::vector<bool> ret;

  552. -        measure_qubits(ids, ret);

  553. -        return ret;

  554. -    }

  555. -

  556. -    void deallocate_qubit(unsigned id){

  557. -        run();

  558. -        assert(map_.count(id) == 1);

  559. -        if (!is_classical(id))

  560. -            throw(std::runtime_error("Error: Qubit has not been measured / uncomputed! There is most likely a bug in your code."));

  561. -

  562. -        bool value = get_classical_value(id);

  563. -        collapse_vector(id, value, true);

  564. +        for (unsigned i = 0; i < N_; i++)

  565. +            map_[i] = i;

  566.      }

  567.  

  568.      template <class M>

  569. @@ -221,84 +73,13 @@

  570.              fused_gates_ = fused_gates;

  571.      }

  572.  

  573. -    template <class F, class QuReg>

  574. -    void emulate_math(F const& f, QuReg quregs, const std::vector<unsigned>& ctrl,

  575. -                      bool parallelize = false){

  576. -        run();

  577. -        auto ctrlmask = get_control_mask(ctrl);

  578. -

  579. -        for (unsigned i = 0; i < quregs.size(); ++i)

  580. -            for (unsigned j = 0; j < quregs[i].size(); ++j)

  581. -                quregs[i][j] = map_[quregs[i][j]];

  582. -

  583. -        StateVector newvec; // avoid costly memory reallocations

  584. -        if( tmpBuff1_.capacity() >= vec_.size() )

  585. -          std::swap(newvec, tmpBuff1_);

  586. -        newvec.resize(vec_.size());

  587. -#pragma omp parallel for schedule(static)

  588. -        for (std::size_t i = 0; i < vec_.size(); i++)

  589. -          newvec[i] = 0;

  590. -

  591. -//#pragma omp parallel reduction(+:newvec[:newvec.size()]) if(parallelize) // requires OpenMP 4.5

  592. -        {

  593. -          std::vector<int> res(quregs.size());

  594. -          //#pragma omp for schedule(static)

  595. -          for (std::size_t i = 0; i < vec_.size(); ++i){

  596. -              if ((ctrlmask&i) == ctrlmask){

  597. -                  for (unsigned qr_i = 0; qr_i < quregs.size(); ++qr_i){

  598. -                      res[qr_i] = 0;

  599. -                      for (unsigned qb_i = 0; qb_i < quregs[qr_i].size(); ++qb_i)

  600. -                          res[qr_i] |= ((i >> quregs[qr_i][qb_i])&1) << qb_i;

  601. -                  }

  602. -                  f(res);

  603. -                  auto new_i = i;

  604. -                  for (unsigned qr_i = 0; qr_i < quregs.size(); ++qr_i){

  605. -                      for (unsigned qb_i = 0; qb_i < quregs[qr_i].size(); ++qb_i){

  606. -                          if (!(((new_i >> quregs[qr_i][qb_i])&1) == ((res[qr_i] >> qb_i)&1)))

  607. -                              new_i ^= (1UL << quregs[qr_i][qb_i]);

  608. -                      }

  609. -                  }

  610. -                  newvec[new_i] += vec_[i];

  611. -              }

  612. -              else

  613. -                  newvec[i] += vec_[i];

  614. -          }

  615. -        }

  616. -        std::swap(vec_, newvec);

  617. -        std::swap(tmpBuff1_, newvec);

  618. -    }

  619. -

  620. -    // faster version without calling python 

  621. -    template<class QuReg>

  622. -    inline void emulate_math_addConstant(int a, const QuReg& quregs, const std::vector<unsigned>& ctrl)

  623. -    {

  624. -      emulate_math([a](std::vector<int> &res){for(auto& x: res) x = x + a;}, quregs, ctrl, true);

  625. -    }

  626. -

  627. -    // faster version without calling python 

  628. -    template<class QuReg>

  629. -    inline void emulate_math_addConstantModN(int a, int N, const QuReg& quregs, const std::vector<unsigned>& ctrl)

  630. -    {

  631. -      emulate_math([a,N](std::vector<int> &res){for(auto& x: res) x = (x + a) % N;}, quregs, ctrl, true);

  632. -    }

  633. -

  634. -    // faster version without calling python 

  635. -    template<class QuReg>

  636. -    inline void emulate_math_multiplyByConstantModN(int a, int N, const QuReg& quregs, const std::vector<unsigned>& ctrl)

  637. -    {

  638. -      emulate_math([a,N](std::vector<int> &res){for(auto& x: res) x = (x * a) % N;}, quregs, ctrl, true);

  639. -    }

  640. -

  641.      calc_type get_expectation_value(TermsDict const& td, std::vector<unsigned> const& ids){

  642.          run();

  643.          calc_type expectation = 0.;

  644.  

  645. -        StateVector current_state; // avoid costly memory reallocations

  646. -        if( tmpBuff1_.capacity() >= vec_.size() )

  647. -          std::swap(tmpBuff1_, current_state);

  648. -        current_state.resize(vec_.size());

  649. +        StateVector current_state = (StateVector)malloc(len_ *sizeof(calc_type));

  650.  #pragma omp parallel for schedule(static)

  651. -        for (std::size_t i = 0; i < vec_.size(); ++i)

  652. +        for (std::size_t i = 0; i < len_; ++i)

  653.            current_state[i] = vec_[i];

  654.  

  655.          for (auto const& term : td){

  656. @@ -306,81 +87,53 @@

  657.              apply_term(term.first, ids, {});

  658.              calc_type delta = 0.;

  659.              #pragma omp parallel for reduction(+:delta) schedule(static)

  660. -            for (std::size_t i = 0; i < vec_.size(); ++i){

  661. -                auto const a1 = std::real(current_state[i]);

  662. -                auto const b1 = -std::imag(current_state[i]);

  663. -                auto const a2 = std::real(vec_[i]);

  664. -                auto const b2 = std::imag(vec_[i]);

  665. +            for (std::size_t i = 0; i < (len_ >> 1); ++i){

  666. +                auto const a1 = current_state[2 * i];

  667. +                auto const b1 = -current_state[2 * i + 1];

  668. +                auto const a2 = vec_[2 * i];

  669. +                auto const b2 = vec_[2 * i + 1];

  670.                  delta += a1 * a2 - b1 * b2;

  671.                  // reset vec_

  672. -                vec_[i] = current_state[i];

  673. +                vec_[2 * i] = current_state[2 * i];

  674. +                vec_[2 * i + 1] = current_state[2 * i + 1];

  675.              }

  676.              expectation += coefficient * delta;

  677.          }

  678. -        std::swap(current_state, tmpBuff1_);

  679. +        if (NULL != current_state){

  680. +            free(current_state);

  681. +            current_state = NULL;

  682. +        }

  683.          return expectation;

  684.      }

  685.  

  686.      void apply_qubit_operator(ComplexTermsDict const& td, std::vector<unsigned> const& ids){

  687.          run();

  688. -        StateVector new_state, current_state; // avoid costly memory reallocations

  689. -        if( tmpBuff1_.capacity() >= vec_.size() )

  690. -          std::swap(tmpBuff1_, new_state);

  691. -        if( tmpBuff2_.capacity() >= vec_.size() )

  692. -          std::swap(tmpBuff2_, current_state);

  693. -        new_state.resize(vec_.size());

  694. -        current_state.resize(vec_.size());

  695. +        StateVector new_state = (StateVector)calloc(len_, sizeof(calc_type));

  696. +        StateVector current_state = (StateVector)malloc(len_ * sizeof(calc_type));

  697.  #pragma omp parallel for schedule(static)

  698. -        for (std::size_t i = 0; i < vec_.size(); ++i){

  699. -          new_state[i] = 0;

  700. +        for (std::size_t i = 0; i < len_; ++i){

  701.            current_state[i] = vec_[i];

  702.          }

  703.          for (auto const& term : td){

  704.              auto const& coefficient = term.second;

  705.              apply_term(term.first, ids, {});

  706.              #pragma omp parallel for schedule(static)

  707. -            for (std::size_t i = 0; i < vec_.size(); ++i){

  708. -                new_state[i] += coefficient * vec_[i];

  709. -                vec_[i] = current_state[i];

  710. +            for (std::size_t i = 0; i < (len_ >> 1); ++i){

  711. +                new_state[2 * i] += coefficient.real() * vec_[2 * i] - coefficient.imag() * vec_[2 * i + 1];

  712. +                new_state[2 * i + 1] += coefficient.real() * vec_[2 * i + 1] + coefficient.imag() * vec_[2 * i];

  713. +                vec_[2 * i] = current_state[2 * i];

  714. +                vec_[2 * i + 1] = current_state[2 * i + 1];

  715.              }

  716.          }

  717. -        std::swap(vec_, new_state);

  718. -        std::swap(tmpBuff1_, new_state);

  719. -        std::swap(tmpBuff2_, current_state);

  720. -    }

  721. -

  722. -    calc_type get_probability(std::vector<bool> const& bit_string,

  723. -                              std::vector<unsigned> const& ids){

  724. -        run();

  725. -        if (!check_ids(ids))

  726. -            throw(std::runtime_error("get_probability(): Unknown qubit id. Please make sure you have called eng.flush()."));

  727. -        std::size_t mask = 0, bit_str = 0;

  728. -        for (unsigned i = 0; i < ids.size(); ++i){

  729. -            mask |= 1UL << map_[ids[i]];

  730. -            bit_str |= (bit_string[i]?1UL:0UL) << map_[ids[i]];

  731. -        }

  732. -        calc_type probability = 0.;

  733. -        #pragma omp parallel for reduction(+:probability) schedule(static)

  734. -        for (std::size_t i = 0; i < vec_.size(); ++i)

  735. -            if ((i & mask) == bit_str)

  736. -                probability += std::norm(vec_[i]);

  737. -        return probability;

  738. -    }

  739. -

  740. -    complex_type const& get_amplitude(std::vector<bool> const& bit_string,

  741. -                                      std::vector<unsigned> const& ids){

  742. -        run();

  743. -        std::size_t chk = 0;

  744. -        std::size_t index = 0;

  745. -        for (unsigned i = 0; i < ids.size(); ++i){

  746. -            if (map_.count(ids[i]) == 0)

  747. -                break;

  748. -            chk |= 1UL << map_[ids[i]];

  749. -            index |= (bit_string[i]?1UL:0UL) << map_[ids[i]];

  750. +        if (NULL != vec_)

  751. +            free(vec_);

  752. +        vec_ = new_state;

  753. +        if (NULL != new_state)

  754. +            new_state = NULL;

  755. +        if (NULL != current_state){

  756. +            free(current_state);

  757. +            current_state = NULL;

  758.          }

  759. -        if (chk + 1 != vec_.size())

  760. -            throw(std::runtime_error("The second argument to get_amplitude() must be a permutation of all allocated qubits. Please make sure you have called eng.flush()."));

  761. -        return vec_[index];

  762.      }

  763.  

  764.      void emulate_time_evolution(TermsDict const& tdict, calc_type const& time,

  765. @@ -400,87 +153,71 @@

  766.          }

  767.          unsigned s = std::abs(time) * op_nrm + 1.;

  768.          complex_type correction = std::exp(-time * I * tr / (double)s);

  769. -        auto output_state = vec_;

  770. +        auto output_state = copy(vec_, len_);

  771.          auto ctrlmask = get_control_mask(ctrl);

  772.          for (unsigned i = 0; i < s; ++i){

  773.              calc_type nrm_change = 1.;

  774.              for (unsigned k = 0; nrm_change > 1.e-12; ++k){

  775.                  auto coeff = (-time * I) / double(s * (k + 1));

  776. -                auto current_state = vec_;

  777. -                auto update = StateVector(vec_.size(), 0.);

  778. +                auto current_state = copy(vec_, len_);

  779. +                auto update = (StateVector)calloc(len_, sizeof(calc_type));

  780.                  for (auto const& tup : td){

  781.                      apply_term(tup.first, ids, {});

  782.                      #pragma omp parallel for schedule(static)

  783. -                    for (std::size_t j = 0; j < vec_.size(); ++j){

  784. +                    for (std::size_t j = 0; j < len_; ++j){

  785.                          update[j] += vec_[j] * tup.second;

  786.                          vec_[j] = current_state[j];

  787.                      }

  788.                  }

  789.                  nrm_change = 0.;

  790.                  #pragma omp parallel for reduction(+:nrm_change) schedule(static)

  791. -                for (std::size_t j = 0; j < vec_.size(); ++j){

  792. -                    update[j] *= coeff;

  793. -                    vec_[j] = update[j];

  794. +                for (std::size_t j = 0; j < (len_ >> 1); ++j){

  795. +                    complex_type tmp(update[2 * j], update[2 * j + 1]);

  796. +                    tmp *= coeff;

  797. +                    update[2 * j] *= std::real(tmp);

  798. +                    update[2 * j + 1] *= std::imag(tmp);

  799. +                    vec_[2 * j] = update[2 * j];

  800. +                    vec_[2 * j + 1] = update[2 * j + 1];

  801.                      if ((j & ctrlmask) == ctrlmask){

  802. -                        output_state[j] += update[j];

  803. -                        nrm_change += std::norm(update[j]);

  804. +                        output_state[2 * j] += update[2 * j];

  805. +                        output_state[2 * j + 1] += update[2 * j + 1];

  806. +                        nrm_change += std::sqrt(update[2 * j] * update[2 * j] + update[2 * j + 1] * update[2 * j + 1]);

  807.                      }

  808.                  }

  809.                  nrm_change = std::sqrt(nrm_change);

  810. +                if (NULL != current_state){

  811. +                    free(current_state);

  812. +                    current_state = NULL;

  813. +                }

  814. +                if (NULL != update){

  815. +                    free(update);

  816. +                    update = NULL;

  817. +                }

  818.              }

  819.              #pragma omp parallel for schedule(static)

  820. -            for (std::size_t j = 0; j < vec_.size(); ++j){

  821. -                if ((j & ctrlmask) == ctrlmask)

  822. -                    output_state[j] *= correction;

  823. -                vec_[j] = output_state[j];

  824. +            for (std::size_t j = 0; j < (len_ >>1); ++j){

  825. +                if ((j & ctrlmask) == ctrlmask){

  826. +                    complex_type tmp(output_state[2 * j], output_state[2 * j + 1]);

  827. +                    tmp *= correction;

  828. +                    output_state[2 * j] = std::real(tmp);

  829. +                    output_state[2 * j + 1] =std::imag(tmp);

  830. +                }

  831. +                vec_[2 * j] = output_state[2 * j];

  832. +                vec_[2 * j + 1] = output_state[2 * j + 1];

  833.              }

  834.          }

  835. +        if (NULL != output_state){

  836. +            free(output_state);

  837. +            output_state = NULL;

  838. +        }

  839.      }

  840.  

  841.      void set_wavefunction(StateVector const& wavefunction, std::vector<unsigned> const& ordering){

  842.          run();

  843. -        // make sure there are 2^n amplitudes for n qubits

  844. -        assert(wavefunction.size() == (1UL << ordering.size()));

  845. -        // check that all qubits have been allocated previously

  846. -        if (map_.size() != ordering.size() || !check_ids(ordering))

  847. -            throw(std::runtime_error("set_wavefunction(): Invalid mapping provided. Please make sure all qubits have been allocated previously (call eng.flush())."));

  848. -

  849. -        // set mapping and wavefunction

  850. -        for (unsigned i = 0; i < ordering.size(); ++i)

  851. -            map_[ordering[i]] = i;

  852. -        #pragma omp parallel for schedule(static)

  853. -        for (std::size_t i = 0; i < wavefunction.size(); ++i)

  854. -            vec_[i] = wavefunction[i];

  855. -    }

  856. -

  857. -    void collapse_wavefunction(std::vector<unsigned> const& ids, std::vector<bool> const& values){

  858. -        run();

  859. -        assert(ids.size() == values.size());

  860. -        if (!check_ids(ids))

  861. -            throw(std::runtime_error("collapse_wavefunction(): Unknown qubit id(s) provided. Try calling eng.flush() before invoking this function."));

  862. -        std::size_t mask = 0, val = 0;

  863. -        for (unsigned i = 0; i < ids.size(); ++i){

  864. -            mask |= (1UL << map_[ids[i]]);

  865. -            val |= ((values[i]?1UL:0UL) << map_[ids[i]]);

  866. -        }

  867. -        // set bad entries to 0 and compute probability of outcome to renormalize

  868. -        calc_type N = 0.;

  869. -        #pragma omp parallel for reduction(+:N) schedule(static)

  870. -        for (std::size_t i = 0; i < vec_.size(); ++i){

  871. -            if ((i & mask) == val)

  872. -                N += std::norm(vec_[i]);

  873. -        }

  874. -        if (N < 1.e-12)

  875. -            throw(std::runtime_error("collapse_wavefunction(): Invalid collapse! Probability is ~0."));

  876. -        // re-normalize (if possible)

  877. -        N = 1./std::sqrt(N);

  878. -        #pragma omp parallel for schedule(static)

  879. -        for (std::size_t i = 0; i < vec_.size(); ++i){

  880. -            if ((i & mask) != val)

  881. -                vec_[i] = 0.;

  882. -            else

  883. -                vec_[i] *= N;

  884. +        if (NULL != vec_){

  885. +          free(vec_);

  886.          }

  887. +        vec_ = copy(wavefunction, len_);

  888.      }

  889.  

  890.      void run(){

  891. @@ -500,23 +237,23 @@

  892.          switch (ids.size()){

  893.              case 1:

  894.                  #pragma omp parallel

  895. -                kernel(vec_, ids[0], m, ctrlmask);

  896. +                kernel(vec_, ids[0], m, ctrlmask, len_ >> 1);

  897.                  break;

  898.              case 2:

  899.                  #pragma omp parallel

  900. -                kernel(vec_, ids[1], ids[0], m, ctrlmask);

  901. +                kernel(vec_, ids[1], ids[0], m, ctrlmask, len_ >> 1);

  902.                  break;

  903.              case 3:

  904.                  #pragma omp parallel

  905. -                kernel(vec_, ids[2], ids[1], ids[0], m, ctrlmask);

  906. +                kernel(vec_, ids[2], ids[1], ids[0], m, ctrlmask, len_ >> 1);

  907.                  break;

  908.              case 4:

  909.                  #pragma omp parallel

  910. -                kernel(vec_, ids[3], ids[2], ids[1], ids[0], m, ctrlmask);

  911. +                kernel(vec_, ids[3], ids[2], ids[1], ids[0], m, ctrlmask, len_ >> 1);

  912.                  break;

  913.              case 5:

  914.                  #pragma omp parallel

  915. -                kernel(vec_, ids[4], ids[3], ids[2], ids[1], ids[0], m, ctrlmask);

  916. +                kernel(vec_, ids[4], ids[3], ids[2], ids[1], ids[0], m, ctrlmask, len_ >> 1);

  917.                  break;

  918.              default:

  919.                  throw std::invalid_argument("Gates with more than 5 qubits are not supported!");

  920. @@ -525,12 +262,27 @@

  921.          fused_gates_ = Fusion();

  922.      }

  923.  

  924. -    std::tuple<Map, StateVector&> cheat(){

  925. +    std::vector<complex_type> cheat(){

  926.          run();

  927. -        return make_tuple(map_, std::ref(vec_));

  928. +        std::vector<complex_type> result;

  929. +        for (unsigned int i = 0; i < (len_ >> 1); i++){

  930. +            result.push_back({vec_[2 * i], vec_[2 * i + 1]});

  931. +        }

  932. +        return result;

  933. +    }

  934. +

  935. +    inline StateVector copy(StateVector source, unsigned len){

  936. +    StateVector result = (StateVector)malloc(len * sizeof(calc_type));

  937. +#pragma omp parallel for schedule(static)

  938. +    for (std::size_t i = 0; i < len; ++i) {

  939. +      result[i] = source[i];

  940.      }

  941. +    return result;

  942. +}

  943.  

  944.      ~Simulator(){

  945. +        if (NULL != vec_)

  946. +            free(vec_);

  947.      }

  948.  

  949.  private:

  950. @@ -562,18 +314,13 @@

  951.      }

  952.  

  953.      unsigned N_; // #qubits

  954. -    StateVector vec_;

  955. +    unsigned len_;

  956.      Map map_;

  957.      Fusion fused_gates_;

  958.      unsigned fusion_qubits_min_, fusion_qubits_max_;

  959.      RndEngine rnd_eng_;

  960.      std::function<double()> rng_;

  961. -

  962. -    // large array buffers to avoid costly reallocations

  963. -    static StateVector tmpBuff1_, tmpBuff2_;

  964.  };

  965.  

  966. -Simulator::StateVector Simulator::tmpBuff1_;

  967. -Simulator::StateVector Simulator::tmpBuff2_;

  968.  

  969.  #endif