Translator and toolchain added.

qasm_parser/braket/qasm_braket_parser.py

@@ -0,0 +1,186 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import numpy as np\n')
+        f.write('from braket.circuits import Circuit\n')
+        f.write('from braket.devices import LocalSimulator\n')
+        f.write('from braket.circuits.gates import Unitary\n')
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return np.array(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return np.array(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('qc = Circuit()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.{}({})\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.v({})\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.vi({})\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('qc.add_{}gate({}, np.pi*{})\n'.format(s.group().upper(),  t_qbit, float(m_r[0][0])))
+                    f.write('qc.{}({}, np.pi*{})\n'.format(s.group(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('qc.cnot({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.unitary([{}], U2(np.pi*{}, np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.unitary([{}], U3(np.pi*{}, np.pi*{}, np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+
+        f.write('qc.state_vector()\n')
+        f.write('device = LocalSimulator()\n')
+        f.write('f_state = device.run(qc).result().values[0]\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "n12_qulacs.py")
+
+task = 'hdyn'
+sim_pack = 'braket'
+com_cap = 'st'
+prec = 'dp'
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+
+"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/cirq/qasm_cirq_parser.py

@@ -0,0 +1,205 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+import os
+
+def parse_qasm_to_package_gen(N, precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import cirq\n')
+
+        f.write('class U2(cirq.Gate):\n')
+        f.write('    def __init__(self, phi, lam):\n')
+        f.write('        super(U2, self)\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = ((np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))/np.sqrt(2))*np.array([[1, -np.cos(self._l)-1j*np.sin(self._l)], [np.cos(self._p) + 1j*np.sin(self._p), np.cos(self._l + self._p) + 1j*np.sin(self._l+self._p)]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('class U3(cirq.Gate):\n')
+        f.write('    def __init__(self, theta, phi, lam):\n')
+        f.write('        super(U3, self)\n')
+        f.write('        self._t = theta\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = (np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))*np.array([[np.cos(self._t/2.), -np.sin(self._t/2.)*(np.cos(self._l) + 1j*np.sin(self._l))], [np.sin(self._t/2.)*(np.cos(self._p) + 1j*np.sin(self._p)), np.cos(self._t/2.)*(np.cos(self._l + self._p) + 1j*np.sin(self._l + self._p))]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('q = cirq.LineQubit.range({})\n'.format(N))
+
+        f.write('cir = cirq.Circuit()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(q[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=-0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(np.pi*{}).on(q[{}]))\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.append(cirq.CNOT(q[{}], q[{}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        if precision == 'single':
+            f.write('simulator = cirq.Simulator()\n')
+        elif precision == 'double':
+            f.write('simulator = cirq.Simulator(dtype=np.complex128)\n')
+        f.write('result = simulator.simulate(cir)\n')
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(result.final_state_vector)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_cirq.py")
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/cirq/cirq_run_files/'
+    output_file = output_file_path + 'cirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/cirq/cirq_run_files/'
+    output_file = output_file_path + 'cirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+"""
+
+task = 'qft'
+sim_pack = 'cirq'
+com_cap = 'st'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 'single', input_file, output_file, save_file_path)
+

qasm_parser/cudaq/qasm_cudaq_parser.py

@@ -0,0 +1,177 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, comp_cap, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('import sys\n')
+        f.write('import numpy as np\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import cudaq\n')
+        if comp_cap == 'st' or comp_cap == 'mt':
+            f.write('cudaq.set_qpu(\'qpp\')\n')
+        elif comp_cap == 'gpu':
+            f.write('cudaq.set_qpu(\'cuquantum\')\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('cir = cudaq.make_kernel()\n'.format(N))
+        f.write('q = cir.qalloc({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}(q[{}])\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.rx(0.5*np.pi, q[{}])\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.rx(-0.5*np.pi, q[{}])\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}(np.pi*{}, q[{}])\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.cx(q[{}], q[{}])\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.U2(np.pi*{}, np.pi*{}, q[{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.U3(np.pi*{}, np.pi*{}, np.pi*{}, q[{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('state = cudaq.get_state(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+task = 'rqc'
+sim_pack = 'cudaq'
+com_cap = 'st'
+prec = 'sp'
+
+for N in range(12, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, com_cap, input_file, output_file, save_file_path)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim/svsim_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim/svsim_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+"""

qasm_parser/cuquantum_qiskit/qasm_qiskit_parser_gpu_2pt0_new.py

@@ -0,0 +1,163 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+import os
+
+def parse_qasm_to_package_gen(N, f_precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from qiskit import QuantumRegister, QuantumCircuit, transpile, ClassicalRegister\n')
+        f.write('from qiskit.quantum_info.operators import Operator\n')
+        f.write('from qiskit.providers.aer import QasmSimulator\n')
+        f.write('from qiskit import Aer\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        # f.write('backend = Aer.get_backend(\'statevector_simulator\')\n')#, max_parallel_threads={}, statevector_parallel_threshold={}, precision=\'{}\')\n'.format(mpt, spt, f_precision))
+        f.write('backend = Aer.get_backend(\'aer_simulator_statevector\')\n')
+        f.write('opt = backend.options\n')
+        f.write('opt.device=\'GPU\'\n')
+        f.write('opt.precision=\'{}\'\n'.format(f_precision))
+
+        f.write('cir = QuantumCircuit({})\n'.format(N))
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}({})\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}(np.pi*{}, {})\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.cx({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi/2., np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi*{}, np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('job = backend.run(transpile(cir, backend))\n')
+        f.write('result = job.result()\n')
+        # f.write('outputstate = result.get_statevector(cir)\n')
+        f.write('print(f\'backend: {result.backend_name}\')\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(outputstate)')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, 1, 42, "../qasm_test/qasm_rqc_test.qasm", "test_qiskit.py")
+# parse_qasm_to_package_gen(12, 1, 42, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qiskit_2.py")
+
+
+task = 'hdyn'
+sim_pack = 'cuquantum_qiskit'
+com_cap = 'gpu1'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, "single", input_file, output_file, save_file_path)

qasm_parser/cuquantum_qiskit/qasm_qiskit_parser_ngpu_2pt0_new.py

@@ -0,0 +1,163 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+import os
+
+def parse_qasm_to_package_gen(N, f_precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from qiskit import QuantumRegister, QuantumCircuit, transpile, ClassicalRegister\n')
+        f.write('from qiskit.quantum_info.operators import Operator\n')
+        f.write('from qiskit.providers.aer import QasmSimulator\n')
+        f.write('from qiskit import Aer\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        # f.write('backend = Aer.get_backend(\'statevector_simulator\')\n')#, max_parallel_threads={}, statevector_parallel_threshold={}, precision=\'{}\')\n'.format(mpt, spt, f_precision))
+        f.write('backend = Aer.get_backend(\'aer_simulator_statevector\')\n')
+        f.write('opt = backend.options\n')
+        f.write('opt.device=\'GPU\'\n')
+        f.write('opt.precision=\'{}\'\n'.format(f_precision))
+
+        f.write('cir = QuantumCircuit({})\n'.format(N))
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}({})\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}(np.pi*{}, {})\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.cx({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi/2., np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi*{}, np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('job = backend.run(transpile(cir, backend))\n')
+        f.write('result = job.result()\n')
+        # f.write('outputstate = result.get_statevector(cir)\n')
+        f.write('print(f\'backend: {result.backend_name}\')\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+        f.write('print(t_e - t_s)\n')
+        # f.write('print(t_ep - t_sp)\n')
+        # f.write('print(outputstate)')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, 1, 42, "../qasm_test/qasm_rqc_test.qasm", "test_qiskit.py")
+# parse_qasm_to_package_gen(12, 1, 42, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qiskit_2.py")
+
+
+task = 'qft'
+sim_pack = 'cuquantum_qiskit'
+com_cap = 'gpu8'
+prec = 'dp'
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, "double", input_file, output_file, save_file_path)

qasm_parser/cuquantum_qsimcirq/qasm_qsimcirq_gpu_parser.py

@@ -0,0 +1,210 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        # f.write('os.chdir(\'/sim_lib/qsimcirq/qsim/\')\n')
+        # f.write('cwd = os.getcwd()\n')
+        # f.write('import sys\n')
+        # f.write('sys.path.insert(0, \'\')\n')
+
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import cirq\n')
+        f.write('import qsimcirq\n')
+
+        f.write('class U2(cirq.Gate):\n')
+        f.write('    def __init__(self, phi, lam):\n')
+        f.write('        super(U2, self)\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = ((np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))/np.sqrt(2))*np.array([[1, -np.cos(self._l)-1j*np.sin(self._l)], [np.cos(self._p) + 1j*np.sin(self._p), np.cos(self._l + self._p) + 1j*np.sin(self._l+self._p)]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('class U3(cirq.Gate):\n')
+        f.write('    def __init__(self, theta, phi, lam):\n')
+        f.write('        super(U3, self)\n')
+        f.write('        self._t = theta\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = (np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))*np.array([[np.cos(self._t/2.), -np.sin(self._t/2.)*(np.cos(self._l) + 1j*np.sin(self._l))], [np.sin(self._t/2.)*(np.cos(self._p) + 1j*np.sin(self._p)), np.cos(self._t/2.)*(np.cos(self._l + self._p) + 1j*np.sin(self._l + self._p))]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('q = cirq.LineQubit.range({})\n'.format(N))
+
+        f.write('cir = cirq.Circuit()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(q[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=-0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(np.pi*{}).on(q[{}]))\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.append(cirq.CNOT(q[{}], q[{}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+
+        f.write('gpu_options = qsimcirq.QSimOptions(gpu_mode=1)\n')
+        f.write('qsim_simulator = qsimcirq.QSimSimulator(qsim_options=gpu_options)\n')
+        f.write('result = qsim_simulator.simulate(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(result.final_state_vector)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qsimcirq.py")
+
+task = 'hdyn'
+sim_pack = 'cuquantum_qsimcirq'
+com_cap = 'gpu1'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_gpu_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_gpu_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+"""

qasm_parser/cuquantum_qsimcirq/qasm_qsimcirq_ngpu_parser.py

@@ -0,0 +1,210 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path, cc):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        # f.write('os.chdir(\'/sim_lib/qsimcirq/qsim/\')\n')
+        # f.write('cwd = os.getcwd()\n')
+        # f.write('import sys\n')
+        # f.write('sys.path.insert(0, \'\')\n')
+
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import cirq\n')
+        f.write('import qsimcirq\n')
+
+        f.write('class U2(cirq.Gate):\n')
+        f.write('    def __init__(self, phi, lam):\n')
+        f.write('        super(U2, self)\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = ((np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))/np.sqrt(2))*np.array([[1, -np.cos(self._l)-1j*np.sin(self._l)], [np.cos(self._p) + 1j*np.sin(self._p), np.cos(self._l + self._p) + 1j*np.sin(self._l+self._p)]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('class U3(cirq.Gate):\n')
+        f.write('    def __init__(self, theta, phi, lam):\n')
+        f.write('        super(U3, self)\n')
+        f.write('        self._t = theta\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = (np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))*np.array([[np.cos(self._t/2.), -np.sin(self._t/2.)*(np.cos(self._l) + 1j*np.sin(self._l))], [np.sin(self._t/2.)*(np.cos(self._p) + 1j*np.sin(self._p)), np.cos(self._t/2.)*(np.cos(self._l + self._p) + 1j*np.sin(self._l + self._p))]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('q = cirq.LineQubit.range({})\n'.format(N))
+
+        f.write('cir = cirq.Circuit()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(q[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=-0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(np.pi*{}).on(q[{}]))\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.append(cirq.CNOT(q[{}], q[{}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+
+        f.write('gpu_options = qsimcirq.QSimOptions(gpu_mode={})\n'.format(int(cc[-1])))
+        f.write('qsim_simulator = qsimcirq.QSimSimulator(qsim_options=gpu_options)\n')
+        f.write('result = qsim_simulator.simulate(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(result.final_state_vector)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qsimcirq.py")
+
+task = 'qft'
+sim_pack = 'cuquantum_qsimcirq'
+com_cap = 'gpu8'
+prec = 'sp'
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path, com_cap)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_gpu_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_gpu_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+"""

qasm_parser/hiq/qasm_hiq_parser.py

@@ -0,0 +1,188 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('from projectq.backends import Simulator\n')
+        f.write('from projectq import MainEngine\n')
+        f.write('from projectq.meta import Compute, Control, Loop, Uncompute\n')
+        f.write('from projectq.ops import All, H, Measure, X, Z, Rx, Rz, Ry, CNOT, SGate, SqrtXGate, QubitOperator, MatrixGate, get_inverse\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('from hiq.projectq.cengines import GreedyScheduler, HiQMainEngine\n')
+        f.write('from hiq.projectq.backends import SimulatorMPI\n')
+        f.write('import projectq.setups.decompositions\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return MatrixGate(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return MatrixGate(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('backend = SimulatorMPI(num_local_qubits={})\n'.format(N))
+        f.write('eng = HiQMainEngine(backend, [GreedyScheduler()])\n')
+        f.write('qureg = eng.allocate_qureg({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('{} | qureg[{}]\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('SqrtXGate() | qureg[{}]\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('get_inverse(SqrtXGate()) | qureg[{}]\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('R{}(np.pi*{}) | qureg[{}]\n'.format(s.group()[1], float(m_r[0][0]),  t_qbit))
+                    continue
+
+                elif s.group() == "s":
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('SGate() | qureg[{}]\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('CNOT | (qureg[{}], qureg[{}])\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('U2(np.pi*{}, np.pi*{}) | qureg[{}]\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('U3(np.pi*{}, np.pi*{}, np.pi*{}) | qureg[{}]\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('eng.flush()\n')
+        f.write('All(Measure) | qureg\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "qasm_ex.qasm", "n12_projectq.py")
+
+task = 'qft'
+sim_pack = 'hiq'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/hiq_sim/hiq_run_files/'
+    output_file = output_file_path + 'hiq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/hiq_sim/hiq_run_files/'
+    output_file = output_file_path + 'hiq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/hybridq/qasm_hybridq_gpu_parser.py

@@ -0,0 +1,197 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('from hybridq.gate import Gate\n')
+        f.write('from hybridq.circuit import Circuit\n')
+        f.write('from hybridq.gate import MatrixGate\n')
+        f.write('from hybridq.circuit.simulation import simulate\n')
+        f.write('import numpy as np\n')
+
+        f.write('def SqrtXdg(q0):\n')
+        f.write('    mat = [[(1-1j)/2., (1+1j)/2.], [(1+1j)/2., (1-1j)/2.]]\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('def S(q0):\n')
+        f.write('    mat = [[1, 0], [0, 1j]]\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('def U2(p, l, q0):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('def U3(t, p, l, q0):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('init_state = \'0\'*{}\n'.format(N))
+
+        f.write('cir_arr = []\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'{}\', qubits=[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'SQRT_X\', qubits=[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'{}\', qubits=[{}], params=[np.pi*{}]))\n'.format(s.group().upper(),  t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(SqrtXdg({}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == "s":
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(S({}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'CX\', qubits=[{}, {}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(U2(np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(U3(np.pi*{}, np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        # f.write('psi = simulate(cir_arr, initial_state=init_state, simplify=False, optimize=\'evolution-einsum\', backend=\'jax\', max_largest_intermediate=2**40)\n')
+        f.write('psi = simulate(cir_arr, initial_state=init_state, optimize=\'evolution-einsum\', backend=\'jax\', max_largest_intermediate=2**40)\n')
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'rqc'
+sim_pack = 'hybridq'
+com_cap = 'gpu'
+prec = 'sp'
+
+for N in range(12, 36, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/hybridq/hybridq_gpu_run_files/'
+    output_file = output_file_path + 'hybridq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/hybridq/hybridq_gpu_run_files/'
+    output_file = output_file_path + 'hybridq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/hybridq/qasm_hybridq_mt_parser.py

@@ -0,0 +1,175 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('from hybridq.gate import Gate\n')
+        f.write('from hybridq.circuit import Circuit\n')
+        f.write('from hybridq.gate import MatrixGate\n')
+        f.write('from hybridq.circuit.simulation import simulate\n')
+        f.write('import numpy as np\n')
+
+        f.write('def SqrtXdg(q0):\n')
+        f.write('    mat = [[(1-1j)/2., (1+1j)/2.], [(1+1j)/2., (1-1j)/2.]]\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('def S(q0):\n')
+        f.write('    mat = [[1, 0], [0, 1j]]\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('def U2(p, l, q0):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('def U3(t, p, l, q0):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('init_state = \'0\'*{}\n'.format(N))
+
+        f.write('cir_arr = []\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'{}\', qubits=[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'SQRT_X\', qubits=[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'{}\', qubits=[{}], params=[np.pi*{}]))\n'.format(s.group().upper(),  t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(SqrtXdg({}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == "s":
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(S({}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'CX\', qubits=[{}, {}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(U2(np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(U3(np.pi*{}, np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('psi = simulate(cir_arr, initial_state=init_state, simplify=False, optimize=\'evolution-hybridq\', parallel=84, max_largest_intermediate=2**40)\n')
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/hybridq/hybridq_mt_run_files/'
+    output_file = output_file_path + 'hybridq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/hybridq/hybridq_mt_run_files/'
+    output_file = output_file_path + 'hybridq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+

qasm_parser/hybridq/qasm_hybridq_parser.py

@@ -0,0 +1,199 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, n_threads, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('from hybridq.gate import Gate\n')
+        f.write('from hybridq.circuit import Circuit\n')
+        f.write('from hybridq.gate import MatrixGate\n')
+        f.write('from hybridq.circuit.simulation import simulate\n')
+        f.write('import numpy as np\n')
+
+        f.write('def SqrtXdg(q0):\n')
+        f.write('    mat = [[(1-1j)/2., (1+1j)/2.], [(1+1j)/2., (1-1j)/2.]]\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('def S(q0):\n')
+        f.write('    mat = [[1, 0], [0, 1j]]\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('def U2(p, l, q0):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('def U3(t, p, l, q0):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return MatrixGate(mat, qubits=[q0], n_qubits=1)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('init_state = \'0\'*{}\n'.format(N))
+
+        f.write('cir_arr = []\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'{}\', qubits=[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'SQRT_X\', qubits=[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'{}\', qubits=[{}], params=[np.pi*{}]))\n'.format(s.group().upper(),  t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(SqrtXdg({}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == "s":
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(S({}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir_arr.append(Gate(\'CX\', qubits=[{}, {}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(U2(np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir_arr.append(U3(np.pi*{}, np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        # f.write('psi = simulate(cir_arr, initial_state=init_state, simplify=False, optimize=\'evolution-hybridq\', parallel=n_threads, max_largest_intermediate=2**40)\n')
+        f.write('psi = simulate(cir_arr, initial_state=init_state, optimize=\'evolution-hybridq\', parallel={}, max_largest_intermediate=2**40)\n'.format(n_threads))
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+task = 'rqc'
+sim_pack = 'hybridq'
+com_cap = 'st'
+prec = 'sp'
+
+for N in range(12, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file, save_file_path)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/hybridq/hybridq_run_files/'
+    output_file = output_file_path + 'hybridq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/hybridq/hybridq_run_files/'
+    output_file = output_file_path + 'hybridq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/intel_qs/qasm_intel_mt_parser.py

@@ -0,0 +1,213 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, _nt, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <time.h>\n')
+        f.write('#include <complex.h>\n')
+
+        f.write('#define BILLION 1E9\n')
+
+        f.write('#include "../../include/qureg.hpp"')
+
+        f.write('\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyU2(iqs::QubitRegister<Type> &state, int q0, double p, double l) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(std::cos(0.5*(p+l))/sqrt(2), -std::sin(0.5*(p+l))/sqrt(2));\n')
+        f.write('D(0, 1) = Type(-std::cos(0.5*(p-l))/sqrt(2), std::sin(0.5*(p-l))/sqrt(2));\n')
+        f.write('D(1, 0) = Type(std::cos(0.5*(p-l))/sqrt(2), std::sin(0.5*(p-l))/sqrt(2));\n')
+        f.write('D(1, 1) = Type(std::cos(0.5*(p+l))/sqrt(2), std::sin(0.5*(p+l))/sqrt(2));\n')
+
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyU3(iqs::QubitRegister<Type> &state, int q0, double t, double p, double l) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(std::cos(0.5*(p+l))*std::cos(0.5*t), -std::sin(0.5*(p+l))*std::cos(0.5*t));\n')
+        f.write('D(0, 1) = Type(-std::cos(0.5*(p-l))*std::sin(0.5*t), std::sin(0.5*(p-l))*std::sin(0.5*t));\n')
+        f.write('D(1, 0) = Type(std::cos(0.5*(p-l))*std::sin(0.5*t), std::sin(0.5*(p-l))*std::sin(0.5*t));\n')
+        f.write('D(1, 1) = Type(std::cos(0.5*(p+l))*std::cos(0.5*t), std::sin(0.5*(p+l))*std::cos(0.5*t));\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyS(iqs::QubitRegister<Type> &state, int q0) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = (1, 0);\n')
+        f.write('D(0, 1) = (0, 0);\n')
+        f.write('D(1, 0) = (0, 0);\n')
+        f.write('D(1, 1) = (0, 1);\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplySXDG(iqs::QubitRegister<Type> &state, int q0) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = (0.5, -0.5);\n')
+        f.write('D(0, 1) = (0.5, 0.5);\n')
+        f.write('D(1, 0) = (0.5, 0.5);\n')
+        f.write('D(1, 1) = (0.5, -0.5);\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('int main(int argc, char **argv){\n')
+
+        f.write('\t#ifndef INTELQS_HAS_MPI\n')
+        f.write('\t#endif\n')
+
+        f.write('\tiqs::mpi::Environment env(argc, argv);\n')
+        f.write('\tif (env.IsUsefulRank() == false) return 0;\n')
+        f.write('\tassert(env.GetNumStates()==1);\n')
+        f.write('\tint my_rank = env.GetStateRank();\n')
+        f.write('\tint num_ranks = env.GetStateSize();\n')
+        f.write('\tint num_threads = {};\n\n'.format(_nt))
+
+        f.write('\t#ifdef _OPENMP\n')
+        f.write('\t#pragma omp parallel\n')
+        f.write('\tnum_threads=omp_get_num_threads();\n')
+        f.write('\t#endif\n\n')
+
+        f.write('\tiqs::QubitRegister<ComplexDP> state ({});\n'.format(N))
+        f.write('\tstd::size_t index = 0;\n')
+        f.write('\tstate.Initialize("base", index);\n')
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        f.write('\tiqs::mpi::StateBarrier();\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('// {}\n'.format(s.group()))
+                    continue
+
+                # this can be done better by using key value pairs
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tstate.ApplyPauli{}({});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tstate.ApplyPauliSqrt{}({});\n'.format(s.group()[1].upper(), t_qbit))
+                    continue
+
+                elif s.group() == "s" or s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApply{}(state, {});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                #################
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tstate.ApplyRotation{}({}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('\tstate.ApplyCPauliX({}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApplyU2(state, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApplyU3(state, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tiqs::mpi::StateBarrier();\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc_mt/intel_mt_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.cpp'.format(N)
+    parse_qasm_to_package_gen(N, 84, input_file, output_file)
+
+r"""
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_mt_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.cpp'.format(N)
+    parse_qasm_to_package_gen(N, 84, input_file, output_file)
+
+"""

qasm_parser/intel_qs/qasm_intel_parser.py

@@ -0,0 +1,252 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, _nt, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <time.h>\n')
+        f.write('#include <complex.h>\n')
+
+        f.write('#define BILLION 1E9\n')
+
+        f.write('#include "/sim_lib/intel_qs_cpp/intel-qs/include/qureg.hpp"')
+
+        f.write('\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyU2(iqs::QubitRegister<Type> &state, int q0, double p, double l) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(std::cos(0.5*(p+l))/sqrt(2), -std::sin(0.5*(p+l))/sqrt(2));\n')
+        f.write('D(0, 1) = Type(-std::cos(0.5*(p-l))/sqrt(2), std::sin(0.5*(p-l))/sqrt(2));\n')
+        f.write('D(1, 0) = Type(std::cos(0.5*(p-l))/sqrt(2), std::sin(0.5*(p-l))/sqrt(2));\n')
+        f.write('D(1, 1) = Type(std::cos(0.5*(p+l))/sqrt(2), std::sin(0.5*(p+l))/sqrt(2));\n')
+
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyU3(iqs::QubitRegister<Type> &state, int q0, double t, double p, double l) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(std::cos(0.5*(p+l))*std::cos(0.5*t), -std::sin(0.5*(p+l))*std::cos(0.5*t));\n')
+        f.write('D(0, 1) = Type(-std::cos(0.5*(p-l))*std::sin(0.5*t), std::sin(0.5*(p-l))*std::sin(0.5*t));\n')
+        f.write('D(1, 0) = Type(std::cos(0.5*(p-l))*std::sin(0.5*t), std::sin(0.5*(p-l))*std::sin(0.5*t));\n')
+        f.write('D(1, 1) = Type(std::cos(0.5*(p+l))*std::cos(0.5*t), std::sin(0.5*(p+l))*std::cos(0.5*t));\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyS(iqs::QubitRegister<Type> &state, int q0) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(1, 0);\n')
+        f.write('D(0, 1) = Type(0, 0);\n')
+        f.write('D(1, 0) = Type(0, 0);\n')
+        f.write('D(1, 1) = Type(0, 1);\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplySXDG(iqs::QubitRegister<Type> &state, int q0) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(0.5, -0.5);\n')
+        f.write('D(0, 1) = Type(0.5, 0.5);\n')
+        f.write('D(1, 0) = Type(0.5, 0.5);\n')
+        f.write('D(1, 1) = Type(0.5, -0.5);\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+
+        f.write('int main(int argc, char **argv){\n')
+
+        f.write('\t#ifndef INTELQS_HAS_MPI\n')
+        f.write('\t#endif\n')
+
+        f.write('\tiqs::mpi::Environment env(argc, argv);\n')
+        f.write('\tif (env.IsUsefulRank() == false) return 0;\n')
+        f.write('\tassert(env.GetNumStates()==1);\n')
+        f.write('\tint my_rank = env.GetStateRank();\n')
+        f.write('\tint num_ranks = env.GetStateSize();\n')
+        f.write('\tint num_threads = {};\n\n'.format(_nt))
+
+        f.write('\t#ifdef _OPENMP\n')
+        f.write('\t#pragma omp parallel\n')
+        # if com_cap == 'st':
+        #     f.write('\tassert(num_threads==omp_get_num_threads());\n')
+        # elif com_cap == 'mt':
+        f.write('\tnum_threads=omp_get_num_threads();\n')
+        f.write('\t#endif\n\n')
+
+        f.write('\tiqs::mpi::StateBarrier();\n')
+
+        f.write('\tiqs::QubitRegister<ComplexDP> psi ({});\n'.format(N))
+        f.write('\tstd::size_t index = 0;\n')
+        f.write('\tpsi.Initialize("base", index);\n')
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        # f.write('\tiqs::mpi::StateBarrier();\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('// {}\n'.format(s.group()))
+                    continue
+
+                # this can be done better by using key value pairs
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyPauli{}({});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyHadamard({});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyPauliSqrt{}({});\n'.format(s.group()[1].upper(), t_qbit))
+                    continue
+
+                elif s.group() == "s" or s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApply{}(psi, {});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                #################
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyRotation{}({}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('\tpsi.ApplyCPauliX({}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApplyU2(psi, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApplyU3(psi, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tiqs::mpi::StateBarrier();\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+task = 'qft'
+sim_pack = 'intel_qs_cpp'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_{}_{}_{}_n{}.cpp'.format(sim_pack, task, com_cap, prec, N)
+    parse_qasm_to_package_gen(N, 84, input_file, output_file)
+
+r"""
+for N in range(16, 18, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.cpp'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.cpp'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+
+
+for N in range(16, 18, 2):
+    input_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/data_files/'
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+"""

qasm_parser/intel_qs/qasm_intel_parser_mpi.py

@@ -0,0 +1,245 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, _nt, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <time.h>\n')
+        f.write('#include <complex.h>\n')
+
+        f.write('#define BILLION 1E9\n')
+
+        f.write('#include "/data/user/gangap_a/sim_lib_mpi/intel-qs/include/qureg.hpp"')
+
+        f.write('\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyU2(iqs::QubitRegister<Type> &state, int q0, double p, double l) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(std::cos(0.5*(p+l))/sqrt(2), -std::sin(0.5*(p+l))/sqrt(2));\n')
+        f.write('D(0, 1) = Type(-std::cos(0.5*(p-l))/sqrt(2), std::sin(0.5*(p-l))/sqrt(2));\n')
+        f.write('D(1, 0) = Type(std::cos(0.5*(p-l))/sqrt(2), std::sin(0.5*(p-l))/sqrt(2));\n')
+        f.write('D(1, 1) = Type(std::cos(0.5*(p+l))/sqrt(2), std::sin(0.5*(p+l))/sqrt(2));\n')
+
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyU3(iqs::QubitRegister<Type> &state, int q0, double t, double p, double l) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(std::cos(0.5*(p+l))*std::cos(0.5*t), -std::sin(0.5*(p+l))*std::cos(0.5*t));\n')
+        f.write('D(0, 1) = Type(-std::cos(0.5*(p-l))*std::sin(0.5*t), std::sin(0.5*(p-l))*std::sin(0.5*t));\n')
+        f.write('D(1, 0) = Type(std::cos(0.5*(p-l))*std::sin(0.5*t), std::sin(0.5*(p-l))*std::sin(0.5*t));\n')
+        f.write('D(1, 1) = Type(std::cos(0.5*(p+l))*std::cos(0.5*t), std::sin(0.5*(p+l))*std::cos(0.5*t));\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyS(iqs::QubitRegister<Type> &state, int q0) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = (1, 0);\n')
+        f.write('D(0, 1) = (0, 0);\n')
+        f.write('D(1, 0) = (0, 0);\n')
+        f.write('D(1, 1) = (0, 1);\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplySXDG(iqs::QubitRegister<Type> &state, int q0) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = (0.5, -0.5);\n')
+        f.write('D(0, 1) = (0.5, 0.5);\n')
+        f.write('D(1, 0) = (0.5, 0.5);\n')
+        f.write('D(1, 1) = (0.5, -0.5);\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+
+        f.write('int main(int argc, char **argv){\n')
+
+        f.write('\t#ifndef INTELQS_HAS_MPI\n')
+        f.write('\t#endif\n')
+
+        f.write('\tiqs::mpi::Environment env(argc, argv);\n')
+        f.write('\tif (env.IsUsefulRank() == false) return 0;\n')
+        f.write('\tassert(env.GetNumStates()==1);\n')
+        f.write('\tint my_rank = env.GetStateRank();\n')
+        f.write('\tint num_ranks = env.GetStateSize();\n')
+        f.write('\tint num_threads = {};\n\n'.format(_nt))
+
+        f.write('\t#ifdef _OPENMP\n')
+        f.write('\t#pragma omp parallel\n')
+        # if com_cap == 'st':
+        #     f.write('\tassert(num_threads==omp_get_num_threads());\n')
+        # elif com_cap == 'mt':
+        f.write('\tnum_threads=omp_get_num_threads();\n')
+        f.write('\t#endif\n\n')
+
+        f.write('\tiqs::mpi::StateBarrier();\n')
+
+        f.write('\tiqs::QubitRegister<ComplexDP> psi ({});\n'.format(N))
+        f.write('\tstd::size_t index = 0;\n')
+        f.write('\tpsi.Initialize("base", index);\n')
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        # f.write('\tiqs::mpi::StateBarrier();\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('// {}\n'.format(s.group()))
+                    continue
+
+                # this can be done better by using key value pairs
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyPauli{}({});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyPauliSqrt{}({});\n'.format(s.group()[1].upper(), t_qbit))
+                    continue
+
+                elif s.group() == "s" or s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApply{}(psi, {});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                #################
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyRotation{}({}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('\tpsi.ApplyCPauliX({}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApplyU2(psi, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApplyU3(psi, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tiqs::mpi::StateBarrier();\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+task = 'hdyn'
+sim_pack = 'intel_qs_cpp'
+com_cap = 'mpi'
+prec = 'dp'
+
+for N in range(12, 36, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_{}_{}_{}_n{}.cpp'.format(sim_pack, task, com_cap, prec, N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+r"""
+for N in range(16, 18, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.cpp'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.cpp'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+
+
+for N in range(16, 18, 2):
+    input_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/data_files/'
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+"""

qasm_parser/intel_qs/qasm_intel_parser_sp.py

@@ -0,0 +1,253 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, _nt, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <time.h>\n')
+        f.write('#include <complex.h>\n')
+
+        f.write('#define BILLION 1E9\n')
+
+        f.write('#include "/sim_lib/intel_qs_cpp/intel-qs/include/qureg.hpp"')
+
+        f.write('\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyU2(iqs::QubitRegister<Type> &state, int q0, float p, float l) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(std::cos(0.5*(p+l))/sqrt(2), -std::sin(0.5*(p+l))/sqrt(2));\n')
+        f.write('D(0, 1) = Type(-std::cos(0.5*(p-l))/sqrt(2), std::sin(0.5*(p-l))/sqrt(2));\n')
+        f.write('D(1, 0) = Type(std::cos(0.5*(p-l))/sqrt(2), std::sin(0.5*(p-l))/sqrt(2));\n')
+        f.write('D(1, 1) = Type(std::cos(0.5*(p+l))/sqrt(2), std::sin(0.5*(p+l))/sqrt(2));\n')
+
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyU3(iqs::QubitRegister<Type> &state, int q0, float t, float p, float l) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(std::cos(0.5*(p+l))*std::cos(0.5*t), -std::sin(0.5*(p+l))*std::cos(0.5*t));\n')
+        f.write('D(0, 1) = Type(-std::cos(0.5*(p-l))*std::sin(0.5*t), std::sin(0.5*(p-l))*std::sin(0.5*t));\n')
+        f.write('D(1, 0) = Type(std::cos(0.5*(p-l))*std::sin(0.5*t), std::sin(0.5*(p-l))*std::sin(0.5*t));\n')
+        f.write('D(1, 1) = Type(std::cos(0.5*(p+l))*std::cos(0.5*t), std::sin(0.5*(p+l))*std::cos(0.5*t));\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplyS(iqs::QubitRegister<Type> &state, int q0) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(1, 0);\n')
+        f.write('D(0, 1) = Type(0, 0);\n')
+        f.write('D(1, 0) = Type(0, 0);\n')
+        f.write('D(1, 1) = Type(0, 1);\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+        f.write('template<typename Type>\n')
+        f.write('void ApplySXDG(iqs::QubitRegister<Type> &state, int q0) {\n')
+        f.write('TM2x2<ComplexDP> D;\n')
+        f.write('D(0, 0) = Type(0.5, -0.5);\n')
+        f.write('D(0, 1) = Type(0.5, 0.5);\n')
+        f.write('D(1, 0) = Type(0.5, 0.5);\n')
+        f.write('D(1, 1) = Type(0.5, -0.5);\n')
+        f.write('state.Apply1QubitGate(q0, D);\n')
+        f.write('}\n\n')
+
+
+        f.write('int main(int argc, char **argv){\n')
+
+        f.write('\t#ifndef INTELQS_HAS_MPI\n')
+        f.write('\t#endif\n')
+
+        f.write('\tiqs::mpi::Environment env(argc, argv);\n')
+        f.write('\tif (env.IsUsefulRank() == false) return 0;\n')
+        f.write('\tassert(env.GetNumStates()==1);\n')
+        f.write('\tint my_rank = env.GetStateRank();\n')
+        f.write('\tint num_ranks = env.GetStateSize();\n')
+        f.write('\tint num_threads = {};\n\n'.format(_nt))
+
+        f.write('\t#ifdef _OPENMP\n')
+        f.write('\t#pragma omp parallel\n')
+        # if com_cap == 'st':
+        #     f.write('\tassert(num_threads==omp_get_num_threads());\n')
+        # elif com_cap == 'mt':
+        f.write('\tnum_threads=omp_get_num_threads();\n')
+        f.write('\t#endif\n\n')
+
+        f.write('\tiqs::mpi::StateBarrier();\n')
+
+        f.write('\tiqs::QubitRegister<ComplexSP> psi ({});\n'.format(N))
+        f.write('\tstd::size_t index = 0;\n')
+        f.write('\tpsi.Initialize("base", index);\n')
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        # f.write('\tiqs::mpi::StateBarrier();\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('// {}\n'.format(s.group()))
+                    continue
+
+                # this can be done better by using key value pairs
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyPauli{}({});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyHadamard({});\n'.format(t_qbit))
+                    continue
+
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyPauliSqrt{}({});\n'.format(s.group()[1].upper(), t_qbit))
+                    continue
+
+                elif s.group() == "s" or s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApply{}(psi, {});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                #################
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpsi.ApplyRotation{}({}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('\tpsi.ApplyCPauliX({}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApplyU2(psi, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tApplyU3(psi, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tiqs::mpi::StateBarrier();\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+task = 'rqc'
+sim_pack = 'intel_qs_cpp'
+com_cap = 'mt'
+prec = 'sp'
+
+for N in range(12, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_{}_{}_{}_n{}.cpp'.format(sim_pack, task, com_cap, prec, N)
+    parse_qasm_to_package_gen(N, 84, input_file, output_file)
+
+r"""
+for N in range(16, 18, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.cpp'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.cpp'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+
+
+for N in range(16, 18, 2):
+    input_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/data_files/'
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/intel_qs_cpp/intel-qs/rqc/intel_run_files/'
+    output_file = output_file_path + 'intel_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+"""

qasm_parser/myqlm/qasm_myqlm_cpp_parser.py

@@ -0,0 +1,210 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, cc, pr, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import numpy as np\n')
+        f.write('from qat.lang.AQASM import Program, X, Y, Z, H, S, T, CNOT, RX, RY, RZ\n')
+        # f.write('from qat.qpus import get_default_qpu\n')
+        f.write('from qat.clinalg import CLinalg\n')
+        f.write('from qat.lang.AQASM import AbstractGate\n')
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('SX = AbstractGate("SX", [], arity=1)\n')#, matrix_generator=np.array([[(1+1j)/2., (1-1j)/2.], [(1-1j)/2., (1+1j)/2.]]))\n')
+        f.write('SX.set_matrix_generator(lambda: np.array([[(1+1j)/2., (1-1j)/2.], [(1-1j)/2., (1+1j)/2.]]))\n')
+
+        f.write('SXDG = AbstractGate("SXDG", [], arity=1)\n')#, matrix_generator=np.array([[(1-1j)/2., (1+1j)/2.], [(1+1j)/2., (1-1j)/2.]]))\n')
+        f.write('SXDG.set_matrix_generator(lambda: np.array([[(1-1j)/2., (1+1j)/2.], [(1+1j)/2., (1-1j)/2.]]))\n')
+
+        f.write('def U2_generator(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return np.array(mat)\n\n')
+
+        f.write('U2 = AbstractGate("U2", [float, float], arity=1, matrix_generator=U2_generator)\n')
+
+        f.write('def U3_generator(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return np.array(mat)\n\n')
+
+        f.write('U3 = AbstractGate("U3", [float, float, float], arity=1, matrix_generator=U3_generator)\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('prog = Program()\n')
+        f.write('qbits = prog.qalloc({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('{}(qbits[{}])\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('prog.apply(SX(), qbits[{}])\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('prog.apply(SXDG(), qbits[{}])\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('qc.add_{}gate({}, np.pi*{})\n'.format(s.group().upper(),  t_qbit, float(m_r[0][0])))
+                    f.write('{}(np.pi*{})(qbits[{}])\n'.format(s.group().upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('CNOT(qbits[{}], qbits[{}])\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('prog.apply(U2(np.pi*{}, np.pi*{}), qbits[{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('prog.apply(U3(np.pi*{}, np.pi*{}, np.pi*{}), qbits[{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), float(m_r[2][0]), t_qbit))
+                    continue
+
+
+        # f.write('qpu = get_default_qpu()\n')
+        if (com_cap == 'st' or com_cap == 'mt') and pr == 'sp':
+            f.write('qpu = CLinalg(use_nbthreads_heuristic=True, precision=1)\n')
+        elif (com_cap == 'st' or com_cap == 'mt') and pr == 'dp':
+            f.write('qpu = CLinalg(use_nbthreads_heuristic=True, precision=2)\n')
+        elif com_cap == 'gpu' and pr == 'sp':
+            f.write('qpu = CLinalg(use_gpu=True, precision=1)\n')
+        elif com_cap == 'gpu' and pr == 'dp':
+            f.write('qpu = CLinalg(use_gpu=True, precision=2)\n')
+
+        
+        f.write('circuit = prog.to_circ()\n')
+        f.write('job = circuit.to_job()\n')
+        f.write('result = qpu.submit(job)\n')
+        # f.write('f_state = device.run(qc).result().values[0]\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "n12_qulacs.py")
+
+task = 'qft'
+sim_pack = 'myqlm_cpp'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, com_cap, prec, input_file, output_file, save_file_path)
+
+
+"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/myqlm/qasm_myqlm_py_parser.py

@@ -0,0 +1,201 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import numpy as np\n')
+        f.write('from qat.lang.AQASM import Program, X, Y, Z, H, S, T, CNOT, RX, RY, RZ\n')
+        # f.write('from qat.qpus import get_default_qpu\n')
+        f.write('from qat.pylinalg import PyLinalg\n')
+        f.write('from qat.lang.AQASM import AbstractGate\n')
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('SX = AbstractGate("SX", [], arity=1)\n')#, matrix_generator=np.array([[(1+1j)/2., (1-1j)/2.], [(1-1j)/2., (1+1j)/2.]]))\n')
+        f.write('SX.set_matrix_generator(lambda: np.array([[(1+1j)/2., (1-1j)/2.], [(1-1j)/2., (1+1j)/2.]]))\n')
+
+        f.write('SXDG = AbstractGate("SXDG", [], arity=1)\n')#, matrix_generator=np.array([[(1-1j)/2., (1+1j)/2.], [(1+1j)/2., (1-1j)/2.]]))\n')
+        f.write('SXDG.set_matrix_generator(lambda: np.array([[(1-1j)/2., (1+1j)/2.], [(1+1j)/2., (1-1j)/2.]]))\n')
+
+        f.write('def U2_generator(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return np.array(mat)\n\n')
+
+        f.write('U2 = AbstractGate("U2", [float, float], arity=1, matrix_generator=U2_generator)\n')
+
+        f.write('def U3_generator(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return np.array(mat)\n\n')
+
+        f.write('U3 = AbstractGate("U3", [float, float, float], arity=1, matrix_generator=U3_generator)\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('prog = Program()\n')
+        f.write('qbits = prog.qalloc({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('{}(qbits[{}])\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('prog.apply(SX(), qbits[{}])\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('prog.apply(SXDG(), qbits[{}])\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('qc.add_{}gate({}, np.pi*{})\n'.format(s.group().upper(),  t_qbit, float(m_r[0][0])))
+                    f.write('{}(np.pi*{})(qbits[{}])\n'.format(s.group().upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('CNOT(qbits[{}], qbits[{}])\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('prog.apply(U2(np.pi*{}, np.pi*{}), qbits[{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('prog.apply(U3(np.pi*{}, np.pi*{}, np.pi*{}), qbits[{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), float(m_r[2][0]), t_qbit))
+                    continue
+
+
+        # f.write('qpu = get_default_qpu()\n')
+        f.write('qpu = PyLinalg()\n')
+        f.write('circuit = prog.to_circ()\n')
+        f.write('job = circuit.to_job()\n')
+        f.write('result = qpu.submit(job)\n')
+        # f.write('f_state = device.run(qc).result().values[0]\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "n12_qulacs.py")
+
+task = 'qft'
+sim_pack = 'myqlm'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+
+"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/pennylane/qasm_pennylane_gpu_parser.py

@@ -0,0 +1,198 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import pennylane as qml\n')
+        f.write('from pennylane import numpy as np\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return mat\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return mat\n\n')
+
+        f.write('dev = qml.device("lightning.gpu", shots=None, wires={}, c_dtype={})\n'.format(N, precision))
+        f.write('@qml.qnode(dev)\n')
+        f.write('def run_rqc():\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('\t# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('\t# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.Pauli{}(wires={})\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.Hadamard(wires={})\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.S(wires={})\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.SX(wires={})\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.SX(wires={}).inv()\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.{}(np.pi*{}, wires={})\n'.format(s.group().upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('\tqml.CNOT(wires=[{}, {}])\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.QubitUnitary(U2(np.pi*{}, np.pi*{}), wires={})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.QubitUnitary(U3(np.pi*{}, np.pi*{}, np.pi*{}), wires={})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('\treturn qml.state()\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+        f.write('fs=run_rqc()\n')
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # f.write('print(result.final_state_vector)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'qft'
+sim_pack = 'pennylane_l'
+com_cap = 'gpu'
+prec = 'dp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 'np.complex128', input_file, output_file, save_file_path)
+
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_pennylane.py")
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/pennylane/pennylane_gpu_sp_run_files/'
+    output_file = output_file_path + 'pennylane_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 'np.complex64', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/pennylane/pennylane_gpu_sp_run_files/'
+    output_file = output_file_path + 'pennylane_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 'np.complex64', input_file, output_file)
+"""

qasm_parser/pennylane/qasm_pennylane_l_parser.py

@@ -0,0 +1,185 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import pennylane as qml\n')
+        f.write('from pennylane import numpy as np\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return mat\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return mat\n\n')
+
+        if precision == 'single':
+            f.write('dev = qml.device("lightning.qubit", shots=None, wires={}, c_dtype=np.complex64)\n'.format(N))
+        elif precision == 'double':
+            f.write('dev = qml.device("lightning.qubit", shots=None, wires={}, c_dtype=np.complex128)\n'.format(N))
+
+        f.write('@qml.qnode(dev)\n')
+        f.write('def run_rqc():\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('\t# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('\t# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.Pauli{}(wires={})\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.Hadamard(wires={})\n'.format(t_qbit))
+                    continue
+
+
+                elif s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.S(wires={})\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.SX(wires={})\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.SX(wires={}).inv()\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.{}(np.pi*{}, wires={})\n'.format(s.group().upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('\tqml.CNOT(wires=[{}, {}])\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.QubitUnitary(U2(np.pi*{}, np.pi*{}), wires={})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.QubitUnitary(U3(np.pi*{}, np.pi*{}, np.pi*{}), wires={})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('\treturn qml.state()\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+        f.write('fs=run_rqc()\n')
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # f.write('print(result.final_state_vector)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_pennylane_l.py")
+
+task ='qft'
+sim_pack = 'pennylane_l'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 'double', input_file, output_file, save_file_path)

qasm_parser/pennylane/qasm_pennylane_parser.py

@@ -0,0 +1,184 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import pennylane as qml\n')
+        f.write('from pennylane import numpy as np\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return mat\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return mat\n\n')
+
+        if precision == 'single':
+            f.write('dev = qml.device("default.qubit", shots=None, wires={}, r_dtype=np.float32, c_dtype=np.complex64)\n'.format(N))
+        elif precision == 'double':
+            f.write('dev = qml.device("default.qubit", shots=None, wires={}, r_dtype=np.float64, c_dtype=np.complex128)\n'.format(N))
+
+        f.write('@qml.qnode(dev)\n')
+        f.write('def run_rqc():\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('\t# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('\t# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.Pauli{}(wires={})\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.Hadamard(wires={})\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.S(wires={})\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.SX(wires={})\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.SX(wires={}).inv()\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.{}(np.pi*{}, wires={})\n'.format(s.group().upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('\tqml.CNOT(wires=[{}, {}])\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.QubitUnitary(U2(np.pi*{}, np.pi*{}), wires={})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqml.QubitUnitary(U3(np.pi*{}, np.pi*{}, np.pi*{}), wires={})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('\treturn qml.state()\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+        f.write('fs=run_rqc()\n')
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # f.write('print(result.final_state_vector)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_pennylane.py")
+
+task = 'qft'
+sim_pack = 'pennylane'
+com_cap = 'st'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 'single', input_file, output_file, save_file_path)

qasm_parser/projectq/qasm_projectq_mt_parser.py

@@ -0,0 +1,163 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('from projectq.backends import Simulator\n')
+        f.write('from projectq import MainEngine\n')
+        f.write('from projectq.meta import Compute, Control, Loop, Uncompute\n')
+        f.write('from projectq.ops import All, H, Measure, X, Z, Rx, Rz, Ry, CNOT, SGate, SqrtXGate, QubitOperator, MatrixGate, get_inverse\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return MatrixGate(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return MatrixGate(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('eng = MainEngine(backend=Simulator(gate_fusion=True))\n')
+        f.write('qureg = eng.allocate_qureg({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('{} | qureg[{}]\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('SqrtXGate() | qureg[{}]\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('get_inverse(SqrtXGate()) | qureg[{}]\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('R{}(np.pi*{}) | qureg[{}]\n'.format(s.group()[1], float(m_r[0][0]),  t_qbit))
+                    continue
+
+                elif s.group() == "s":
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('SGate() | qureg[{}]\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('CNOT | (qureg[{}], qureg[{}])\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('U2(np.pi*{}, np.pi*{}) | qureg[{}]\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('U3(np.pi*{}, np.pi*{}, np.pi*{}) | qureg[{}]\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('eng.flush()\n')
+        f.write('All(Measure) | qureg\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "qasm_ex.qasm", "n12_projectq.py")
+
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/projectq/projectq_mt_run_files/'
+    output_file = output_file_path + 'projectq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/projectq/projectq_mt_run_files/'
+    output_file = output_file_path + 'projectq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+

qasm_parser/projectq/qasm_projectq_parser.py

@@ -0,0 +1,185 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('from projectq.backends import Simulator\n')
+        f.write('from projectq import MainEngine\n')
+        f.write('from projectq.meta import Compute, Control, Loop, Uncompute\n')
+        f.write('from projectq.ops import All, H, Measure, X, Z, Rx, Rz, Ry, CNOT, SGate, SqrtXGate, QubitOperator, MatrixGate, get_inverse\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return MatrixGate(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return MatrixGate(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        # f.write('eng = MainEngine(backend=Simulator(gate_fusion=True))\n')
+        f.write('eng = MainEngine(backend=Simulator())\n')
+        f.write('qureg = eng.allocate_qureg({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('{} | qureg[{}]\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('SqrtXGate() | qureg[{}]\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('get_inverse(SqrtXGate()) | qureg[{}]\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('R{}(np.pi*{}) | qureg[{}]\n'.format(s.group()[1], float(m_r[0][0]),  t_qbit))
+                    continue
+
+                elif s.group() == "s":
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('SGate() | qureg[{}]\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('CNOT | (qureg[{}], qureg[{}])\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('U2(np.pi*{}, np.pi*{}) | qureg[{}]\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('U3(np.pi*{}, np.pi*{}, np.pi*{}) | qureg[{}]\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('eng.flush()\n')
+        f.write('All(Measure) | qureg\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "qasm_ex.qasm", "n12_projectq.py")
+
+
+task = 'qft'
+sim_pack = 'projectq'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/projectq/projectq_run_files/'
+    output_file = output_file_path + 'projectq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/projectq/projectq_run_files/'
+    output_file = output_file_path + 'projectq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/qcgpu/qasm_gcgpu_parser.py

@@ -0,0 +1,198 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+
+        f.write('from time import process_time\n')
+        f.write('import qcgpu\n')
+        f.write('import numpy as np\n')
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('def SqrtX():\n')
+        f.write('    mat = [[(1+1j)/2., (1-1j)/2.], [(1-1j)/2., (1+1j)/2.]]\n')
+        f.write('    return qcgpu.Gate(mat)\n\n')
+
+        f.write('def SqrtXdg():\n')
+        f.write('    mat = [[(1-1j)/2., (1+1j)/2.], [(1+1j)/2., (1-1j)/2.]]\n')
+        f.write('    return qcgpu.Gate(mat)\n\n')
+
+        f.write('def Rx(t):\n')
+        f.write('    mat = [[np.cos(0.5*t), -1j*np.sin(0.5*t)], [-1j*np.sin(0.5*t), np.cos(0.5*t)]]\n')
+        f.write('    return qcgpu.Gate(mat)\n\n')
+
+        f.write('def Ry(t):\n')
+        f.write('    mat = [[np.cos(0.5*t), -np.sin(0.5*t)], [np.sin(0.5*t), np.cos(0.5*t)]]\n')
+        f.write('    return qcgpu.Gate(mat)\n\n')
+
+        f.write('def Rz(t):\n')
+        f.write('    mat = [[np.exp(-0.5j*t), 0.], [0., np.exp(0.5j*t)]]\n')
+        f.write('    return qcgpu.Gate(mat)\n\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return qcgpu.Gate(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return qcgpu.Gate(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('reg = qcgpu.State({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('reg.{}({})\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('reg.apply_gate(SqrtX(), {})\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('reg.apply_gate(SqrtXdg(), {})\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('reg.apply_gate(R{}(np.pi*{}), {})\n'.format(s.group()[1], float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('reg.cx({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('reg.apply_gate(U2(np.pi*{}, np.pi*{}), {})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('reg.apply_gate(U3(np.pi*{}, np.pi*{}, np.pi*{}), {})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "n12_qulacs.py")
+
+task = 'qft'
+sim_pack = 'qcgpu'
+com_cap = 'gpu'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qcgpu/qcgpu_run_files/'
+    output_file = output_file_path + 'qcgpu_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qcgpu/qcgpu_run_files/'
+    output_file = output_file_path + 'qcgpu_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+"""

qasm_parser/qibo/qasm_qibo_parser.py

@@ -0,0 +1,150 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, precision, cpu_threads, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import numpy as np\n')
+        f.write('import qibo as qb\n')
+
+        if cpu_threads == 1:
+            f.write('qb.set_threads({})\n'.format(cpu_threads))
+        f.write('qb.set_backend("numpy")\n')
+
+        f.write('qb.set_precision(\'{}\')\n'.format(precision))
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('cir = qb.models.Circuit({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.{}({}))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.{}({}, theta=np.pi*{}, trainable=False))\n'.format(s.group().upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.add(qb.gates.CNOT({}, {}))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.U2({}, phi=np.pi*{}, lam=np.pi*{}, trainable=False))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.U3({}, theta=np.pi*{}, phi=np.pi*{}, lam=np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('result = cir()\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # f.write('print(result.final_state_vector)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qibo.py")
+
+task = 'qft'
+sim_pack = 'qibo'
+com_cap = 'mt'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 'single', 84, input_file, output_file, save_file_path)

qasm_parser/qibo/qasm_qibojit_gpu_parser.py

@@ -0,0 +1,167 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import numpy as np\n')
+        f.write('import qibo as qb\n')
+
+        f.write('qb.set_backend("qibojit")\n')
+        # f.write('qb.set_threads({})\n'.format(cpu_threads))
+
+        f.write('qb.set_precision(\'{}\')\n'.format(precision))
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('cir = qb.models.Circuit({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.{}({}))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.{}({}, theta=np.pi*{}, trainable=False))\n'.format(s.group().upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.add(qb.gates.CNOT({}, {}))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.U2({}, phi=np.pi*{}, lam=np.pi*{}, trainable=False))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.U3({}, theta=np.pi*{}, phi=np.pi*{}, lam=np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('result = cir()\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(result.final_state_vector)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qibojit.py")
+
+task = 'rqc'
+sim_pack = 'qibojit'
+com_cap = 'gpu'
+prec = 'dp'
+
+for N in range(12, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 'double', input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qibo/qibojit_gpu_sp_run_files/'
+    output_file = output_file_path + 'qibojit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 'single', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qibo/qibojit_gpu_sp_run_files/'
+    output_file = output_file_path + 'qibojit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 'single', input_file, output_file)
+
+"""

qasm_parser/qibo/qasm_qibojit_parser.py

@@ -0,0 +1,151 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, precision, cpu_threads, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import numpy as np\n')
+        f.write('import qibo as qb\n')
+
+        f.write('qb.set_backend("qibojit")\n')
+
+        if cpu_threads == 1:
+            f.write('qb.set_threads({})\n'.format(cpu_threads))
+
+        f.write('qb.set_precision(\'{}\')\n'.format(precision))
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('cir = qb.models.Circuit({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.{}({}))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.{}({}, theta=np.pi*{}, trainable=False))\n'.format(s.group().upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.add(qb.gates.CNOT({}, {}))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.U2({}, phi=np.pi*{}, lam=np.pi*{}, trainable=False))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.U3({}, theta=np.pi*{}, phi=np.pi*{}, lam=np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('result = cir()\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # f.write('print(result.final_state_vector)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qibojit.py")
+
+task = 'qft'
+sim_pack = 'qibojit'
+com_cap = 'mt'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 'single', 84, input_file, output_file, save_file_path)

qasm_parser/qibo_ngpu/qasm_qibojit_gpu_parser.py

@@ -0,0 +1,183 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, ngpus, precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import numpy as np\n')
+        f.write('import qibo as qb\n')
+
+        f.write('qb.set_backend("qibojit")\n')
+        # f.write('qb.set_threads({})\n'.format(cpu_threads))
+
+        f.write('qb.set_precision(\'{}\')\n'.format(precision))
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        gs_key_arr = []
+
+        if ngpus==1:
+            f.write('cir = qb.models.Circuit({})\n'.format(N))
+        else:
+            gs_key_arr = []
+
+            for gpu in range(ngpus):
+                gs_key_arr.append('/GPU:' + str(gpu))
+
+            gs_val_arr = [1 for _ in range(ngpus)]
+
+            gpu_dict = dict(zip(gs_key_arr, gs_val_arr))
+
+            f.write('cir = qb.models.Circuit({}, {})\n'.format(N, gpu_dict))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.{}({}))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.{}({}, theta=np.pi*{}, trainable=False))\n'.format(s.group().upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.add(qb.gates.CNOT({}, {}))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.U2({}, phi=np.pi*{}, lam=np.pi*{}, trainable=False))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.add(qb.gates.U3({}, theta=np.pi*{}, phi=np.pi*{}, lam=np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('result = cir()\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # f.write('print(result.final_state_vector)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qibojit.py")
+
+task = 'qft'
+sim_pack = 'qibojit'
+com_cap = 'gpu8'
+prec = 'dp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 8, 'double', input_file, output_file, save_file_path)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qibojit_na100/qibojit_n1_run_files/'
+    output_file = output_file_path + 'qibojit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 'double', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qibojit_na100/qibojit_n1_run_files/'
+    output_file = output_file_path + 'qibojit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 'double', input_file, output_file)
+
+"""

qasm_parser/qiskit/qasm_qiskit_parser_2pt0_new.py

@@ -0,0 +1,200 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+import os
+
+def parse_qasm_to_package_gen(N, mpt, spt, f_precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from qiskit import QuantumRegister, QuantumCircuit, transpile, ClassicalRegister\n')
+        f.write('from qiskit.quantum_info.operators import Operator\n')
+        f.write('from qiskit.providers.aer import QasmSimulator\n')
+        f.write('from qiskit import Aer\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('from qiskit.quantum_info import Statevector, shannon_entropy\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('backend = Aer.get_backend(\'statevector_simulator\')#, max_parallel_threads={}, statevector_parallel_threshold={}, precision=\'{}\')\n'.format(mpt, spt, f_precision))
+        f.write('opt = backend.options\n')
+        f.write('opt.max_parallel_threads={}\n'.format(mpt))
+        f.write('opt.statevector_parallel_threshold={}\n'.format(spt))
+        f.write('opt.precision=\'{}\'\n'.format(f_precision))
+
+        f.write('cir = QuantumCircuit({})\n'.format(N))
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}({})\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}(np.pi*{}, {})\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.cx({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi/2., np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi*{}, np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('job = backend.run(transpile(cir, backend))\n')
+        f.write('result = job.result()\n')
+        f.write('outputstate = result.get_statevector(cir)\n')
+
+        f.write('probs = Statevector(outputstate).probabilities()\n')
+        f.write('print(sum(probs))\n')
+
+        f.write('ent = shannon_entropy(probs)\n')
+        f.write('print(ent)\n')
+
+        # f.write('t_e = perf_counter()\n')
+        # f.write('t_ep = process_time()\n')
+
+        # f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        # f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+        # f.write('print(t_e - t_s)\n')
+        # f.write('print(t_ep - t_sp)\n')
+
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, 1, 42, "../qasm_test/qasm_rqc_test.qasm", "test_qiskit.py")
+# parse_qasm_to_package_gen(12, 1, 42, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qiskit_2.py")
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qiskit/qiskit_sp_run_files/'
+    output_file = output_file_path + 'qiskit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 42, 'single', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qiskit/qiskit_sp_run_files/'
+    output_file = output_file_path + 'qiskit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 42, 'single', input_file, output_file)
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/data_files/'
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/qiskit/qiskit_run_files/'
+    output_file = output_file_path + 'h_dyn_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 42, 'double', input_file, output_file)
+"""
+
+task = 'hdyn'
+sim_pack = 'qiskit'
+com_cap = 'st'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/home/amit/Documents/PSI_m/project_files_final/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    # save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    # output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    save_file_path = None
+
+    output_file_path = '/home/amit/Documents/PSI_m/project_files_final/{}_ent/{}/'.format(task, sim_pack)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 1, 40, "single", input_file, output_file, save_file_path)

qasm_parser/qiskit/qasm_qiskit_parser_gpu_2pt0_new.py

@@ -0,0 +1,186 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+import os
+
+def parse_qasm_to_package_gen(N, f_precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from qiskit import QuantumRegister, QuantumCircuit, transpile, ClassicalRegister\n')
+        f.write('from qiskit.quantum_info.operators import Operator\n')
+        f.write('from qiskit.providers.aer import QasmSimulator\n')
+        f.write('from qiskit import Aer\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('backend = Aer.get_backend(\'statevector_simulator\')\n')#, max_parallel_threads={}, statevector_parallel_threshold={}, precision=\'{}\')\n'.format(mpt, spt, f_precision))
+        f.write('opt = backend.options\n')
+        f.write('opt.device=\'GPU\'\n')
+        f.write('opt.precision=\'{}\'\n'.format(f_precision))
+
+        f.write('cir = QuantumCircuit({})\n'.format(N))
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}({})\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}(np.pi*{}, {})\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.cx({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi/2., np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi*{}, np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('job = backend.run(transpile(cir, backend))\n')
+        f.write('result = job.result()\n')
+        f.write('outputstate = result.get_statevector(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(outputstate)')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, 1, 42, "../qasm_test/qasm_rqc_test.qasm", "test_qiskit.py")
+# parse_qasm_to_package_gen(12, 1, 42, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qiskit_2.py")
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qiskit/qiskit_sp_run_files/'
+    output_file = output_file_path + 'qiskit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 42, 'single', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qiskit/qiskit_sp_run_files/'
+    output_file = output_file_path + 'qiskit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 42, 'single', input_file, output_file)
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/data_files/'
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/qiskit/qiskit_run_files/'
+    output_file = output_file_path + 'h_dyn_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 42, 'double', input_file, output_file)
+"""
+
+task = 'qft'
+sim_pack = 'qiskit'
+com_cap = 'gpu'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, "single", input_file, output_file, save_file_path)

qasm_parser/qiskit/qasm_qiskit_parser_mt_2pt0_new.py

@@ -0,0 +1,187 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+import os
+
+def parse_qasm_to_package_gen(N, mpt, spt, f_precision, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from qiskit import QuantumRegister, QuantumCircuit, transpile, ClassicalRegister\n')
+        f.write('from qiskit.quantum_info.operators import Operator\n')
+        f.write('from qiskit.providers.aer import QasmSimulator\n')
+        f.write('from qiskit import Aer\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('backend = Aer.get_backend(\'statevector_simulator\')\n')#, max_parallel_threads={}, statevector_parallel_threshold={}, precision=\'{}\')\n'.format(mpt, spt, f_precision))
+        f.write('opt = backend.options\n')
+        f.write('opt.max_parallel_threads={}\n'.format(mpt))
+        f.write('opt.statevector_parallel_threshold={}\n'.format(spt))
+        f.write('opt.precision=\'{}\'\n'.format(f_precision))
+
+        f.write('cir = QuantumCircuit({})\n'.format(N))
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}({})\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}(np.pi*{}, {})\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.cx({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi/2., np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi*{}, np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('job = backend.run(transpile(cir, backend))\n')
+        f.write('result = job.result()\n')
+        f.write('outputstate = result.get_statevector(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(outputstate)')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, 1, 42, "../qasm_test/qasm_rqc_test.qasm", "test_qiskit.py")
+# parse_qasm_to_package_gen(12, 1, 42, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qiskit_2.py")
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qiskit/qiskit_sp_run_files/'
+    output_file = output_file_path + 'qiskit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 42, 'single', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qiskit/qiskit_sp_run_files/'
+    output_file = output_file_path + 'qiskit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 42, 'single', input_file, output_file)
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/data_files/'
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/qiskit/qiskit_run_files/'
+    output_file = output_file_path + 'h_dyn_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, 42, 'double', input_file, output_file)
+"""
+
+task = 'hdyn'
+sim_pack = 'qiskit'
+com_cap = 'mt'
+prec = 'sp'
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 84, 5, "single", input_file, output_file, save_file_path)

qasm_parser/qiskit_cont_ngpu/qasm_qiskit_parser_nvidia_container_2pt0.py

@@ -0,0 +1,173 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+import math
+
+def parse_qasm_to_package_gen(N, ngpus, mpi_on, f_precision, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('import sys\n')
+        # f.write('sys.path.insert(0, \'/data/user/gangap_a/rqc/qiskit_nvidia/cuquantum/lib\')\n')
+        f.write('from qiskit import QuantumRegister, QuantumCircuit, transpile, ClassicalRegister\n')
+        f.write('from qiskit.quantum_info.operators import Operator\n')
+        # f.write('from cusvaer.backends import StatevectorSimulator\n')
+        f.write('from qiskit import Aer\n')
+        f.write('import math\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+
+        f.write('def U2(p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+        f.write('def U3(t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return Operator(mat)\n\n')
+
+
+        blocking_e = False
+        blocking_q = None
+
+        if mpi_on == True:
+            blocking_e = True
+            blocking_q = N - int(math.log2(ngpus))
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        # f.write('backend = Aer.get_backend(\'statevector_simulator\', max_parallel_threads={}, statevector_parallel_threshold={})\n'.format(mpt, spt))
+        f.write('backend = Aer.get_backend(\'statevector_simulator\', device=\'GPU\', cusvaer_enable=False, cuStateVec_enable=False, blocking_enable={}, blocking_qubits={}, precision=\'{}\')\n'.format(blocking_e, blocking_q, f_precision))
+        # f.write('backend.set_options(device=\'GPU\')\n')
+
+        # f.write('backend = StatevectorSimulator()\n')
+        # f.write('backend.set_options(precision=\'{}\')\n'.format(f_precision))
+        # f.write('backend.set_options(cusvaer_global_index_bits=[0, 0])\n')
+        # f.write('backend.set_options(cusvaer_p2p_device_bits=0)\n')
+
+        f.write('cir = QuantumCircuit({})\n'.format(N))
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'sx' or s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}({})\n'.format(s.group(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.{}(np.pi*{}, {})\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.cx({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi/2., np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('cir.u(np.pi*{}, np.pi*{}, np.pi*{}, {})\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}), [{}])\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('job = backend.run(transpile(cir, backend))\n')
+        f.write('result = job.result()\n')
+        f.write('outputstate = result.get_statevector(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(outputstate)')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, 1, 42, "../qasm_test/qasm_rqc_test.qasm", "test_qiskit.py")
+# parse_qasm_to_package_gen(12, 1, 42, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qiskit_2.py")
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qiskit_cont_ngpu/qiskit_gpu_n8_off_run_files/'
+    output_file = output_file_path + 'qiskit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 8, False, 'double', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qiskit_cont_ngpu/qiskit_gpu_n8_off_run_files/'
+    output_file = output_file_path + 'qiskit_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 8, False, 'double', input_file, output_file)

qasm_parser/qpanda/qasm_qpanda_parser.py

@@ -0,0 +1,174 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+import os
+
+def parse_qasm_to_package_gen(N, com_cap, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('from pyqpanda import *\n')
+
+        f.write('def SX_gate(qp, qb):\n')
+        f.write('    qp << U4(qb, np.pi/4., np.pi/2., -np.pi/2., -np.pi/2.)\n')
+
+        f.write('def SXDG_gate(qp, qb):\n')
+        f.write('    qp << U4(qb, -np.pi/4., np.pi/2., np.pi/2., -np.pi/2.)\n')
+
+        f.write('def U2_gate(qp, qb, p, l):\n')
+        f.write('    qp << U4(qb, 0., p, np.pi/2., l)\n')
+
+        f.write('def U3_gate(qp, qb, t, p, l):\n')
+        f.write('    qp << U4(qb, 0., p, t, l)\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        if com_cap == 'st':
+            # f.write('init(QMachineType.CPU_SINGLE_THREAD)\n')
+            f.write('qvm = init_quantum_machine(QMachineType.CPU_SINGLE_THREAD)\n')
+        elif com_cap == 'mt':
+            f.write('qvm = CPUQVM()\n')
+            f.write('qvm.init_qvm()\n')
+        elif com_cap == 'gpu':
+            f.write('qvm = init_quantum_machine(QMachineType.GPU)\n')
+
+        f.write('qvm.set_configure({}, {})\n'.format(N, N))
+        f.write('q_bits = qvm.qAlloc_many({})\n'.format(N))
+        f.write('qprog = QProg()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qprog << {}(q_bits[{}])\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('SX_gate(qprog, q_bits[{}])\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('SXDG_gate(qprog, q_bits[{}])\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qprog << {}(q_bits[{}], np.pi*{})\n'.format(s.group().upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('qprog << CNOT(q_bits[{}], q_bits[{}])\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('U2_gate(qprog, q_bits[{}], np.pi*{}, np.pi*{})\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('U3_gate(qprog, q_bits[{}], np.pi*{}, np.pi*{}, np.pi*{})\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('result = qvm.directly_run(qprog)\n')
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(qvm.get_qstate())\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'hdyn'
+sim_pack = 'qpanda'
+c_cap = 'gpu'
+prec = 'dp'
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, c_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, c_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, c_cap, input_file, output_file, save_file_path)
+

qasm_parser/qpp/qasm_qpp_parser.py

@@ -0,0 +1,199 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <stdio.h>\n')
+        f.write('#include <math.h>\n')
+        f.write('#include <time.h>\n')
+        f.write('#include <stdlib.h>\n')
+
+        f.write('#include \"qpp.h\"\n')
+
+        f.write('using namespace qpp;\n')
+
+        f.write('#define BILLION 1E9\n')
+
+        f.write('\n')
+
+        f.write('cmat u2g(double p, double l){\n')
+        f.write('\tcmat u2{cmat::Zero(2, 2)};\n')
+
+        f.write('\tu2 << std::exp(-1_i * (p + l) / 2.0)/std::sqrt(2),\n')
+        f.write('\t-std::exp(-1_i * (p - l) / 2.0)/std::sqrt(2),\n')
+        f.write('\tstd::exp(1_i * (p - l) / 2.0)/std::sqrt(2),\n')
+        f.write('\tstd::exp(1_i * (p + l) / 2.0)/std::sqrt(2);\n')
+        f.write('\treturn u2;\n')
+        f.write('}\n')
+
+        f.write('cmat u3g(double t, double p, double l){\n')
+        f.write('\tcmat u3{cmat::Zero(2, 2)};\n')
+
+        f.write('\tu3 << std::exp(-1_i * (p + l) / 2.0) * std::cos(t / 2.0),\n')
+        f.write('\t-std::exp(-1_i * (p - l) / 2.0) * std::sin(t / 2.0),\n')
+        f.write('\tstd::exp(1_i * (p - l) / 2.0) * std::sin(t / 2.0),\n')
+        f.write('\tstd::exp(1_i * (p + l) / 2.0) * std::cos(t / 2.0);\n')
+
+        f.write('\treturn u3;\n')
+        f.write('}\n')
+
+        # f.write('int main(int argc, char* argv[]){\n')
+        f.write('int main(){\n')
+
+        f.write('\tusing namespace qpp;\n')
+        # f.write('\tQCircuit qc{{}};\n'.format(N))
+        f.write('\tQCircuit qc{' + str(N) + '};\n')
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            k = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('// {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'sx' or s.group() == 'sxdg' or s.group() == 'h' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tqc.gate(gt.{}, {});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tcmat U_{} = gt.{}(M_PI*{});\n'.format(k, s.group().upper(), float(m_r[0][0])))
+                    f.write('\tqc.gate(U_{}, {}, \"{}\");\n'.format(k, t_qbit, s.group()))
+                    k = k + 1
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('\tqc.gate(gt.CNOT, {}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+
+                    f.write('\tcmat u2_' + str(k) + '{cmat::Zero(2, 2)};\n')
+
+                    f.write('\tu2_{} << u2g(M_PI*{}, M_PI*{});\n'.format(k, float(m_r[0][0]), float(m_r[1][0])))
+                    f.write('\tqc.gate(u2_{}, {}, \"u2\");\n'.format(k, t_qbit))
+                    k = k + 1
+
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+
+                    f.write('\tcmat u3_' + str(k) + '{cmat::Zero(2, 2)};\n')
+
+                    f.write('\tu3_{} << u3g(M_PI*{}, M_PI*{}, M_PI*{});\n'.format(k, float(m_r[0][0]), float(m_r[1][0]), float(m_r[2][0])))
+                    f.write('\tqc.gate(u3_{}, {}, \"u3\");\n'.format(k, t_qbit))
+                    k = k + 1
+
+                    continue
+
+        f.write('\tQEngine engine{qc};\n')
+        f.write('\tengine.execute();\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'qft'
+sim_pack = 'qpp'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    # save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.cpp'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+"""

qasm_parser/qrack/qasm_qrack_opt_gpu_parser.py

@@ -0,0 +1,179 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, _prec, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <time.h>\n')
+        f.write('#define BILLION 1E9\n')
+
+        # f.write('#include \"qrack/qfactory.hpp\"\n')
+        f.write('#include \"/sim_lib/qrack/qrack/build_gpu_{}/include/qfactory.hpp\"\n'.format(_prec))
+
+        f.write('#include <algorithm>\n') # // std::random_shuffle
+        f.write('#include <cstddef>\n') # // size_t
+        f.write('#include <iostream>\n') # // std::cout
+
+        f.write('using namespace Qrack;\n')
+
+        f.write('\n')
+        f.write('int main(int argc, char* argv[]){\n')
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+        f.write('\tQInterfacePtr qReg = CreateQuantumInterface(QINTERFACE_OPTIMAL, {}, 0);\n'.format(N))
+        # f.write('\tQInterfacePtr qReg = CreateQuantumInterface(QINTERFACE_CPU, {}, 0);\n'.format(N))
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('\t// {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'h' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tpauli{}(qubits, {});\n'.format(s.group().upper(), t_qbit))
+                    f.write('\tqReg->{}({});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+                    f.write('\tqReg->SqrtX({});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+       	       	    f.write('\tqReg->ISqrtX({});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\trotate{}(qubits, {}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    f.write('\tqReg->R{}(M_PI*{}, {});\n'.format(s.group()[1].upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('\tcontrolledNot(qubits, {}, {});\n'.format(c_qbit, t_qbit))
+                    f.write('\tqReg->CNOT({}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tu2(qubits, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    f.write('\tqReg->U2({}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tu3(qubits, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    f.write('\tqReg->U({}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'qft'
+sim_pack = 'qrack_opt'
+com_cap = 'gpu'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    # save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.cpp'.format(task, N)
+    parse_qasm_to_package_gen(N, prec, input_file, output_file)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+"""

qasm_parser/qrack/qasm_qrack_opt_parser.py

@@ -0,0 +1,179 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, _prec, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <time.h>\n')
+        f.write('#define BILLION 1E9\n')
+
+        # f.write('#include \"qrack/qfactory.hpp\"\n')
+        f.write('#include \"/sim_lib/qrack/qrack/build_st_{}/include/qfactory.hpp\"\n'.format(_prec))
+
+        f.write('#include <algorithm>\n') # // std::random_shuffle
+        f.write('#include <cstddef>\n') # // size_t
+        f.write('#include <iostream>\n') # // std::cout
+
+        f.write('using namespace Qrack;\n')
+
+        f.write('\n')
+        f.write('int main(int argc, char* argv[]){\n')
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+        f.write('\tQInterfacePtr qReg = CreateQuantumInterface(QINTERFACE_OPTIMAL, {}, 0);\n'.format(N))
+        # f.write('\tQInterfacePtr qReg = CreateQuantumInterface(QINTERFACE_CPU, {}, 0);\n'.format(N))
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('\t// {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'h' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tpauli{}(qubits, {});\n'.format(s.group().upper(), t_qbit))
+                    f.write('\tqReg->{}({});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+                    f.write('\tqReg->SqrtX({});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+       	       	    f.write('\tqReg->ISqrtX({});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\trotate{}(qubits, {}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    f.write('\tqReg->R{}(M_PI*{}, {});\n'.format(s.group()[1].upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('\tcontrolledNot(qubits, {}, {});\n'.format(c_qbit, t_qbit))
+                    f.write('\tqReg->CNOT({}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tu2(qubits, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    f.write('\tqReg->U2({}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tu3(qubits, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    f.write('\tqReg->U({}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'qft'
+sim_pack = 'qrack_opt'
+com_cap = 'mt'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    # save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.cpp'.format(task, N)
+    parse_qasm_to_package_gen(N, prec, input_file, output_file)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+"""

qasm_parser/qrack/qasm_qrack_sch_gpu_parser.py

@@ -0,0 +1,179 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, _prec, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <time.h>\n')
+        f.write('#define BILLION 1E9\n')
+
+        # f.write('#include \"qrack/qfactory.hpp\"\n')
+        f.write('#include \"/sim_lib/qrack/qrack/build_gpu_{}/include/qfactory.hpp\"\n'.format(_prec))
+
+        f.write('#include <algorithm>\n') # // std::random_shuffle
+        f.write('#include <cstddef>\n') # // size_t
+        f.write('#include <iostream>\n') # // std::cout
+
+        f.write('using namespace Qrack;\n')
+
+        f.write('\n')
+        f.write('int main(int argc, char* argv[]){\n')
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+        # f.write('\tQInterfacePtr qReg = CreateQuantumInterface(QINTERFACE_OPTIMAL, {}, 0);\n'.format(N))
+        f.write('\tQInterfacePtr qReg = CreateQuantumInterface(QINTERFACE_OPENCL, {}, 0);\n'.format(N))
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('\t// {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'h' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tpauli{}(qubits, {});\n'.format(s.group().upper(), t_qbit))
+                    f.write('\tqReg->{}({});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+                    f.write('\tqReg->SqrtX({});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+       	       	    f.write('\tqReg->ISqrtX({});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\trotate{}(qubits, {}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    f.write('\tqReg->R{}(M_PI*{}, {});\n'.format(s.group()[1].upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('\tcontrolledNot(qubits, {}, {});\n'.format(c_qbit, t_qbit))
+                    f.write('\tqReg->CNOT({}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tu2(qubits, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    f.write('\tqReg->U2({}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tu3(qubits, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    f.write('\tqReg->U({}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'hdyn'
+sim_pack = 'qrack_sch'
+com_cap = 'gpu'
+prec = 'sp'
+
+for N in range(6, 36, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    # save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.cpp'.format(task, N)
+    parse_qasm_to_package_gen(N, prec, input_file, output_file)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+"""

qasm_parser/qrack/qasm_qrack_sch_parser.py

@@ -0,0 +1,179 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, _prec, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <time.h>\n')
+        f.write('#define BILLION 1E9\n')
+
+        # f.write('#include \"qrack/qfactory.hpp\"\n')
+        f.write('#include \"/sim_lib/qrack/qrack/build_st_{}/include/qfactory.hpp\"\n'.format(_prec))
+
+        f.write('#include <algorithm>\n') # // std::random_shuffle
+        f.write('#include <cstddef>\n') # // size_t
+        f.write('#include <iostream>\n') # // std::cout
+
+        f.write('using namespace Qrack;\n')
+
+        f.write('\n')
+        f.write('int main(int argc, char* argv[]){\n')
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+        # f.write('\tQInterfacePtr qReg = CreateQuantumInterface(QINTERFACE_OPTIMAL, {}, 0);\n'.format(N))
+        f.write('\tQInterfacePtr qReg = CreateQuantumInterface(QINTERFACE_CPU, {}, 0);\n'.format(N))
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('\t// {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'h' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tpauli{}(qubits, {});\n'.format(s.group().upper(), t_qbit))
+                    f.write('\tqReg->{}({});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+                    f.write('\tqReg->SqrtX({});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+       	       	    f.write('\tqReg->ISqrtX({});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\trotate{}(qubits, {}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    f.write('\tqReg->R{}(M_PI*{}, {});\n'.format(s.group()[1].upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('\tcontrolledNot(qubits, {}, {});\n'.format(c_qbit, t_qbit))
+                    f.write('\tqReg->CNOT({}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tu2(qubits, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    f.write('\tqReg->U2({}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('\tu3(qubits, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    f.write('\tqReg->U({}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'rqc'
+sim_pack = 'qrack_sch'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(12, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    # save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.cpp'.format(task, N)
+    parse_qasm_to_package_gen(N, prec, input_file, output_file)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+"""

qasm_parser/qsimcirq/qasm_qsimcirq_a100_parser.py

@@ -0,0 +1,211 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('os.chdir(\'/data/user/gangap_a/rqc/qsimcirq_a100/qsim\')\n')
+        f.write('cwd = os.getcwd()\n')
+        f.write('import sys\n')
+        f.write('sys.path.insert(0, \'\')\n')
+
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import cirq\n')
+        f.write('import qsimcirq\n')
+
+        f.write('class U2(cirq.Gate):\n')
+        f.write('    def __init__(self, phi, lam):\n')
+        f.write('        super(U2, self)\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = ((np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))/np.sqrt(2))*np.array([[1, -np.cos(self._l)-1j*np.sin(self._l)], [np.cos(self._p) + 1j*np.sin(self._p), np.cos(self._l + self._p) + 1j*np.sin(self._l+self._p)]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('class U3(cirq.Gate):\n')
+        f.write('    def __init__(self, theta, phi, lam):\n')
+        f.write('        super(U3, self)\n')
+        f.write('        self._t = theta\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = (np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))*np.array([[np.cos(self._t/2.), -np.sin(self._t/2.)*(np.cos(self._l) + 1j*np.sin(self._l))], [np.sin(self._t/2.)*(np.cos(self._p) + 1j*np.sin(self._p)), np.cos(self._t/2.)*(np.cos(self._l + self._p) + 1j*np.sin(self._l + self._p))]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('q = cirq.LineQubit.range({})\n'.format(N))
+
+        f.write('cir = cirq.Circuit()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(q[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=-0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(np.pi*{}).on(q[{}]))\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.append(cirq.CNOT(q[{}], q[{}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+
+        f.write('gpu_options = qsimcirq.QSimOptions(use_gpu=True)\n')
+        f.write('qsim_simulator = qsimcirq.QSimSimulator(qsim_options=gpu_options)\n')
+        f.write('result = qsim_simulator.simulate(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(result.final_state_vector)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qsimcirq.py")
+
+task = 'rqc'
+sim_pack = 'qsimcirq'
+com_cap = 'gpu'
+prec = 'sp'
+
+for N in range(12, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_gpu_a100_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_gpu_a100_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/qsimcirq/qasm_qsimcirq_gpu_parser.py

@@ -0,0 +1,210 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('os.chdir(\'/sim_lib/qsimcirq/qsim/\')\n')
+        f.write('cwd = os.getcwd()\n')
+        f.write('import sys\n')
+        f.write('sys.path.insert(0, \'\')\n')
+
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import cirq\n')
+        f.write('import qsimcirq\n')
+
+        f.write('class U2(cirq.Gate):\n')
+        f.write('    def __init__(self, phi, lam):\n')
+        f.write('        super(U2, self)\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = ((np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))/np.sqrt(2))*np.array([[1, -np.cos(self._l)-1j*np.sin(self._l)], [np.cos(self._p) + 1j*np.sin(self._p), np.cos(self._l + self._p) + 1j*np.sin(self._l+self._p)]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('class U3(cirq.Gate):\n')
+        f.write('    def __init__(self, theta, phi, lam):\n')
+        f.write('        super(U3, self)\n')
+        f.write('        self._t = theta\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = (np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))*np.array([[np.cos(self._t/2.), -np.sin(self._t/2.)*(np.cos(self._l) + 1j*np.sin(self._l))], [np.sin(self._t/2.)*(np.cos(self._p) + 1j*np.sin(self._p)), np.cos(self._t/2.)*(np.cos(self._l + self._p) + 1j*np.sin(self._l + self._p))]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('q = cirq.LineQubit.range({})\n'.format(N))
+
+        f.write('cir = cirq.Circuit()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(q[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=-0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(np.pi*{}).on(q[{}]))\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.append(cirq.CNOT(q[{}], q[{}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+
+        f.write('gpu_options = qsimcirq.QSimOptions(use_gpu=True)\n')
+        f.write('qsim_simulator = qsimcirq.QSimSimulator(qsim_options=gpu_options)\n')
+        f.write('result = qsim_simulator.simulate(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(result.final_state_vector)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qsimcirq.py")
+
+task = 'hdyn'
+sim_pack = 'qsimcirq'
+com_cap = 'gpu'
+prec = 'sp'
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_gpu_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_gpu_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+"""

qasm_parser/qsimcirq/qasm_qsimcirq_mt_parser.py

@@ -0,0 +1,184 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, cpu_threads, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import cirq\n')
+        f.write('import qsimcirq\n')
+
+        f.write('class U2(cirq.Gate):\n')
+        f.write('    def __init__(self, phi, lam):\n')
+        f.write('        super(U2, self)\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = ((np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))/np.sqrt(2))*np.array([[1, -np.cos(self._l)-1j*np.sin(self._l)], [np.cos(self._p) + 1j*np.sin(self._p), np.cos(self._l + self._p) + 1j*np.sin(self._l+self._p)]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('class U3(cirq.Gate):\n')
+        f.write('    def __init__(self, theta, phi, lam):\n')
+        f.write('        super(U3, self)\n')
+        f.write('        self._t = theta\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = (np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))*np.array([[np.cos(self._t/2.), -np.sin(self._t/2.)*(np.cos(self._l) + 1j*np.sin(self._l))], [np.sin(self._t/2.)*(np.cos(self._p) + 1j*np.sin(self._p)), np.cos(self._t/2.)*(np.cos(self._l + self._p) + 1j*np.sin(self._l + self._p))]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('q = cirq.LineQubit.range({})\n'.format(N))
+
+        f.write('cir = cirq.Circuit()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(q[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=-0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(np.pi*{}).on(q[{}]))\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.append(cirq.CNOT(q[{}], q[{}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('qsim_options = qsimcirq.QSimOptions(cpu_threads={})\n'.format(cpu_threads))
+        f.write('qsim_simulator = qsimcirq.QSimSimulator(qsim_options)\n')
+        f.write('result = qsim_simulator.simulate(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(result.final_state_vector)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qsimcirq.py")
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_mt_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 84, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_mt_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 84, input_file, output_file)
+

qasm_parser/qsimcirq/qasm_qsimcirq_parser.py

@@ -0,0 +1,213 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, cpu_threads, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import cirq\n')
+        f.write('import qsimcirq\n')
+
+        f.write('class U2(cirq.Gate):\n')
+        f.write('    def __init__(self, phi, lam):\n')
+        f.write('        super(U2, self)\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = ((np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))/np.sqrt(2))*np.array([[1, -np.cos(self._l)-1j*np.sin(self._l)], [np.cos(self._p) + 1j*np.sin(self._p), np.cos(self._l + self._p) + 1j*np.sin(self._l+self._p)]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('class U3(cirq.Gate):\n')
+        f.write('    def __init__(self, theta, phi, lam):\n')
+        f.write('        super(U3, self)\n')
+        f.write('        self._t = theta\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = (np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))*np.array([[np.cos(self._t/2.), -np.sin(self._t/2.)*(np.cos(self._l) + 1j*np.sin(self._l))], [np.sin(self._t/2.)*(np.cos(self._p) + 1j*np.sin(self._p)), np.cos(self._t/2.)*(np.cos(self._l + self._p) + 1j*np.sin(self._l + self._p))]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('q = cirq.LineQubit.range({})\n'.format(N))
+
+        f.write('cir = cirq.Circuit()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(q[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=-0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(np.pi*{}).on(q[{}]))\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.append(cirq.CNOT(q[{}], q[{}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('qsim_options = qsimcirq.QSimOptions(cpu_threads={})\n'.format(cpu_threads))
+        f.write('qsim_simulator = qsimcirq.QSimSimulator(qsim_options)\n')
+        f.write('result = qsim_simulator.simulate(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(result.final_state_vector)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qsimcirq.py")
+
+task = 'qft'
+sim_pack = 'qsimcirq'
+com_cap = 'mt'
+prec = 'sp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, 84, input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq/qsimcirq_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+
+
+for N in range(6, 38, 2):
+    input_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/data_files/'
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/heisenberg_dyn_qasm/qsimcirq/qsimcirq_run_files/'
+    output_file = output_file_path + 'h_dyn_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 1, input_file, output_file)
+"""

qasm_parser/qsimcirq_cont_ngpu/qasm_qsimcirq_mnvidia_parser.py

@@ -0,0 +1,191 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, n_gpus, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        # f.write('import os\n')
+        # f.write('os.chdir(\'/data/user/gangap_a/dynamics/qsimcirq_nvidia/qsim/\')\n')
+        # f.write('cwd = os.getcwd()\n')
+        # f.write('import sys\n')
+        # f.write('sys.path.insert(0, \'\')\n')
+
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import numpy as np\n\n')
+        f.write('import cirq\n')
+        f.write('import qsimcirq\n')
+
+        f.write('class U2(cirq.Gate):\n')
+        f.write('    def __init__(self, phi, lam):\n')
+        f.write('        super(U2, self)\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = ((np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))/np.sqrt(2))*np.array([[1, -np.cos(self._l)-1j*np.sin(self._l)], [np.cos(self._p) + 1j*np.sin(self._p), np.cos(self._l + self._p) + 1j*np.sin(self._l+self._p)]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('class U3(cirq.Gate):\n')
+        f.write('    def __init__(self, theta, phi, lam):\n')
+        f.write('        super(U3, self)\n')
+        f.write('        self._t = theta\n')
+        f.write('        self._p = phi\n')
+        f.write('        self._l = lam\n\n')
+
+        f.write('    def _num_qubits_(self):\n')
+        f.write('        return 1\n\n')
+
+        f.write('    def _unitary_(self):\n')
+        f.write('       mat = (np.cos(0.5*(self._p + self._l)) - 1j*np.sin(0.5*(self._p + self._l)))*np.array([[np.cos(self._t/2.), -np.sin(self._t/2.)*(np.cos(self._l) + 1j*np.sin(self._l))], [np.sin(self._t/2.)*(np.cos(self._p) + 1j*np.sin(self._p)), np.cos(self._t/2.)*(np.cos(self._l + self._p) + 1j*np.sin(self._l + self._p))]])\n')
+        f.write('       return mat\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('q = cirq.LineQubit.range({})\n'.format(N))
+
+        f.write('cir = cirq.Circuit()\n')
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(q[{}]))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.XPowGate(exponent=-0.5).on(q[{}]))\n'.format(t_qbit))
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cirq.{}(np.pi*{}).on(q[{}]))\n'.format(s.group(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    # f.write('cir.append(cirq.X(q[{}]).controlled_by(q[{}]))\n'.format(t_qbit,  c_qbit))
+                    f.write('cir.append(cirq.CNOT(q[{}], q[{}]))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U2(np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(U3(np.pi*{}, np.pi*{}, np.pi*{}).on(q[{}]))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+
+
+        f.write('gpu_options = qsimcirq.QSimOptions(gpu_mode={})\n'.format(n_gpus))
+        f.write('qsim_simulator = qsimcirq.QSimSimulator(qsim_options=gpu_options)\n')
+        f.write('result = qsim_simulator.simulate(cir)\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+        # f.write('print(result.final_state_vector)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "../qasm_test/qasm_rqc_test.qasm", "test_cirq.py")
+# parse_qasm_to_package_gen(12, 1, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "test_qsimcirq.py")
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq_cont_na100/qsimcirq_n8_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 8, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qsimcirq_cont_na100/qsimcirq_n8_run_files/'
+    output_file = output_file_path + 'qsimcirq_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 8, input_file, output_file)
+

qasm_parser/quest/qasm_quest_parser.py

@@ -0,0 +1,214 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, precision, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <stdio.h>\n')
+        f.write('#include <math.h>\n')
+        f.write('#include <time.h>\n')
+        f.write('#include <stdlib.h>\n')
+
+        f.write('#include "QuEST.h"\n')
+
+        if precision == 'single':
+            f.write('#define QuEST_PREC 1\n')
+        elif precision == 'double':
+            f.write('#define QuEST_PREC 2\n')
+
+        f.write('#define BILLION 1E9\n')
+
+        f.write('\n')
+
+        f.write('void u2(Qureg qubits, const int q, double p, double l) {\n')
+        f.write('ComplexMatrix2 u = {\n')
+        f.write('.real = {{cos(0.5*(p+l))/sqrt(2), -cos(0.5*(p-l))/sqrt(2)},\n')
+        f.write('\t{cos(0.5*(p-l))/sqrt(2), cos(0.5*(p+l))/sqrt(2)}},\n')
+        f.write('.imag = {{-sin(0.5*(p+l))/sqrt(2), sin(0.5*(p-l))/sqrt(2)},\n')
+        f.write('\t{sin(0.5*(p-l))/sqrt(2), sin(0.5*(p+l))/sqrt(2)}}};\n')
+        f.write('unitary(qubits, q, u);\n')
+        f.write('}\n\n')
+
+        f.write('void u3(Qureg qubits, const int q, double t, double p, double l) {\n')
+        f.write('ComplexMatrix2 u = {\n')
+        f.write('.real = {{cos(0.5*(p+l))*cos(0.5*t), -cos(0.5*(p-l))*sin(0.5*t)},\n')
+        f.write('\t{cos(0.5*(p-l))*sin(0.5*t), cos(0.5*(p+l))*cos(0.5*t)}},\n')
+        f.write('.imag = {{-sin(0.5*(p+l))*cos(0.5*t), sin(0.5*(p-l))*sin(0.5*t)},\n')
+        f.write('\t{sin(0.5*(p-l))*sin(0.5*t), sin(0.5*(p+l))*cos(0.5*t)}}};\n')
+        f.write('unitary(qubits, q, u);\n')
+        f.write('}\n\n')
+
+        f.write('void pauliSX(Qureg qubits, const int q) {\n')
+        f.write('ComplexMatrix2 u = {\n')
+        f.write('.real = {{0.5, 0.5},\n')
+        f.write('\t{0.5, 0.5}},\n')
+        f.write('.imag = {{0.5, -0.5},\n')
+        f.write('\t{-0.5, 0.5}}};\n')
+        f.write('unitary(qubits, q, u);\n')
+        f.write('}\n\n')
+
+        f.write('void pauliSXDG(Qureg qubits, const int q) {\n')
+        f.write('ComplexMatrix2 u = {\n')
+        f.write('.real = {{0.5, 0.5},\n')
+        f.write('\t{0.5, 0.5}},\n')
+        f.write('.imag = {{-0.5, 0.5},\n')
+        f.write('\t{0.5, -0.5}}};\n')
+        f.write('unitary(qubits, q, u);\n')
+        f.write('}\n\n')
+
+        f.write('int main(int argc, char* argv[]){\n')
+
+        f.write('\tQuESTEnv env = createQuESTEnv();\n')
+        f.write('\tQureg qubits = createQureg({}, env);\n'.format(N))
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('// {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'sx' or s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpauli{}(qubits, {});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\trotate{}(qubits, {}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == "s":
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tsGate(qubits, {});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('\tcontrolledNot(qubits, {}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tu2(qubits, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tu3(qubits, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tdestroyQureg(qubits, env);\n')
+        f.write('\tdestroyQuESTEnv(env);\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'rqc'
+sim_pack = 'quest'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(12, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    # save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.c'.format(task, N)
+    parse_qasm_to_package_gen(N, 'double', input_file, output_file)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+"""

qasm_parser/quest/qasm_quest_parser_sp.py

@@ -0,0 +1,214 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, precision, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('#include <stdio.h>\n')
+        f.write('#include <math.h>\n')
+        f.write('#include <time.h>\n')
+        f.write('#include <stdlib.h>\n')
+
+        f.write('#include "QuEST.h"\n')
+
+        if precision == 'single':
+            f.write('#define QuEST_PREC 1\n')
+        elif precision == 'double':
+            f.write('#define QuEST_PREC 2\n')
+
+        f.write('#define BILLION 1E9\n')
+
+        f.write('\n')
+
+        f.write('void u2(Qureg qubits, const int q, float p, float l) {\n')
+        f.write('ComplexMatrix2 u = {\n')
+        f.write('.real = {{cos(0.5*(p+l))/sqrt(2), -cos(0.5*(p-l))/sqrt(2)},\n')
+        f.write('\t{cos(0.5*(p-l))/sqrt(2), cos(0.5*(p+l))/sqrt(2)}},\n')
+        f.write('.imag = {{-sin(0.5*(p+l))/sqrt(2), sin(0.5*(p-l))/sqrt(2)},\n')
+        f.write('\t{sin(0.5*(p-l))/sqrt(2), sin(0.5*(p+l))/sqrt(2)}}};\n')
+        f.write('unitary(qubits, q, u);\n')
+        f.write('}\n\n')
+
+        f.write('void u3(Qureg qubits, const int q, float t, float p, float l) {\n')
+        f.write('ComplexMatrix2 u = {\n')
+        f.write('.real = {{cos(0.5*(p+l))*cos(0.5*t), -cos(0.5*(p-l))*sin(0.5*t)},\n')
+        f.write('\t{cos(0.5*(p-l))*sin(0.5*t), cos(0.5*(p+l))*cos(0.5*t)}},\n')
+        f.write('.imag = {{-sin(0.5*(p+l))*cos(0.5*t), sin(0.5*(p-l))*sin(0.5*t)},\n')
+        f.write('\t{sin(0.5*(p-l))*sin(0.5*t), sin(0.5*(p+l))*cos(0.5*t)}}};\n')
+        f.write('unitary(qubits, q, u);\n')
+        f.write('}\n\n')
+
+        f.write('void pauliSX(Qureg qubits, const int q) {\n')
+        f.write('ComplexMatrix2 u = {\n')
+        f.write('.real = {{0.5, 0.5},\n')
+        f.write('\t{0.5, 0.5}},\n')
+        f.write('.imag = {{0.5, -0.5},\n')
+        f.write('\t{-0.5, 0.5}}};\n')
+        f.write('unitary(qubits, q, u);\n')
+        f.write('}\n\n')
+
+        f.write('void pauliSXDG(Qureg qubits, const int q) {\n')
+        f.write('ComplexMatrix2 u = {\n')
+        f.write('.real = {{0.5, 0.5},\n')
+        f.write('\t{0.5, 0.5}},\n')
+        f.write('.imag = {{-0.5, 0.5},\n')
+        f.write('\t{0.5, -0.5}}};\n')
+        f.write('unitary(qubits, q, u);\n')
+        f.write('}\n\n')
+
+        f.write('int main(int argc, char* argv[]){\n')
+
+        f.write('\tQuESTEnv env = createQuESTEnv();\n')
+        f.write('\tQureg qubits = createQureg({}, env);\n'.format(N))
+
+        f.write('\tstruct timespec requestStart, requestEnd;\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestStart);\n')
+
+        lc = 0
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits', 'cirq']:
+                    lc = lc + 1
+                    f.write('// {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 'sx' or s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tpauli{}(qubits, {});\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\thadamard(qubits, {});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\trotate{}(qubits, {}, M_PI*{});\n'.format(s.group()[1].upper(), t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == "s":
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tsGate(qubits, {});\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('\tcontrolledNot(qubits, {}, {});\n'.format(c_qbit, t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tu2(qubits, {}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('\tu3(qubits, {}, M_PI*{}, M_PI*{}, M_PI*{});\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('\tdestroyQureg(qubits, env);\n')
+        f.write('\tdestroyQuESTEnv(env);\n')
+        f.write('\tclock_gettime(CLOCK_REALTIME, &requestEnd);\n')
+
+        f.write('\tdouble accum = (requestEnd.tv_sec - requestStart.tv_sec) + (requestEnd.tv_nsec - requestStart.tv_nsec)/BILLION;\n')
+        f.write('\tprintf( "%lf, ", accum );\n')
+        f.write('\treturn 0;\n')
+        f.write('}')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+task = 'rqc'
+sim_pack = 'quest'
+com_cap = 'mt'
+prec = 'sp'
+
+for N in range(12, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    # save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.c'.format(task, N)
+    parse_qasm_to_package_gen(N, 'single', input_file, output_file)
+
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/quest/QuEST/rqc/quest_sp_run_files/'
+    output_file = output_file_path + 'quest_rqc_n{}.c'.format(N)
+    parse_qasm_to_package_gen(N, 'float', input_file, output_file)
+
+"""

qasm_parser/qulacs/qasm_qulacs_gpu_new_parser.py

@@ -0,0 +1,200 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import numpy as np\n')
+        f.write('import qulacs as qul\n')
+        f.write('from qulacs.gate import DenseMatrix\n')
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('def Rx(q, t):\n')
+        f.write('    mat = [[np.cos(0.5*t), -1j*np.sin(0.5*t)], [-1j*np.sin(0.5*t), np.cos(0.5*t)]]\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('def Ry(q, t):\n')
+        f.write('    mat = [[np.cos(0.5*t), -np.sin(0.5*t)], [np.sin(0.5*t), np.cos(0.5*t)]]\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('def Rz(q, t):\n')
+        f.write('    mat = [[np.exp(-0.5j*t), 0.], [0., np.exp(0.5j*t)]]\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('def U2(q, p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('def U3(q, t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('qc = qul.QuantumCircuit({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.add_{}_gate({})\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.add_sqrtX_gate({})\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.add_sqrtXdag_gate({})\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('qc.add_{}gate({}, np.pi*{})\n'.format(s.group().upper(),  t_qbit, float(m_r[0][0])))
+                    f.write('qc.add_gate(R{}({}, np.pi*{}))\n'.format(s.group()[1], t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('qc.add_CNOT_gate({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('qc.add_U2_gate({}, np.pi*{}, np.pi*{})\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    f.write('qc.add_gate(U2({}, np.pi*{}, np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.add_gate(U3({}, np.pi*{}, np.pi*{}, np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        # f.write('init_state = qul.QuantumState({})\n'.format(N))
+        f.write('init_state = qul.QuantumStateGpu({})\n'.format(N))
+        f.write('init_state.set_zero_state()\n')
+        f.write('qc.update_quantum_state(init_state)\n')
+
+        f.write('del init_state\n')
+        f.write('del qc\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "n12_qulacs.py")
+
+task = 'qft'
+sim_pack = 'qulacs'
+com_cap = 'gpu'
+prec = 'dp'
+
+for N in range(6, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+r"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_gpu_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_gpu_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/qulacs/qasm_qulacs_new_parser.py

@@ -0,0 +1,200 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, input_filename, output_filename, save_data_path):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import numpy as np\n')
+        f.write('import qulacs as qul\n')
+        f.write('from qulacs.gate import DenseMatrix\n')
+        f.write('import os\n')
+        f.write('from time import process_time, perf_counter\n')
+
+        f.write('def Rx(q, t):\n')
+        f.write('    mat = [[np.cos(0.5*t), -1j*np.sin(0.5*t)], [-1j*np.sin(0.5*t), np.cos(0.5*t)]]\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('def Ry(q, t):\n')
+        f.write('    mat = [[np.cos(0.5*t), -np.sin(0.5*t)], [np.sin(0.5*t), np.cos(0.5*t)]]\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('def Rz(q, t):\n')
+        f.write('    mat = [[np.exp(-0.5j*t), 0.], [0., np.exp(0.5j*t)]]\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('def U2(q, p, l):\n')
+        f.write('    mat = ((np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))/np.sqrt(2))*np.array([[1, -np.cos(l)-1j*np.sin(l)], [np.cos(p) + 1j*np.sin(p), np.cos(l + p) + 1j*np.sin(l + p)]])\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('def U3(q, t, p, l):\n')
+        f.write('    mat = (np.cos(0.5*(p + l)) - 1j*np.sin(0.5*(p + l)))*np.array([[np.cos(t/2.), -np.sin(t/2.)*(np.cos(l) + 1j*np.sin(l))], [np.sin(t/2.)*(np.cos(p) + 1j*np.sin(p)), np.cos(t/2.)*(np.cos(l + p) + 1j*np.sin(l + p))]])\n')
+        f.write('    return DenseMatrix(q, mat)\n\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('qc = qul.QuantumCircuit({})\n'.format(N))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.add_{}_gate({})\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.add_sqrtX_gate({})\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.add_sqrtXdag_gate({})\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('qc.add_{}gate({}, np.pi*{})\n'.format(s.group().upper(),  t_qbit, float(m_r[0][0])))
+                    f.write('qc.add_gate(R{}({}, np.pi*{}))\n'.format(s.group()[1], t_qbit, float(m_r[0][0])))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('qc.add_CNOT_gate({}, {})\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    # f.write('qc.add_U2_gate({}, np.pi*{}, np.pi*{})\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    f.write('qc.add_gate(U2({}, np.pi*{}, np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0])))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('qc.add_gate(U3({}, np.pi*{}, np.pi*{}, np.pi*{}))\n'.format(t_qbit, float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0])))
+                    continue
+
+        f.write('init_state = qul.QuantumState({})\n'.format(N))
+        f.write('init_state.set_zero_state()\n')
+        f.write('qc.update_quantum_state(init_state)\n')
+
+        f.write('del init_state\n')
+        f.write('del qc\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        f.write('os.chdir(\'{}\')\n'.format(save_data_path))
+        f.write('np.save(\'time_n{}.npy\', [t_e - t_s, t_ep - t_sp])\n'.format(N))
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+# parse_qasm_to_package_gen(12, "/data/user/gangap_a/rqc/data_files/circuit_n12_m14_s0_e0_pEFGH.qasm", "n12_qulacs.py")
+
+task = 'rqc'
+sim_pack = 'qulacs'
+com_cap = 'mt'
+prec = 'dp'
+
+for N in range(12, 40, 2):
+    input_file_path = '/data/user/gangap_a/{}_singular/qasm_files/'.format(task)
+    input_file = input_file_path + 'qasm_N_{}.qasm'.format(N)
+
+    save_file_path = '/data/user/gangap_a/{}_singular/{}/data_{}_{}'.format(task, sim_pack, com_cap, prec)
+
+    output_file_path = '/data/user/gangap_a/{}_singular/{}/run_files_{}_{}/'.format(task, sim_pack, com_cap, prec)
+
+    output_file = output_file_path + '{}_n{}.py'.format(task, N)
+    parse_qasm_to_package_gen(N, input_file, output_file, save_file_path)
+
+
+"""
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/qulacs/qulacs_run_files/'
+    output_file = output_file_path + 'qulacs_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, input_file, output_file)
+
+"""

qasm_parser/svsim/qasm_svsim_gpu_a100_parser.py

@@ -0,0 +1,152 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, n_cores, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('import sys\n')
+        f.write('sys.path.insert(0, \'/data/user/gangap_a/rqc/svsim/SV-Sim/svsim/build_a100\')\n')
+        f.write('import numpy as np\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import libsvsim as svsim\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('cir = svsim.Simulation({}, {})\n'.format(N, n_cores))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|h|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's' or s.group() == 'h':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.{}({}))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.SRN({}))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.RX(-0.5*np.pi, {}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.{}(np.pi*{}, {}))\n'.format(s.group().upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.append(cir.CX({}, {}))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.U2(np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.U3(np.pi*{}, np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('cir.upload()\n')
+        f.write('cir.run()\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim/svsim_gpu_a100_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 0, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim/svsim_gpu_a100_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 0, input_file, output_file)
+

qasm_parser/svsim/qasm_svsim_gpu_ma100_parser.py

@@ -0,0 +1,152 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, n_cores, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('import sys\n')
+        f.write('sys.path.insert(0, \'/data/user/gangap_a/rqc/svsim/SV-Sim/svsim/build_ma100\')\n')
+        f.write('import numpy as np\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import libsvsim as svsim\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('cir = svsim.Simulation({}, {})\n'.format(N, n_cores))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.{}({}))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.SRN({}))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.RX(-0.5*np.pi, {}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.{}(np.pi*{}, {}))\n'.format(s.group().upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.append(cir.CX({}, {}))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.U2(np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.U3(np.pi*{}, np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('cir.upload()\n')
+        f.write('cir.run()\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim_na100/svsim_n8_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 8, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim_na100/svsim_n8_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 8, input_file, output_file)
+

qasm_parser/svsim/qasm_svsim_gpu_parser.py

@@ -0,0 +1,152 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, n_cores, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('import sys\n')
+        f.write('sys.path.insert(0, \'/data/user/gangap_a/dynamics/sv_sim/SV-Sim/svsim/build_gpu\')\n')
+        f.write('import numpy as np\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import libsvsim as svsim\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('cir = svsim.Simulation({}, {})\n'.format(N, n_cores))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.{}({}))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.SRN({}))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.RX(-0.5*np.pi, {}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.{}(np.pi*{}, {}))\n'.format(s.group().upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.append(cir.CX({}, {}))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.U2(np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.U3(np.pi*{}, np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('cir.upload()\n')
+        f.write('cir.run()\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim/svsim_gpu_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 0, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim/svsim_gpu_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 0, input_file, output_file)
+

qasm_parser/svsim/qasm_svsim_mt_parser.py

@@ -0,0 +1,152 @@
+# Credit to: https://github.com/qulacs/cirq-qulacs/blob/master/benchmark/benchmark_state_vector_qulacs.py
+
+import re
+import subprocess
+
+def parse_qasm_to_package_gen(N, n_cores, input_filename, output_filename):
+
+    with open(output_filename, 'w') as f:
+
+        f.write('import os\n')
+        f.write('import sys\n')
+        f.write('sys.path.insert(0, \'/data/user/gangap_a/dynamics/sv_sim/SV-Sim/svsim/build_omp\')\n')
+        f.write('import numpy as np\n')
+        f.write('from time import process_time, perf_counter\n')
+        f.write('import libsvsim as svsim\n')
+
+        f.write('t_sp = process_time()\n')
+        f.write('t_s = perf_counter()\n')
+
+        f.write('cir = svsim.Simulation({}, {})\n'.format(N, n_cores))
+
+        with open(input_filename, "r") as ifile:
+            lines = ifile.readlines()
+
+            lc = 0
+            cirq_c = 0
+            for line in lines:
+
+                s = re.search(r"Generated|QASM|include|qreg|Qubits|cirq|x|y|z|rx|ry|rz|cx|u2|u3|\bsx\b|\bsxdg\b|s", line)
+
+                if s is None:
+                    continue
+
+                elif s.group() in ['Generated', 'QASM', 'include', 'qreg', 'Qubits']:#, 'cirq']:
+                    lc = lc + 1
+                    f.write('# {}\n'.format(s.group()))
+                    continue
+
+                elif s.group() == 'cirq':
+                    lc = lc + 1
+                    f.write('# {} {}\n'.format(s.group(), cirq_c))
+                    cirq_c = cirq_c + 1
+                    continue
+
+                elif s.group() == 'x' or s.group() == 'y' or s.group() == 'z' or s.group() == 's':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.{}({}))\n'.format(s.group().upper(), t_qbit))
+                    continue
+
+                elif s.group() == 'sx':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.SRN({}))\n'.format(t_qbit))
+
+                elif s.group() == 'sxdg':
+                    lc = lc + 1
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.RX(-0.5*np.pi, {}))\n'.format(t_qbit))
+                    continue
+
+                elif s.group() == 'rx' or s.group() == 'ry' or s.group() == 'rz':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?)\)', line)
+                    # print(m_r)
+                    if 'pi' in m_r[0] and 'e' in m_r[0]:
+                        sp_str = m_r[0].split('e-')
+                        m_r[0] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                    elif 'pi' in m_r[0]:
+                        m_r[0] = re.findall(r'[-]?\d*\.\d\d*', m_r[0])
+                    # print(m_r)
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.{}(np.pi*{}, {}))\n'.format(s.group().upper(), float(m_r[0][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'cx':
+                    lc = lc + 1
+                    match = re.findall(r'\[\d\d*\]', line)
+                    c_qbit = int(match[0].strip('[]'))
+                    t_qbit = int(match[1].strip('[]'))
+                    f.write('cir.append(cir.CX({}, {}))\n'.format(c_qbit,  t_qbit))
+                    continue
+
+                elif s.group() == 'u2':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.U2(np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]), t_qbit))
+                    continue
+
+                elif s.group() == 'u3':
+                    lc = lc + 1
+                    m_r = re.findall(r'\((.*?,.*?,.*?)\)', line)
+                    m_r = m_r[0].split(',')
+                    for i, m in enumerate(m_r):
+                        if 'pi' in m and 'e' in m:
+                            sp_str = m_r[i].split('e-')
+                            m_r[i] = [re.findall(r'[-]?\d*\.\d\d*', sp_str[0])[0] + 'E-' + sp_str[1]]
+                        elif 'pi' in m:
+                            m_r[i] = re.findall(r'[-]?\d*\.\d\d*', m)
+                        else:
+                            m_r[i] = '0'
+                    m_i = re.findall(r'\[\d\d*\]', line)
+                    t_qbit = int(m_i[0].strip('[]'))
+                    f.write('cir.append(cir.U3(np.pi*{}, np.pi*{}, np.pi*{}, {}))\n'.format(float(m_r[0][0]), float(m_r[1][0]),float(m_r[2][0]), t_qbit))
+                    continue
+
+        f.write('cir.upload()\n')
+        f.write('cir.run()\n')
+
+        f.write('t_e = perf_counter()\n')
+        f.write('t_ep = process_time()\n')
+        f.write('print(t_e - t_s)\n')
+        f.write('print(t_ep - t_sp)\n')
+
+        # result = subprocess.run(["grep", ".", input_filename, "|", "wc", "-l"], text=True)#stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
+        _cmd = "grep . " + input_filename + "| wc -l"
+        lc_res = subprocess.check_output(_cmd, shell=True)
+        print(int(lc_res) == lc)
+        # print(lc)
+
+
+for N in range(12, 42, 2):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim/svsim_mt_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 84, input_file, output_file)
+
+for N in range(41, 51):
+    input_file_path = '/data/user/gangap_a/rqc/data_files/'
+    input_file = input_file_path + 'circuit_n{}_m14_s0_e0_pEFGH.qasm'.format(N)
+
+    output_file_path = '/data/user/gangap_a/rqc/svsim/svsim_mt_run_files/'
+    output_file = output_file_path + 'svsim_rqc_n{}.py'.format(N)
+    parse_qasm_to_package_gen(N, 84, input_file, output_file)
+