From 84ce5e48cc13229a7a691b421a7e5b4750cde312 Mon Sep 17 00:00:00 2001 From: Paul Nation Date: Mon, 11 Mar 2019 18:49:30 -0400 Subject: [PATCH 01/24] Add openpulse simulator --- .gitignore | 2 +- example/pulse_sim.ipynb | 870 +++++++++ qiskit/__init__.py | 13 + qiskit/providers/__init__.py | 13 + qiskit/providers/aer/aerprovider.py | 4 +- .../providers/aer/backends/pulse_simulator.py | 107 ++ qiskit/providers/aer/openpulse/__init__.py | 27 + qiskit/providers/aer/openpulse/cy/__init__.py | 13 + .../aer/openpulse/cy/channel_value.pxd | 25 + .../aer/openpulse/cy/channel_value.pyx | 107 ++ qiskit/providers/aer/openpulse/cy/measure.pyx | 73 + qiskit/providers/aer/openpulse/cy/memory.pyx | 44 + qiskit/providers/aer/openpulse/cy/utils.pyx | 45 + .../providers/aer/openpulse/qobj/__init__.py | 13 + qiskit/providers/aer/openpulse/qobj/digest.py | 578 ++++++ .../providers/aer/openpulse/qobj/op_qobj.py | 214 +++ .../providers/aer/openpulse/qobj/op_system.py | 56 + .../providers/aer/openpulse/qobj/operators.py | 257 +++ .../providers/aer/openpulse/qobj/opparse.py | 420 ++++ .../aer/openpulse/qutip_lite/__init__.py | 47 + .../aer/openpulse/qutip_lite/cy/__init__.py | 0 .../openpulse/qutip_lite/cy/complex_math.pxi | 24 + .../aer/openpulse/qutip_lite/cy/math.pxd | 36 + .../aer/openpulse/qutip_lite/cy/math.pyx | 125 ++ .../openpulse/qutip_lite/cy/parameters.pxi | 14 + .../aer/openpulse/qutip_lite/cy/pyxbuilder.py | 66 + .../qutip_lite/cy/sparse_routines.pxi | 644 +++++++ .../qutip_lite/cy/sparse_structs.pxd | 59 + .../openpulse/qutip_lite/cy/sparse_utils.pyx | 375 ++++ .../aer/openpulse/qutip_lite/cy/spconvert.pxd | 39 + .../aer/openpulse/qutip_lite/cy/spconvert.pyx | 303 +++ .../openpulse/qutip_lite/cy/spmatfuncs.pxd | 115 ++ .../openpulse/qutip_lite/cy/spmatfuncs.pyx | 570 ++++++ .../aer/openpulse/qutip_lite/cy/spmath.pxd | 59 + .../aer/openpulse/qutip_lite/cy/spmath.pyx | 763 ++++++++ .../aer/openpulse/qutip_lite/cy/src/zspmv.cpp | 172 ++ .../aer/openpulse/qutip_lite/cy/src/zspmv.hpp | 53 + .../aer/openpulse/qutip_lite/cy/utilities.py | 67 + .../aer/openpulse/qutip_lite/dimensions.py | 199 ++ .../aer/openpulse/qutip_lite/expect.py | 143 ++ .../aer/openpulse/qutip_lite/fastsparse.py | 435 +++++ .../aer/openpulse/qutip_lite/operators.py | 611 ++++++ .../aer/openpulse/qutip_lite/qobj.py | 1698 +++++++++++++++++ .../aer/openpulse/qutip_lite/settings.py | 61 + .../aer/openpulse/qutip_lite/sparse.py | 588 ++++++ .../aer/openpulse/qutip_lite/states.py | 358 ++++ .../aer/openpulse/qutip_lite/superoperator.py | 326 ++++ .../aer/openpulse/qutip_lite/tensor.py | 111 ++ qiskit/providers/aer/openpulse/readme.md | 59 + .../aer/openpulse/solver/__init__.py | 13 + .../providers/aer/openpulse/solver/codegen.py | 282 +++ .../aer/openpulse/solver/data_config.py | 124 ++ .../aer/openpulse/solver/monte_carlo.py | 177 ++ .../providers/aer/openpulse/solver/opsolve.py | 276 +++ .../providers/aer/openpulse/solver/options.py | 107 ++ .../aer/openpulse/solver/rhs_utils.py | 47 + .../aer/openpulse/solver/settings.py | 18 + .../providers/aer/openpulse/solver/unitary.py | 100 + .../providers/aer/openpulse/solver/zvode.py | 39 + setup.py | 67 + 60 files changed, 12249 insertions(+), 2 deletions(-) create mode 100644 example/pulse_sim.ipynb create mode 100644 qiskit/__init__.py create mode 100644 qiskit/providers/__init__.py create mode 100644 qiskit/providers/aer/backends/pulse_simulator.py create mode 100644 qiskit/providers/aer/openpulse/__init__.py create mode 100644 qiskit/providers/aer/openpulse/cy/__init__.py create mode 100644 qiskit/providers/aer/openpulse/cy/channel_value.pxd create mode 100644 qiskit/providers/aer/openpulse/cy/channel_value.pyx create mode 100644 qiskit/providers/aer/openpulse/cy/measure.pyx create mode 100644 qiskit/providers/aer/openpulse/cy/memory.pyx create mode 100644 qiskit/providers/aer/openpulse/cy/utils.pyx create mode 100644 qiskit/providers/aer/openpulse/qobj/__init__.py create mode 100644 qiskit/providers/aer/openpulse/qobj/digest.py create mode 100644 qiskit/providers/aer/openpulse/qobj/op_qobj.py create mode 100644 qiskit/providers/aer/openpulse/qobj/op_system.py create mode 100644 qiskit/providers/aer/openpulse/qobj/operators.py create mode 100644 qiskit/providers/aer/openpulse/qobj/opparse.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/__init__.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/__init__.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/complex_math.pxi create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/math.pxd create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/math.pyx create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/parameters.pxi create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_routines.pxi create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_structs.pxd create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_utils.pyx create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/spconvert.pxd create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/spconvert.pyx create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/spmatfuncs.pxd create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/spmatfuncs.pyx create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/spmath.pxd create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/spmath.pyx create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/src/zspmv.cpp create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/src/zspmv.hpp create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/utilities.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/dimensions.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/expect.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/operators.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/qobj.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/settings.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/sparse.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/states.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/superoperator.py create mode 100755 qiskit/providers/aer/openpulse/qutip_lite/tensor.py create mode 100644 qiskit/providers/aer/openpulse/readme.md create mode 100644 qiskit/providers/aer/openpulse/solver/__init__.py create mode 100644 qiskit/providers/aer/openpulse/solver/codegen.py create mode 100644 qiskit/providers/aer/openpulse/solver/data_config.py create mode 100644 qiskit/providers/aer/openpulse/solver/monte_carlo.py create mode 100644 qiskit/providers/aer/openpulse/solver/opsolve.py create mode 100644 qiskit/providers/aer/openpulse/solver/options.py create mode 100644 qiskit/providers/aer/openpulse/solver/rhs_utils.py create mode 100644 qiskit/providers/aer/openpulse/solver/settings.py create mode 100644 qiskit/providers/aer/openpulse/solver/unitary.py create mode 100644 qiskit/providers/aer/openpulse/solver/zvode.py diff --git a/.gitignore b/.gitignore index 14c1bba494..66d02cb01b 100644 --- a/.gitignore +++ b/.gitignore @@ -17,6 +17,7 @@ out/* *.whl *.egg* build/* +qiskit/providers/aer/backends/libomp.dylib # Ignore macOS DS_Store .DS_Store @@ -33,4 +34,3 @@ test/.asv docs/_build/ docs/stubs/ docs/api/ - diff --git a/example/pulse_sim.ipynb b/example/pulse_sim.ipynb new file mode 100644 index 0000000000..bcab81db2d --- /dev/null +++ b/example/pulse_sim.ipynb @@ -0,0 +1,870 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Open Pulse Simulator - Rabi Example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "If running the openpulse branch from source, may need to add a symbolic link in site-packages. Also run `python setup.py build_ext --inplace` in openpulse first." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "#Import general libraries (needed for functions)\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import curve_fit\n", + "\n", + "#Import Qiskit classes classes\n", + "import qiskit\n", + "#from qiskit.providers.aer.noise import NoiseModel\n", + "#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error\n", + "\n", + "import qiskit.pulse as pulse\n", + "import qiskit.pulse.pulse_lib as pulse_lib\n", + "from qiskit.compiler import assemble\n", + "import random" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 2, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "qiskit.IBMQ.load_account()" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#Get a pulse configuration from pok\n", + "provider = qiskit.IBMQ.get_provider(hub='ibm-q-dev',group='qiskit', project='ignis')\n", + "backend_real = provider.get_backend('ibmq_poughkeepsie')\n", + "back_config = backend_real.configuration().to_dict()\n", + "system = pulse.PulseChannelSpec.from_backend(backend_real)" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "#Get pulse simulator backend\n", + "backend_sim = qiskit.Aer.get_backend('pulse_simulator')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Simulations\n", + "\n", + "### These need to be run in sequential order\n", + "\n", + "[Rabi Oscillation](#rabi)\n", + "Apply a pulse to Q0 and measure the population evoluation versus pulse amplitude\n", + "\n", + "[Measurement Level 1 for the Readout Test](#readout_test)\n", + "
Prepare the |0> and |1> states and look at the measurement level 1 output \n", + "\n", + "[CR Oscillation](#cr)\n", + "
Look at the Q1 State when we drive Q0 at the frequency of Q1\n", + "\n", + "[T1](#t1)\n", + "
Demonstrating noise with pulse" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Simulate a Rabi Oscillation" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "First, we are going to simulate a rabi oscillation, i.e., meausure the qubit state population versus the amplitude of a drive pulse. This is the same example that is in the tutorials." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Build Pulse Schedule " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Build on qubit 0" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "#qubit to use for exeperiment\n", + "qubit = 0\n", + "# exp configuration\n", + "exps = 41\n", + "shots = 512\n", + "\n", + "# Rabi pulse\n", + "drive_amps = np.linspace(0, 0.9, exps)\n", + "drive_samples = 128\n", + "drive_sigma = 16\n", + "\n", + "# Measurement pulse\n", + "meas_amp = 0.025\n", + "meas_samples = 1200\n", + "meas_sigma = 4\n", + "meas_risefall = 25\n", + "\n", + "# Measurement pulse (common for all experiment)\n", + "meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp,\n", + " sigma=meas_sigma, risefall=meas_risefall, \n", + " name='meas_pulse')\n", + "acq_cmd=pulse.Acquire(duration=meas_samples)\n", + "\n", + "# create measurement schedule\n", + "measure_and_acquire = meas_pulse(system.qubits[qubit].measure) | acq_cmd(system.acquires, system.memoryslots)\n", + "\n", + "# Create schedule\n", + "schedules = []\n", + "for ii, drive_amp in enumerate(drive_amps):\n", + " # drive pulse\n", + " rabi_pulse = pulse_lib.gaussian(duration=drive_samples, \n", + " amp=drive_amp, \n", + " sigma=drive_sigma, name='rabi_pulse_%d' % ii)\n", + " \n", + " # add commands to schedule\n", + " schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp)\n", + " \n", + " schedule += rabi_pulse(system.qubits[qubit].drive)\n", + " schedule += measure_and_acquire << schedule.duration\n", + " \n", + " schedules.append(schedule)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Design the Hamiltonian" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's build a transmon Hamiltonian with anharmonicity to test the Rabi oscillation and CR" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "hamiltonian = {}\n", + "hamiltonian['h_str'] = []\n", + "#Q0 terms\n", + "hamiltonian['h_str'].append('pi*(2*v0-alpha0)*O0')\n", + "hamiltonian['h_str'].append('pi*alpha0*O0*O0')\n", + "hamiltonian['h_str'].append('2*pi*r*X0||D0')\n", + "hamiltonian['h_str'].append('2*pi*r*X0||U0')\n", + "\n", + "#Q1 terms\n", + "hamiltonian['h_str'].append('pi*(2*v1-alpha1)*O1')\n", + "hamiltonian['h_str'].append('pi*alpha1*O1*O1')\n", + "hamiltonian['h_str'].append('X1||r*D1')\n", + "\n", + "#Exchange coupling betwene Q0 and Q1\n", + "hamiltonian['h_str'].append('2*pi*j*(Sp0*Sm1+Sm0*Sp1)')\n", + "hamiltonian['vars'] = {'v0': 5.00, 'v1': 5.1, 'j': 0.01, \n", + " 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33}\n", + "\n", + "#set the qubit dimensions to 3\n", + "hamiltonian['qub'] = {'0': 3, '1': 3}\n", + "\n", + "#update the back_end\n", + "back_config['hamiltonian'] = hamiltonian\n", + "back_config['noise'] = {}\n", + "back_config['dt'] = 1.0" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Add Solver Settings" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Any solver settings also does into the back_config" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "back_config['ode_options'] = {}" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Restrict the Qubits Used in the Simulation " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use a qubit whitelist (`qubit_list`) to restrict the set of qubits used in the solution. The pulse simulator will appropriately alter the Hamiltonian. To start let's assume the list contains the first 2 qubits." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [], + "source": [ + "back_config['qubit_list'] = [0,1]\n", + "#back_config['qubit_list'] = None" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Assemble the qobj with the backend config file and the qubit_list" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We have to do this step twice to get the dressed frequencies for setting the LO's. Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "rabi_qobj = assemble(schedules, backend_real, \n", + " meas_level=1, meas_return='avg', \n", + " memory_slots=2,\n", + " shots=shots, sim_config = back_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "evals = backend_sim.get_dressed_energies(rabi_qobj)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([ 0. , 4.9990098 , 9.66953431, 5.1009902 , 10.10132826,\n", + " 14.76614835, 9.86913744, 14.87385165, 19.54 ])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "evals/2/np.pi" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [], + "source": [ + "rabi_qobj = assemble(schedules, backend_real, \n", + " meas_level=1, meas_return='avg', \n", + " memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi,\n", + " evals[3]/2/np.pi],\n", + " shots=shots, sim_config = back_config)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Simulate" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "#Note: this is how to run bypassing the backend\n", + "#opsys = qiskit.providers.aer.openpulse.qobj.digest.digest_pulse_obj(rabi_qobj.to_dict())\n", + "#simdata = qiskit.providers.aer.openpulse.solver.opsolve.opsolve(opsys)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "sim_result = backend_sim.run(rabi_qobj).result()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Extract the qubit populations " + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "amp_data_Q0 = []\n", + "amp_data_Q1 = []\n", + "\n", + "for exp_idx in range(len(drive_amps)):\n", + " exp_mem = sim_result.get_memory(exp_idx)\n", + " amp_data_Q0.append(np.abs(exp_mem[0]))\n", + " amp_data_Q1.append(np.abs(exp_mem[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pi Amplitude 0.314328\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Fit the data\n", + "fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B)\n", + "fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5])\n", + "\n", + "#get the pi amplitude\n", + "pi_amp = (fitparams[3])*fitparams[2]/2/np.pi\n", + "\n", + "plt.plot(drive_amps, amp_data_Q0, label='Q0')\n", + "plt.plot(drive_amps, amp_data_Q1, label='Q1')\n", + "plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit')\n", + "plt.axvline(pi_amp, color='black', linestyle='dashed')\n", + "plt.legend()\n", + "plt.xlabel('Pulse amplitude, a.u.', fontsize=20)\n", + "plt.ylabel('Signal, a.u.', fontsize=20)\n", + "plt.title('Rabi on Q0', fontsize=20)\n", + "plt.grid(True)\n", + "\n", + "print('Pi Amplitude %f'%(pi_amp))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Look at the Shots Distribution" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the pulse amplitude calibrated above, do an experiment with no pulse and an experiment with a pi pulse and look at the measurement outcomes. " + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "# Create schedule\n", + "pi_pulse = pulse_lib.gaussian(duration=drive_samples,\n", + " amp=pi_amp, \n", + " sigma=drive_sigma,\n", + " name='pi_pulse')\n", + "\n", + "pi_2_pulse = pulse_lib.gaussian(duration=drive_samples,\n", + " amp=pi_amp/2, \n", + " sigma=drive_sigma,\n", + " name='pi_2_pulse')\n", + " \n", + "# excited\n", + "excited_exp = pulse.Schedule(name='pi_exp')\n", + "excited_exp += pi_pulse(system.qubits[qubit].drive)\n", + "measure_time = excited_exp.duration\n", + "excited_exp |= measure_and_acquire << measure_time\n", + "\n", + "# superposition\n", + "sup_exp = pulse.Schedule(name='pi_2_exp')\n", + "sup_exp += pi_2_pulse(system.qubits[qubit].drive)\n", + "measure_time = sup_exp.duration\n", + "sup_exp |= measure_and_acquire << measure_time\n", + "\n", + "# ground\n", + "ground_exp = pulse.Schedule(name='no_pi_exp')\n", + "ground_exp |= pulse.Schedule(name='ground_exp')\n", + "ground_exp |= measure_and_acquire << measure_time \n", + "\n", + "excited_exp_schedules = [ground_exp, sup_exp, excited_exp]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Change the `meas_return=single` which will return each individual measurement" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [], + "source": [ + "readout_qobj = assemble(excited_exp_schedules, backend_real, \n", + " meas_level=1, meas_return='single', \n", + " memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi,\n", + " evals[3]/2/np.pi],\n", + " shots=shots, sim_config = back_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [], + "source": [ + "sim_result = backend_sim.run(readout_qobj).result()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Plot the data, there is no measurement error in the simulator data so the histographs will be all centered at the average point." + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [], + "source": [ + "ground_data = sim_result.get_memory(0)[:, qubit]\n", + "excited_data = sim_result.get_memory(2)[:, qubit]\n", + "sup_data = sim_result.get_memory(1)[:, qubit]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Add some random noise to the data to better approximate the experiment" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "for idx in range(len(ground_data)):\n", + " ground_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1)\n", + " excited_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1)\n", + " sup_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Q (a.u.)')" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "\n", + "plt.scatter(np.real(ground_data), np.imag(ground_data), s=5, cmap='viridis',c='blue',alpha=0.5, label='|0>')\n", + "plt.scatter(np.real(excited_data), np.imag(excited_data), s=5, cmap='viridis',c='green',alpha=0.5, label='|1>')\n", + "plt.scatter(np.real(sup_data), np.imag(sup_data), s=5, cmap='viridis',c='red',alpha=0.5, label='|0>+|1>')\n", + "ground_center = np.mean(ground_data)\n", + "excited_center = np.mean(excited_data)\n", + "sup_center = np.mean(sup_data)\n", + "\n", + "plt.scatter(np.real(ground_center), np.imag(ground_center), c='blue', s=200, alpha=1.0)\n", + "plt.scatter(np.real(excited_center), np.imag(excited_center), c='green', s=200, alpha=1.0)\n", + "plt.scatter(np.real(sup_center), np.imag(sup_center), c='red', s=200, alpha=1.0)\n", + "\n", + "plt.title('Kernel integrated I-Q scatter plot', fontsize=20)\n", + "plt.legend(loc='upper right')\n", + "plt.xlabel('I (a.u.)', fontsize=16)\n", + "plt.ylabel('Q (a.u.)', fontsize=16)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# Cross-Resonance" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Simulate cross-resonance by driving on U0. Note you need to run Rabi first to setup the hamiltonian." + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [], + "source": [ + "#qubit to use for exeperiment\n", + "qubit = 0\n", + "# exp configuration\n", + "exps = 41\n", + "shots = 512\n", + "\n", + "# Rabi pulse\n", + "cr_drive_amps = np.linspace(0, 0.9, exps)\n", + "cr_drive_samples = 128*3\n", + "cr_drive_sigma = 4\n", + "\n", + "\n", + "# Create schedule\n", + "schedules = []\n", + "for ii, cr_drive_amp in enumerate(cr_drive_amps):\n", + " # drive pulse\n", + " cr_rabi_pulse = pulse_lib.gaussian_square(duration=cr_drive_samples, \n", + " amp=cr_drive_amp, \n", + " risefall=cr_drive_sigma*4,\n", + " sigma=cr_drive_sigma, name='rabi_pulse_%d' % ii)\n", + " \n", + " # add commands to schedule\n", + " schedule = pulse.Schedule(name='cr_rabi_exp_amp_%s' % cr_drive_amp)\n", + " \n", + " schedule += cr_rabi_pulse(system.controls[0])\n", + " schedule += measure_and_acquire << schedule.duration\n", + " \n", + " schedules.append(schedule)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [], + "source": [ + "cr_rabi_qobj = assemble(schedules, backend_real, \n", + " meas_level=1, meas_return='avg', \n", + " memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi,\n", + " evals[3]/2/np.pi],\n", + " shots=shots, sim_config = back_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "sim_result = backend_sim.run(cr_rabi_qobj).result()" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "metadata": {}, + "outputs": [], + "source": [ + "amp_data_Q0 = []\n", + "amp_data_Q1 = []\n", + "\n", + "for exp_idx in range(len(cr_drive_amps)):\n", + " exp_mem = sim_result.get_memory(exp_idx)\n", + " amp_data_Q0.append(np.abs(exp_mem[0]))\n", + " amp_data_Q1.append(np.abs(exp_mem[1]))" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "plt.plot(drive_amps, amp_data_Q0, label='Q0')\n", + "plt.plot(drive_amps, amp_data_Q1, label='Q1')\n", + "plt.legend()\n", + "plt.xlabel('Pulse amplitude, a.u.', fontsize=20)\n", + "plt.ylabel('Signal, a.u.', fontsize=20)\n", + "plt.title('CR (Target Q1, driving on Q0)', fontsize=20)\n", + "plt.grid(True)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "\n", + "# T1" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Using the calibrated Pi pulse add a T1 decay channel and simulate a t1 experiment. This can take a while to run. The noise operators in pulse are still a work in progress." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "t1_times = np.linspace(0,500,10)\n", + "t1_times = np.array(t1_times, dtype=int)\n", + "\n", + "T1_exps = []\n", + "for kk in range(len(t1_times)):\n", + " schedule = pulse.Schedule(name='T1_{}'.format(kk))\n", + " schedule |= pi_pulse(system.qubits[qubit].drive) << schedule.duration\n", + " schedule |= measure_and_acquire << int(t1_times[kk]) + schedule.duration\n", + " T1_exps.append(schedule)" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [], + "source": [ + "# Add noise to the Hamiltonian on qubit '0'\n", + "back_config['noise'] = {\"qubit\": \n", + " {\"0\": \n", + " {\"Sm\": 0.006\n", + " }}}\n", + "#back_config['noise'] = {}" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "metadata": {}, + "outputs": [], + "source": [ + "t1_qobj = assemble(T1_exps, backend_real, \n", + " meas_level=1, meas_return='avg', \n", + " memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi,\n", + " evals[3]/2/np.pi],\n", + " shots=100, sim_config = back_config)" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "metadata": {}, + "outputs": [], + "source": [ + "sim_result_t1 = backend_sim.run(t1_qobj).result()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "metadata": {}, + "outputs": [], + "source": [ + "t1_data_Q0 = []\n", + "t1_data_Q1 = []\n", + "\n", + "\n", + "for exp_idx in range(len(t1_times)):\n", + " exp_mem = sim_result_t1.get_memory(exp_idx)\n", + " t1_data_Q0.append(np.abs(exp_mem[0]))\n", + " t1_data_Q1.append(np.abs(exp_mem[1]))\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "#Fit the data\n", + "fit_func_t1 = lambda x,A,B,T: (A*np.exp(-x/T)+B)\n", + "fitparams, conv = curve_fit(fit_func_t1, t1_times, t1_data_Q0, [0.5,0.5,100])\n", + "\n", + "\n", + "plt.plot(t1_times, t1_data_Q0, label='Q0')\n", + "plt.plot(t1_times, t1_data_Q1, label='Q1')\n", + "plt.plot(t1_times, fit_func_t1(t1_times, *fitparams), color='black', linestyle='dashed', label='Fit')\n", + "\n", + "plt.legend()\n", + "plt.xlabel('Wait Time (dt)', fontsize=20)\n", + "plt.ylabel('Signal, a.u.', fontsize=20)\n", + "plt.ylim([0,1.05])\n", + "plt.title('T1 on Q0', fontsize=20)\n", + "plt.grid(True)\n" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.8" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/qiskit/__init__.py b/qiskit/__init__.py new file mode 100644 index 0000000000..7909fc6dac --- /dev/null +++ b/qiskit/__init__.py @@ -0,0 +1,13 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/qiskit/providers/__init__.py b/qiskit/providers/__init__.py new file mode 100644 index 0000000000..7909fc6dac --- /dev/null +++ b/qiskit/providers/__init__.py @@ -0,0 +1,13 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/qiskit/providers/aer/aerprovider.py b/qiskit/providers/aer/aerprovider.py index 38ba05ac0c..2fdba50080 100644 --- a/qiskit/providers/aer/aerprovider.py +++ b/qiskit/providers/aer/aerprovider.py @@ -20,6 +20,7 @@ from .backends.qasm_simulator import QasmSimulator from .backends.statevector_simulator import StatevectorSimulator from .backends.unitary_simulator import UnitarySimulator +from .backends.pulse_simulator import PulseSimulator class AerProvider(BaseProvider): @@ -31,7 +32,8 @@ def __init__(self, *args, **kwargs): # Populate the list of Aer simulator providers. self._backends = [QasmSimulator(provider=self), StatevectorSimulator(provider=self), - UnitarySimulator(provider=self)] + UnitarySimulator(provider=self), + PulseSimulator(provider=self)] def get_backend(self, name=None, **kwargs): return super().get_backend(name=name, **kwargs) diff --git a/qiskit/providers/aer/backends/pulse_simulator.py b/qiskit/providers/aer/backends/pulse_simulator.py new file mode 100644 index 0000000000..4ddf647d9d --- /dev/null +++ b/qiskit/providers/aer/backends/pulse_simulator.py @@ -0,0 +1,107 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=arguments-differ + +""" +Qiskit Aer OpenPulse simulator backend. +""" + +import uuid +import time +import datetime +import logging +from qiskit.result import Result +from qiskit.providers.models import BackendConfiguration +from .aerbackend import AerBackend +from ..aerjob import AerJob +from ..aererror import AerError +from ..version import __version__ +from ..openpulse.qobj.digest import digest_pulse_obj +from ..openpulse.solver.opsolve import opsolve + +logger = logging.getLogger(__name__) + +class PulseSimulator(AerBackend): + """Aer OpenPulse simulator + """ + DEFAULT_CONFIGURATION = { + 'backend_name': 'pulse_simulator', + 'backend_version': "0.0.1", + 'n_qubits': 20, + 'coupling_map': None, + 'url': 'https://github.com/Qiskit/qiskit-aer', + 'simulator': True, + 'local': True, + 'conditional': True, + 'open_pulse': True, + 'memory': False, + 'max_shots': 50000, + 'coupling_map': None, + 'description': 'A pulse-based Hamiltonian simulator', + 'gates': [], + 'basis_gates': [] + } + + def __init__(self, configuration=None, provider=None): + super().__init__(self, + BackendConfiguration.from_dict(self.DEFAULT_CONFIGURATION), + provider=provider) + + def run(self, qobj, validate=False): + """Run a qobj on the backend.""" + # Submit job + job_id = str(uuid.uuid4()) + aer_job = AerJob(self, job_id, self._run_job, qobj, + None, None, validate) + aer_job.submit() + return aer_job + + def _run_job(self, job_id, qobj, backend_options, noise_model, validate): + """Run a qobj job""" + start = time.time() + if validate: + self._validate(qobj, backend_options, noise_model) + openpulse_system = digest_pulse_obj(qobj.to_dict()) + results = opsolve(openpulse_system) + end = time.time() + return self._format_results(job_id, results, end - start, qobj.qobj_id) + + def _format_results(self, job_id, results, time_taken, qobj_id): + """Construct Result object from simulator output.""" + # Add result metadata + output = {} + output['qobj_id'] = qobj_id + output['results'] = results + output['success'] = True + output["job_id"] = job_id + output["date"] = datetime.datetime.now().isoformat() + output["backend_name"] = self.name() + output["backend_version"] = self.configuration().backend_version + output["time_taken"] = time_taken + return Result.from_dict(output) + + def get_dressed_energies(self, qobj): + """Digest the pulse qobj and return the eigenenergies + of the Hamiltonian""" + openpulse_system = digest_pulse_obj(qobj.to_dict()) + return openpulse_system.evals + + def _validate(self, qobj, backend_options, noise_model): + """Validate the pulse object. Make sure a + config has been attached in the proper location""" + + # Check to make sure a sim_config has been added + if not hasattr(qobj.config, 'sim_config'): + raise AerError('The pulse simulator qobj must have a sim_config ' + 'entry to configure the simulator') + + super()._validate(qobj, backend_options, noise_model) diff --git a/qiskit/providers/aer/openpulse/__init__.py b/qiskit/providers/aer/openpulse/__init__.py new file mode 100644 index 0000000000..7c63cf6d57 --- /dev/null +++ b/qiskit/providers/aer/openpulse/__init__.py @@ -0,0 +1,27 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + + +import distutils.sysconfig +import numpy as np +from .qutip_lite.cy import pyxbuilder as pbldr + +# Remove -Wstrict-prototypes from cflags +cfg_vars = distutils.sysconfig.get_config_vars() +if "CFLAGS" in cfg_vars: + cfg_vars["CFLAGS"] = cfg_vars["CFLAGS"].replace("-Wstrict-prototypes", "") + +# Setup pyximport +pbldr.install(setup_args={'include_dirs': [np.get_include()]}) +del pbldr diff --git a/qiskit/providers/aer/openpulse/cy/__init__.py b/qiskit/providers/aer/openpulse/cy/__init__.py new file mode 100644 index 0000000000..7909fc6dac --- /dev/null +++ b/qiskit/providers/aer/openpulse/cy/__init__.py @@ -0,0 +1,13 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/qiskit/providers/aer/openpulse/cy/channel_value.pxd b/qiskit/providers/aer/openpulse/cy/channel_value.pxd new file mode 100644 index 0000000000..cba3f3cdad --- /dev/null +++ b/qiskit/providers/aer/openpulse/cy/channel_value.pxd @@ -0,0 +1,25 @@ +# -*- coding: utf-8 -*- +#!python +#cython: language_level = 3 +#distutils: language = c++ + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +cdef complex chan_value(double t, + unsigned int chan_num, + double freq_ch, + double[::1] chan_pulse_times, + complex[::1] pulse_array, + unsigned int[::1] pulse_ints, + double[::1] fc_array, + unsigned char[::1] register) diff --git a/qiskit/providers/aer/openpulse/cy/channel_value.pyx b/qiskit/providers/aer/openpulse/cy/channel_value.pyx new file mode 100644 index 0000000000..54c268ec56 --- /dev/null +++ b/qiskit/providers/aer/openpulse/cy/channel_value.pyx @@ -0,0 +1,107 @@ +# -*- coding: utf-8 -*- +#!python +#cython: language_level = 3 +#distutils: language = c++ + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +cimport cython + +cimport cython +from libc.math cimport floor, M_PI + +cdef extern from "" namespace "std" nogil: + double complex exp(double complex x) + + +@cython.cdivision(True) +cdef inline int get_arr_idx(double t, double start, double stop, int len_arr): + """Computes the array index value for sampling a pulse in pulse_array. + + Args: + t (double): The current simulation time. + start (double): Start time of pulse in question. + stop (double): Stop time of pulse. + len_arr (int): Length of the pulse sample array. + + Returns: + int: The array index value. + """ + return floor(((t-start)/(stop-start)*len_arr)) + +@cython.boundscheck(False) +cdef complex chan_value(double t, + unsigned int chan_num, + double freq_ch, + double[::1] chan_pulse_times, + complex[::1] pulse_array, + unsigned int[::1] pulse_ints, + double[::1] fc_array, + unsigned char[::1] register): + """Computes the value of a given channel at time `t`. + + Args: + t (double): Current time. + chan_num (int): The int that labels the channel. + chan_pulse_times (int array): Array containing + start_time, stop_time, pulse_int, conditional for + each pulse on the channel. + pulse_array (complex array): The array containing all the + pulse data in the passed pulse qobj. + pulse_ints (int array): Array that tells you where to start + indexing pulse_array for a given pulse labeled by + chan_pulse_times[4*kk+2]. + current_pulse_idx (int array), + freq_ch (doule) channel frequency: + """ + cdef size_t kk + cdef double start_time, stop_time, phase=0 + cdef int start_idx, stop_idx, offset_idx, temp_int, cond + cdef complex out = 0 + # This is because each entry has four values: + # start_time, stop_time, pulse_int, conditional + cdef unsigned int num_times = chan_pulse_times.shape[0] // 4 + + for kk in range(num_times): + # the time is overlapped with the kkth pulse + start_time = chan_pulse_times[4*kk] + stop_time = chan_pulse_times[4*kk+1] + if start_time <= t < stop_time: + cond = chan_pulse_times[4*kk+3] + if cond < 0 or register[cond]: + temp_int = chan_pulse_times[4*kk+2] + start_idx = pulse_ints[temp_int] + stop_idx = pulse_ints[temp_int+1] + offset_idx = get_arr_idx(t, start_time, stop_time, stop_idx-start_idx) + out = pulse_array[start_idx+offset_idx] + break + # Compute the frame change up to time t + if out != 0: + num_times = fc_array.shape[0] + for kk in range(num_times): + if t >= fc_array[3*kk]: + do_fc = 1 + # Check if FC is conditioned on register + if fc_array[3*kk+2] >= 0: + # If condition not satisfied no do FC + if not register[fc_array[3*kk+2]]: + do_fc = 0 + if do_fc: + # Update the frame change value + phase += fc_array[3*kk+1] + else: + break + if phase != 0: + out *= exp(1j*phase) + out *= exp(-1j*2*M_PI*freq_ch*t) + return out \ No newline at end of file diff --git a/qiskit/providers/aer/openpulse/cy/measure.pyx b/qiskit/providers/aer/openpulse/cy/measure.pyx new file mode 100644 index 0000000000..033df8096f --- /dev/null +++ b/qiskit/providers/aer/openpulse/cy/measure.pyx @@ -0,0 +1,73 @@ +# -*- coding: utf-8 -*- +#!python +#cython: language_level = 3 +#distutils: language = c++ + +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +cimport cython +import numpy as np +cimport numpy as np +from qiskit.providers.aer.openpulse.qutip_lite.cy.spmatfuncs import cy_expect_psi_csr + +@cython.boundscheck(False) +def occ_probabilities(unsigned int[::1] qubits, complex[::1] state, list meas_ops): + """Computes the occupation probabilities of the specifed qubits for + the given state. + + Args: + qubits (int array): Ints labelling which qubits are to be measured. + """ + + cdef unsigned int num_qubits = qubits.shape[0] + cdef np.ndarray[double, ndim=1, mode="c"] probs = np.zeros(qubits.shape[0], dtype=float) + + cdef size_t kk + cdef object oper + + for kk in range(num_qubits): + oper = meas_ops[qubits[kk]] + probs[kk] = cy_expect_psi_csr(oper.data.data, + oper.data.indices, + oper.data.indptr, + state, 1) + + return probs + +@cython.boundscheck(False) +def write_shots_memory(unsigned char[:, ::1] mem, + unsigned int[::1] mem_slots, + double[::1] probs, + double[::1] rand_vals): + + """Converts probabilities back into shots + + Args: + mem + mem_slots + probs: expectation value + rand_vals: random values used to convert back into shots + """ + + cdef unsigned int nrows = mem.shape[0] + cdef unsigned int nprobs = probs.shape[0] + + cdef size_t ii, jj + cdef unsigned char temp + for ii in range(nrows): + for jj in range(nprobs): + temp = (probs[jj] > rand_vals[nprobs*ii+jj]) + if temp: + mem[ii,mem_slots[jj]] = temp \ No newline at end of file diff --git a/qiskit/providers/aer/openpulse/cy/memory.pyx b/qiskit/providers/aer/openpulse/cy/memory.pyx new file mode 100644 index 0000000000..fe762ca543 --- /dev/null +++ b/qiskit/providers/aer/openpulse/cy/memory.pyx @@ -0,0 +1,44 @@ +# -*- coding: utf-8 -*- +#!python +#cython: language_level = 3 +#distutils: language = c++ + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +cimport cython + +@cython.boundscheck(False) +def write_memory(unsigned char[:, ::1] mem, + unsigned int[::1] memory_slots, + double[::1] probs, + double[::1] rand_vals): + """Writes the results of measurements to memory + in place. + + Args: + mem (int8 array): 2D array of memory of size (shots*memory_slots). + memory_slots (uint32 array): Array of ints for memory_slots to write too. + probs (double array): Probability of being in excited state for + each qubit in `qubits`. + rand_vals (double array): Random values of len = len(qubits)*shots + """ + cdef unsigned int nrows = mem.shape[0] + cdef unsigned int nprobs = probs.shape[0] + + cdef size_t ii, jj + cdef unsigned char temp + for ii in range(nrows): + for jj in range(nprobs): + temp = (probs[jj] > rand_vals[nprobs*ii+jj]) + if temp: + mem[ii,memory_slots[jj]] = temp \ No newline at end of file diff --git a/qiskit/providers/aer/openpulse/cy/utils.pyx b/qiskit/providers/aer/openpulse/cy/utils.pyx new file mode 100644 index 0000000000..fc624c6d37 --- /dev/null +++ b/qiskit/providers/aer/openpulse/cy/utils.pyx @@ -0,0 +1,45 @@ +# -*- coding: utf-8 -*- +#!python +#cython: language_level = 3 +#distutils: language = c++ + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +cimport cython + +@cython.boundscheck(False) +@cython.wraparound(False) +def oplist_to_array(list A, complex[::1] B, + int start_idx=0): + """Takes a list of complex numbers represented by a list + of pairs of floats, and inserts them into a complex NumPy + array at a given starting index. + + Parameters: + A (list): A nested-list of [re, im] pairs. + B(ndarray): Array for storing complex numbers from list A. + start_idx (int): The starting index at which to insert elements. + + Notes: + This is ~5x faster than doing it in Python. + """ + cdef size_t kk + cdef unsigned int lenA = len(A) + cdef list temp + + if (start_idx+lenA) > B.shape[0]: + raise Exception('Input list does not fit into array if start_idx is {}.'.format(start_idx)) + + for kk in range(lenA): + temp = A[kk] + B[start_idx+kk] = temp[0]+1j*temp[1] \ No newline at end of file diff --git a/qiskit/providers/aer/openpulse/qobj/__init__.py b/qiskit/providers/aer/openpulse/qobj/__init__.py new file mode 100644 index 0000000000..7909fc6dac --- /dev/null +++ b/qiskit/providers/aer/openpulse/qobj/__init__.py @@ -0,0 +1,13 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py new file mode 100644 index 0000000000..92fea7be83 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -0,0 +1,578 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=eval-used, exec-used, invalid-name + +"""A module of routines for digesting a PULSE qobj +into something we can actually use. +""" + +from collections import OrderedDict +import numpy as np +import numpy.linalg as la +from .op_system import OPSystem +from .opparse import HamiltonianParser, NoiseParser +from .operators import qubit_occ_oper_dressed +from ..solver.options import OPoptions +# pylint: disable=no-name-in-module,import-error +from ..cy.utils import oplist_to_array +from . import op_qobj as op + + + +def digest_pulse_obj(qobj): + """Takes an input PULSE obj an disgests it into + things we can actually make use of. + + Args: + qobj (Qobj): Qobj of PULSE type. + + Returns: + OPSystem: The parsed qobj. + + Raises: + Exception: Invalid options + ValueError: Invalid channel selection. + """ + # Output data object + out = OPSystem() + + #get the config settings from the qobj + config_dict_sim = qobj['config']['sim_config'] + config_dict = qobj['config'] + + qubit_list = config_dict_sim.get('qubit_list', None) + if qubit_list is None: + qubit_list = list(range(config_dict_sim['n_qubits'])) + else: + config_dict_sim['n_qubits'] = len(qubit_list) + + config_keys_sim = config_dict_sim.keys() + config_keys = config_dict.keys() + + # Look for config keys + out.global_data['shots'] = 1024 + if 'shots' in config_keys: + out.global_data['shots'] = int(config_dict['shots']) + + out.global_data['meas_level'] = 1 + if 'meas_level' in config_keys: + out.global_data['meas_level'] = int(config_dict['meas_level']) + + out.global_data['meas_return'] = 'avg' + if 'meas_return' in config_keys: + out.global_data['meas_return'] = config_dict['meas_return'] + + out.global_data['seed'] = None + if 'seed' in config_keys: + out.global_data['seed'] = int(config_dict['seed']) + + if 'memory_slots' in config_keys: + out.global_data['memory_slots'] = config_dict['memory_slots'] + else: + err_str = 'Number of memory_slots must be specific in Qobj config' + raise ValueError(err_str) + + if 'memory' in config_keys: + out.global_data['memory'] = config_dict['memory'] + else: + out.global_data['memory'] = False + + out.global_data['n_registers'] = 0 + if 'n_registers' in config_keys: + out.global_data['n_registers'] = config_dict['n_registers'] + + + #which level to measure + out.global_data['q_level_meas'] = 1 + if 'q_level_meas' in config_keys_sim: + out.global_data['q_level_meas'] = int(config_dict_sim['q_level_meas']) + + # Attach the ODE options + allowed_ode_options = ['atol', 'rtol', 'nsteps', 'max_step', + 'num_cpus', 'norm_tol', 'norm_steps', + 'rhs_reuse', 'rhs_filename'] + user_set_ode_options = {} + if 'ode_options' in config_keys_sim: + for key, val in config_dict_sim['ode_options'].items(): + if key not in allowed_ode_options: + raise Exception('Invalid ode_option: {}'.format(key)) + else: + user_set_ode_options[key] = val + out.ode_options = OPoptions(**user_set_ode_options) + + + # Step #1: Parse hamiltonian representation + if 'hamiltonian' not in config_keys_sim: + raise ValueError('Qobj must have hamiltonian in config to simulate.') + else: + ham = config_dict_sim['hamiltonian'] + + out.vars = OrderedDict(ham['vars']) + out.global_data['vars'] = list(out.vars.values()) + + # Get qubit subspace dimensions + if 'qub' in ham.keys(): + dim_qub = ham['qub'] + _dim_qub = {} + # Convert str keys to int keys + for key, val in ham['qub'].items(): + _dim_qub[int(key)] = val + dim_qub = _dim_qub + else: + dim_qub = {}.fromkeys(range(config_dict_sim['n_qubits']), 2) + + # Get oscillator subspace dimensions + if 'osc' in ham.keys(): + dim_osc = ham['osc'] + _dim_osc = {} + # Convert str keys to int keys + for key, val in dim_osc.items(): + _dim_osc[int(key)] = val + dim_osc = _dim_osc + else: + dim_osc = {} + + # Parse the Hamiltonian + system = HamiltonianParser(h_str=ham['h_str'], + dim_osc=dim_osc, + dim_qub=dim_qub) + system.parse(qubit_list) + out.system = system.compiled + + if 'noise' in config_dict_sim.keys(): + noise = NoiseParser(noise_dict=config_dict_sim['noise'], + dim_osc=dim_osc, dim_qub=dim_qub) + noise.parse() + + out.noise = noise.compiled + if any(out.noise): + out.can_sample = False + out.global_data['c_num'] = len(out.noise) + else: + out.noise = None + + + # Step #2: Get Hamiltonian channels + out.channels = get_hamiltonian_channels(out.system) + + h_diag, evals, estates = get_diag_hamiltonian(out.system, + out.vars, out.channels) + + #convert estates into a qobj + estates_qobj = [] + for kk in range(len(estates[:,])): + estates_qobj.append(op.state(estates[:, kk])) + + out.h_diag = np.ascontiguousarray(h_diag.real) + out.evals = evals + + + # Set initial state + out.initial_state = 0*op.basis(len(evals), 1) + for idx, estate_coef in enumerate(estates[:, 0]): + out.initial_state += estate_coef*op.basis(len(evals), idx) + #init_fock_state(dim_osc, dim_qub) + + #Setup freqs for the channels + out.freqs = OrderedDict() + for key in out.channels.keys(): + chidx = int(key[1:]) + if key[0] == 'D': + out.freqs[key] = config_dict['qubit_lo_freq'][chidx] + elif key[0] == 'U': + out.freqs[key] = 0 + for u_lo_idx in config_dict_sim['u_channel_lo'][chidx]: + if u_lo_idx['q'] < len(config_dict['qubit_lo_freq']): + qfreq = config_dict['qubit_lo_freq'][u_lo_idx['q']] + qscale = u_lo_idx['scale'][0] + out.freqs[key] += qfreq*qscale + else: + raise ValueError("Channel is not D or U") + + out.global_data['freqs'] = list(out.freqs.values()) + + # Step #3: Build pulse arrays + pulses, pulses_idx, pulse_dict = build_pulse_arrays(qobj) + + out.global_data['pulse_array'] = pulses + out.global_data['pulse_indices'] = pulses_idx + out.pulse_to_int = pulse_dict + + # Step #4: Get dt + if 'dt' not in config_dict_sim.keys(): + raise ValueError('Qobj must have a dt value to simulate.') + else: + out.dt = config_dict_sim['dt'] + + + # Set the ODE solver max step to be the half the width of the smallest pulse + min_width = np.iinfo(np.int32).max + for key, val in out.pulse_to_int.items(): + if key != 'pv': + stop = out.global_data['pulse_indices'][val+1] + start = out.global_data['pulse_indices'][val] + min_width = min(min_width, stop-start) + out.ode_options.max_step = min_width/2 * out.dt + + # Step #6: Convert experiments to data structures. + + out.global_data['measurement_ops'] = [None]*config_dict_sim['n_qubits'] + + for exp in qobj['experiments']: + exp_struct = experiment_to_structs(exp, + out.channels, + out.global_data['pulse_indices'], + out.pulse_to_int, + out.dt, qubit_list) + + # Add in measurement operators + # Not sure if this will work for multiple measurements + if any(exp_struct['acquire']): + for acq in exp_struct['acquire']: + for jj in acq[1]: + if jj > qubit_list[-1]: + continue + if not out.global_data['measurement_ops'][jj]: + out.global_data['measurement_ops'][jj] = \ + qubit_occ_oper_dressed(jj, + estates_qobj, + h_osc=dim_osc, + h_qub=dim_qub, + level=out.global_data['q_level_meas'] + ) + + + out.experiments.append(exp_struct) + if not exp_struct['can_sample']: + out.can_sample = False + return out + +def get_diag_hamiltonian(parsed_ham, ham_vars, channels): + + """ Get the diagonal elements of the hamiltonian and get the + dressed frequencies and eigenstates + + Parameters: + parsed_ham (list): A list holding ops and strings from the Hamiltonian + of a specific quantum system. + + ham_vars (dict): dictionary of variables + + channels (dict): drive channels (set to 0) + + Returns: + h_diag: diagonal elements of the hamiltonian + h_evals: eigenvalues of the hamiltonian with no time-dep terms + h_estates: eigenstates of the hamiltonian with no time-dep terms + + Raises: + Exception: Missing index on channel. + """ + #Get the diagonal elements of the hamiltonian with all the + #drive terms set to zero + for chan in channels: + exec('%s=0'%chan) + + #might be a better solution to replace the 'var' in the hamiltonian + #string with 'op_system.vars[var]' + for var in ham_vars: + exec('%s=%f'%(var, ham_vars[var])) + + H_full = np.zeros(np.shape(parsed_ham[0][0].full()), dtype=complex) + + for hpart in parsed_ham: + H_full += hpart[0].full()*eval(hpart[1]) + + h_diag = np.diag(H_full) + + evals, estates = la.eigh(H_full) + + eval_mapping = [] + for ii in range(len(evals)): + eval_mapping.append(np.argmax(np.abs(estates[:, ii]))) + + evals2 = evals.copy() + estates2 = estates.copy() + + for ii, val in enumerate(eval_mapping): + evals2[val] = evals[ii] + estates2[:, val] = estates[:, ii] + + return h_diag, evals2, estates2 + + + +def get_hamiltonian_channels(parsed_ham): + """ Get all the qubit channels D_i and U_i in the string + representation of a system Hamiltonian. + + Parameters: + parsed_ham (list): A list holding ops and strings from the Hamiltonian + of a specific quantum system. + + Returns: + list: A list of all channels in Hamiltonian string. + + Raises: + Exception: Missing index on channel. + """ + out_channels = [] + for _, ham_str in parsed_ham: + chan_idx = [i for i, letter in enumerate(ham_str) if letter in ['D', 'U']] + for ch in chan_idx: + if (ch+1) == len(ham_str) or not ham_str[ch+1].isdigit(): + raise Exception('Channel name must include an integer labeling the qubit.') + for kk in chan_idx: + done = False + offset = 0 + while not done: + offset += 1 + if not ham_str[kk+offset].isdigit(): + done = True + # In case we hit the end of the string + elif (kk+offset+1) == len(ham_str): + done = True + offset += 1 + temp_chan = ham_str[kk:kk+offset] + if temp_chan not in out_channels: + out_channels.append(temp_chan) + out_channels.sort(key=lambda x: (int(x[1:]), x[0])) + + out_dict = OrderedDict() + for idx, val in enumerate(out_channels): + out_dict[val] = idx + + return out_dict + + +def build_pulse_arrays(qobj): + """ Build pulses and pulse_idx arrays, and a pulse_dict + used in simulations and mapping of experimental pulse + sequencies to pulse_idx sequencies and timings. + + Parameters: + qobj (Qobj): A pulse-qobj instance. + + Returns: + tuple: Returns all pulses in one array, + an array of start indices for pulses, and dict that + maps pulses to the index at which the pulses start. + """ + qobj_pulses = qobj['config']['pulse_library'] + pulse_dict = {} + total_pulse_length = 0 + + num_pulse = 0 + for pulse in qobj_pulses: + pulse_dict[pulse['name']] = num_pulse + total_pulse_length += len(pulse['samples']) + num_pulse += 1 + + idx = num_pulse+1 + #now go through experiments looking for PV gates + pv_pulses = [] + for exp in qobj['experiments']: + for pulse in exp['instructions']: + if pulse['name'] == 'pv': + if pulse['val'] not in [pval[1] for pval in pv_pulses] and pulse['val'] != 0: + pv_pulses.append((pulse['val'], idx)) + idx += 1 + total_pulse_length += 1 + + pulse_dict['pv'] = pv_pulses + + pulses = np.empty(total_pulse_length, dtype=complex) + pulses_idx = np.zeros(idx+1, dtype=np.uint32) + + stop = 0 + ind = 1 + for _, pulse in enumerate(qobj_pulses): + stop = pulses_idx[ind-1] + len(pulse['samples']) + pulses_idx[ind] = stop + oplist_to_array(pulse['samples'], pulses, pulses_idx[ind-1]) + ind += 1 + + for pv in pv_pulses: + stop = pulses_idx[ind-1] + 1 + pulses_idx[ind] = stop + oplist_to_array([pv[0]], pulses, pulses_idx[ind-1]) + ind += 1 + + return pulses, pulses_idx, pulse_dict + +def experiment_to_structs(experiment, ham_chans, pulse_inds, + pulse_to_int, dt, qubit_list=None): + """Converts an experiment to a better formatted structure + + Args: + experiment (dict): An experiment. + ham_chans (dict): The channels in the Hamiltonian. + pulse_inds (array): Array of pulse indices. + pulse_to_int (array): Qobj pulses labeled by ints. + dt (float): Pulse time resolution. + qubit_list (list): List of qubits. + + Returns: + dict: The output formatted structure. + + Raises: + ValueError: Channel not in Hamiltonian. + TypeError: Incorrect snapshot type. + """ + #TO DO: Error check that operations are restricted to qubit list + max_time = 0 + structs = {} + structs['header'] = experiment['header'] + structs['channels'] = OrderedDict() + for chan_name in ham_chans: + structs['channels'][chan_name] = [[], []] + structs['acquire'] = [] + structs['cond'] = [] + structs['snapshot'] = [] + structs['tlist'] = [] + structs['can_sample'] = True + # This is a list that tells us whether the last PV pulse on a channel needs to + # be assigned a final time based on the next pulse on that channel + pv_needs_tf = [0]*len(ham_chans) + + # The instructions are time-ordered so just loop through them. + for inst in experiment['instructions']: + # Do D and U channels + if 'ch' in inst.keys() and inst['ch'][0] in ['d', 'u']: + chan_name = inst['ch'].upper() + if chan_name not in ham_chans.keys(): + raise ValueError('Channel {} is not in Hamiltonian model'.format(inst['ch'])) + + # If last pulse on channel was a PV then need to set + # its final time to be start time of current pulse + if pv_needs_tf[ham_chans[chan_name]]: + structs['channels'][chan_name][0][-3] = inst['t0'] + pv_needs_tf[ham_chans[chan_name]] = 0 + + # Get condtional info + if 'conditional' in inst.keys(): + cond = inst['conditional'] + else: + cond = -1 + # PV's + if inst['name'] == 'pv': + # Get PV index + for pv in pulse_to_int['pv']: + if pv[0] == inst['val']: + index = pv[1] + break + structs['channels'][chan_name][0].extend([inst['t0'], None, index, cond]) + pv_needs_tf[ham_chans[chan_name]] = 1 + + # Frame changes + elif inst['name'] == 'fc': + structs['channels'][chan_name][1].extend([inst['t0'], inst['phase'], cond]) + + # A standard pulse + else: + start = inst['t0'] + pulse_int = pulse_to_int[inst['name']] + pulse_width = (pulse_inds[pulse_int+1]-pulse_inds[pulse_int])*dt + stop = start + pulse_width + structs['channels'][chan_name][0].extend([start, stop, pulse_int, cond]) + + max_time = max(max_time, stop) + + # Take care of acquires and snapshots (bfuncs added ) + else: + # measurements + if inst['name'] == 'acquire': + + #Better way?? + qlist2 = [] + mlist2 = [] + if qubit_list is None: + qlist2 = inst['qubits'] + mlist2 = inst['memory_slot'] + else: + for qind, qb in enumerate(inst['qubits']): + if qb in qubit_list: + qlist2.append(qb) + mlist2.append(inst['memory_slot'][qind]) + + + + + acq_vals = [inst['t0'], + np.asarray(qlist2, dtype=np.uint32), + np.asarray(mlist2, dtype=np.uint32) + ] + if 'register_slot' in inst.keys(): + acq_vals.append(np.asarray(inst['register_slot'], dtype=np.uint32)) + else: + acq_vals.append(None) + structs['acquire'].append(acq_vals) + + #update max_time + max_time = max(max_time, inst['t0']+dt*inst['duration']) + + # Add time to tlist + if inst['t0'] not in structs['tlist']: + structs['tlist'].append(inst['t0']) + + # conditionals + elif inst['name'] == 'bfunc': + bfun_vals = [inst['t0'], inst['mask'], inst['relation'], + inst['val'], inst['register']] + if 'memory' in inst.keys(): + bfun_vals.append(inst['memory']) + else: + bfun_vals.append(None) + + structs['cond'].append(acq_vals) + + #update max_time + max_time = max(max_time, inst['t0']) + + # Add time to tlist + if inst['t0'] not in structs['tlist']: + structs['tlist'].append(inst['t0']) + + # snapshots + elif inst['name'] == 'snapshot': + if inst['type'] != 'state': + raise TypeError("Snapshots must be of type 'state'") + structs['snapshot'].append([inst['t0'], inst['label']]) + + # Add time to tlist + if inst['t0'] not in structs['tlist']: + structs['tlist'].append(inst['t0']) + + #update max_time + max_time = max(max_time, inst['t0']) + + # If any PVs still need time then they are at the end + # and should just go til final time + ham_keys = list(ham_chans.keys()) + for idx, pp in enumerate(pv_needs_tf): + if pp: + structs['channels'][ham_keys[idx]][0][-3] = max_time + pv_needs_tf[idx] = 0 + + # Convert lists to numpy arrays + for key in structs['channels'].keys(): + structs['channels'][key][0] = np.asarray(structs['channels'][key][0], dtype=float) + structs['channels'][key][1] = np.asarray(structs['channels'][key][1], dtype=float) + + structs['tlist'] = np.asarray([0]+structs['tlist'], dtype=float) + + if len(structs['acquire']) > 1 or structs['tlist'][-1] > structs['acquire'][-1][0]: + structs['can_sample'] = False + + return structs diff --git a/qiskit/providers/aer/openpulse/qobj/op_qobj.py b/qiskit/providers/aer/openpulse/qobj/op_qobj.py new file mode 100644 index 0000000000..3c092981a2 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qobj/op_qobj.py @@ -0,0 +1,214 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=invalid-name, no-name-in-module, import-error + +"""Operators to use in simulator""" + +import numpy as np +from ..qutip_lite import operators as ops +from ..qutip_lite import states as st +from ..qutip_lite import tensor as ten +from ..qutip_lite.qobj import Qobj +from ..qutip_lite.cy.spmatfuncs import (spmv_csr, cy_expect_psi_csr) + +def sigmax(dim=2): + """Qiskit wrapper of sigma-X operator. + """ + if dim == 2: + return ops.sigmax() + else: + raise Exception('Invalid level specification of the qubit subspace') + + +def sigmay(dim=2): + """Qiskit wrapper of sigma-Y operator. + """ + if dim == 2: + return ops.sigmay() + else: + raise Exception('Invalid level specification of the qubit subspace') + + +def sigmaz(dim=2): + """Qiskit wrapper of sigma-Z operator. + """ + if dim == 2: + return ops.sigmaz() + else: + raise Exception('Invalid level specification of the qubit subspace') + + +def sigmap(dim=2): + """Qiskit wrapper of sigma-plus operator. + """ + return ops.create(dim) + + +def sigmam(dim=2): + """Qiskit wrapper of sigma-minus operator. + """ + return ops.destroy(dim) + + +def create(dim): + """Qiskit wrapper of creation operator. + """ + return ops.create(dim) + + +def destroy(dim): + """Qiskit wrapper of annihilation operator. + """ + return ops.destroy(dim) + + +def num(dim): + """Qiskit wrapper of number operator. + """ + return ops.num(dim) + + +def qeye(dim): + """Qiskit wrapper of identity operator. + """ + return ops.qeye(dim) + + +def project(dim, states): + """Qiskit wrapper of projection operator. + """ + ket, bra = states + if ket in range(dim) and bra in range(dim): + return st.basis(dim, ket) * st.basis(dim, bra).dag() + else: + raise Exception('States are specified on the outside of Hilbert space %s' % states) + + +def tensor(list_qobj): + """ Qiskit wrapper of tensor product + """ + return ten.tensor(list_qobj) + + +def conj(val): + """ Qiskit wrapper of conjugate + """ + if isinstance(val, Qobj): + return val.conj() + else: + return np.conj(val) + + +def sin(val): + """ Qiskit wrapper of sine function + """ + if isinstance(val, Qobj): + return val.sinm() + else: + return np.sin(val) + + +def cos(val): + """ Qiskit wrapper of cosine function + """ + if isinstance(val, Qobj): + return val.cosm() + else: + return np.cos(val) + + +def exp(val): + """ Qiskit wrapper of exponential function + """ + if isinstance(val, Qobj): + return val.expm() + else: + return np.exp(val) + + +def sqrt(val): + """ Qiskit wrapper of square root + """ + if isinstance(val, Qobj): + return val.sqrtm() + else: + return np.sqrt(val) + + +def dag(qobj): + """ Qiskit wrapper of adjoint + """ + return qobj.dag() + + +def dammy(qobj): + """ Return given quantum object + """ + return qobj + + +def basis(level, pos): + """ Qiskit wrapper of basis + """ + return st.basis(level, pos) + +def state(state_vec): + """ Qiskit wrapper of qobj + """ + return Qobj(state_vec) + + +def fock_dm(level, eigv): + """ Qiskit wrapper of fock_dm + """ + return st.fock_dm(level, eigv) + + +def opr_prob(opr, state_vec): + """ Measure probability of operator in given quantum state + """ + return cy_expect_psi_csr(opr.data.data, + opr.data.indices, + opr.data.indptr, + state_vec, 1) + + +def opr_apply(opr, state_vec): + """ Apply operator to given quantum state + """ + return spmv_csr(opr.data.data, + opr.data.indices, + opr.data.indptr, + state_vec) + + +def get_oper(name, *args): + """ Return quantum operator of given name + """ + return __operdict.get(name, qeye)(*args) + + +def get_func(name, qobj): + """ Apply function of given name + """ + return __funcdict.get(name, dammy)(qobj) + + +__operdict = {'X': sigmax, 'Y': sigmay, 'Z': sigmaz, + 'Sp': create, 'Sm': destroy, 'I': qeye, + 'O': num, 'P': project, 'A': destroy, + 'C': create, 'N': num} + +__funcdict = {'cos': cos, 'sin': sin, 'exp': exp, + 'sqrt': sqrt, 'conj': conj, 'dag': dag} diff --git a/qiskit/providers/aer/openpulse/qobj/op_system.py b/qiskit/providers/aer/openpulse/qobj/op_system.py new file mode 100644 index 0000000000..504dccb119 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qobj/op_system.py @@ -0,0 +1,56 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=invalid-name + +"The OpenPulse simulator system class" + +class OPSystem(): + """ A Class that holds all the information + needed to simulate a given PULSE qobj + """ + def __init__(self): + # The system Hamiltonian in numerical format + self.system = None + # The noise (if any) in numerical format + self.noise = None + # System variables + self.vars = None + # The initial state of the system + self.initial_state = None + # Channels in the Hamiltonian string + # these tell the order in which the channels + # are evaluated in the RHS solver. + self.channels = None + # options of the ODE solver + self.ode_options = None + # time between pulse sample points. + self.dt = None + # Array containing all pulse samples + self.pulse_array = None + # Array of indices indicating where a pulse starts in the self.pulse_array + self.pulse_indices = None + # A dict that translates pulse names to integers for use in self.pulse_indices + self.pulse_to_int = None + # Holds the parsed experiments + self.experiments = [] + # Can experiments be simulated once then sampled + self.can_sample = True + # holds global data + self.global_data = {} + # holds frequencies for the channels + self.freqs = {} + # diagonal elements of the hamiltonian + self.h_diag = None + # eigenvalues of the time-independent hamiltonian + self.evals = None diff --git a/qiskit/providers/aer/openpulse/qobj/operators.py b/qiskit/providers/aer/openpulse/qobj/operators.py new file mode 100644 index 0000000000..3b2adb8607 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qobj/operators.py @@ -0,0 +1,257 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=invalid-name + +"""Module for creating quantum operators.""" + +import numpy as np +import scipy.linalg as la +from ..qobj import op_qobj as op + +def gen_oper(opname, index, h_osc, h_qub, states=None): + """Generate quantum operators. + + Args: + opname (str): Name of the operator to be returned. + index (int): Index of operator. + h_osc (dict): Dimension of oscillator subspace + h_qub (dict): Dimension of qubit subspace + states (tuple): State indices of projection operator. + + Returns: + Qobj: quantum operator for target qubit. + """ + + opr_tmp = None + + # get number of levels in Hilbert space + if opname in ['X', 'Y', 'Z', 'Sp', 'Sm', 'I', 'O', 'P']: + is_qubit = True + dim = h_qub.get(index, 2) + + if opname in ['X', 'Y', 'Z'] and dim > 2: + if opname == 'X': + opr_tmp = op.get_oper('A', dim)+op.get_oper('C', dim) + elif opname == 'Y': + opr_tmp = -1j*op.get_oper('A', dim)+1j*op.get_oper('C', dim) + else: + opr_tmp = op.get_oper('I', dim) - op.get_oper('N', dim) + + else: + is_qubit = False + dim = h_osc.get(index, 5) + + if opname == 'P': + opr_tmp = op.get_oper(opname, dim, states) + else: + if opr_tmp is None: + opr_tmp = op.get_oper(opname, dim) + + # reverse sort by index + rev_h_osc = sorted(h_osc.items(), key=lambda x: x[0])[::-1] + rev_h_qub = sorted(h_qub.items(), key=lambda x: x[0])[::-1] + + # osc_n * … * osc_0 * qubit_n * … * qubit_0 + opers = [] + for ii, dd in rev_h_osc: + if ii == index and not is_qubit: + opers.append(opr_tmp) + else: + opers.append(op.qeye(dd)) + for ii, dd in rev_h_qub: + if ii == index and is_qubit: + opers.append(opr_tmp) + else: + opers.append(op.qeye(dd)) + + return op.tensor(opers) + + +def qubit_occ_oper(target_qubit, h_osc, h_qub, level=0): + """Builds the occupation number operator for a target qubit + in a qubit oscillator system, where the oscillator are the first + subsystems, and the qubit last. + + Parameters + ---------- + target_qubit (int): Qubit for which operator is built. + h_osc (dict): Dict of number of levels in each oscillator. + h_qub (dict): Dict of number of levels in each qubit system. + level (int): Level of qubit system to be measured. + + Returns: + Qobj: Occupation number operator for target qubit. + """ + # reverse sort by index + rev_h_osc = sorted(h_osc.items(), key=lambda x: x[0])[::-1] + rev_h_qub = sorted(h_qub.items(), key=lambda x: x[0])[::-1] + + # osc_n * … * osc_0 * qubit_n * … * qubit_0 + opers = [] + for ii, dd in rev_h_osc: + opers.append(op.qeye(dd)) + for ii, dd in rev_h_qub: + if ii == target_qubit: + opers.append(op.fock_dm(h_qub.get(target_qubit, 2), level)) + else: + opers.append(op.qeye(dd)) + + return op.tensor(opers) + +def qubit_occ_oper_dressed(target_qubit, estates, h_osc, h_qub, level=0): + """Builds the occupation number operator for a target qubit + in a qubit oscillator system, where the oscillator are the first + subsystems, and the qubit last. This does it for a dressed systems + assuming estates has the same ordering + + Args: + target_qubit (int): Qubit for which operator is built. + estates (list): eigenstates in the dressed frame + h_osc (dict): Dict of number of levels in each oscillator. + h_qub (dict): Dict of number of levels in each qubit system. + level (int): Level of qubit system to be measured. + + Returns: + Qobj: Occupation number operator for target qubit. + """ + # reverse sort by index + rev_h_osc = sorted(h_osc.items(), key=lambda x: x[0])[::-1] + rev_h_qub = sorted(h_qub.items(), key=lambda x: x[0])[::-1] + + # osc_n * … * osc_0 * qubit_n * … * qubit_0 + states = [] + proj_op = 0*op.fock_dm(len(estates), 0) + for ii, dd in rev_h_osc: + states.append(op.basis(dd, 0)) + for ii, dd in rev_h_qub: + if ii == target_qubit: + states.append(op.basis(dd, level)) + else: + states.append(op.state(np.ones(dd))) + + + state = op.tensor(states) + + for ii, estate in enumerate(estates): + if state[ii] == 1: + proj_op += estate * estate.dag() + + return proj_op + + +def measure_outcomes(measured_qubits, state_vector, measure_ops, + seed=None): + """Generate measurement outcomes for a given set of qubits and state vector. + + Parameters: + measured_qubits (array_like): Qubits to be measured. + state_vector(ndarray): State vector. + measure_ops (list): List of measurement operator + seed (int): Optional seed to RandomState for reproducibility. + + Returns: + str: String of binaries representing measured qubit values. + """ + outcome_len = max(measured_qubits)+1 + # Create random generator with given seed (if any). + rng_gen = np.random.RandomState(seed) + rnds = rng_gen.rand(outcome_len) + outcomes = '' + for kk in range(outcome_len): + if kk in measured_qubits: + excited_prob = op.opr_prob(measure_ops[kk], state_vector) + if excited_prob >= rnds[kk]: + outcomes += '1' + else: + outcomes += '0' + else: + # We need a string for all the qubits up to the last + # one being measured for the mask operation to work + # Here, we default to unmeasured qubits in the grnd state. + outcomes += '0' + return outcomes + + +def apply_projector(measured_qubits, results, h_qub, h_osc, state_vector): + """Builds and applies the projection operator associated + with a given qubit measurement result onto a state vector. + + Args: + measured_qubits (list): measured qubit indices. + results (list): results of qubit measurements. + h_qub (dict): Dict of number of levels in each qubit system. + h_osc (dict): Dict of number of levels in each oscillator. + state_vector (ndarray): State vector. + + Returns: + Qobj: State vector after projector applied, and normalized. + """ + + # reverse sort by index + rev_h_osc = sorted(h_osc.items(), key=lambda x: x[0])[::-1] + rev_h_qub = sorted(h_qub.items(), key=lambda x: x[0])[::-1] + + # osc_n * … * osc_0 * qubit_n * … * qubit_0 + opers = [] + for ii, dd in rev_h_osc: + opers.append(op.qeye(dd)) + for ii, dd in rev_h_qub: + if ii in measured_qubits: + opers.append(op.fock_dm(dd, results[ii])) + else: + opers.append(op.qeye(dd)) + + proj_oper = op.tensor(opers) + psi = op.opr_apply(proj_oper, state_vector) + psi /= la.norm(psi) + + return psi + +# pylint: disable=dangerous-default-value +def init_fock_state(h_osc, h_qub, noise_dict={}): + """ Generate initial Fock state, in the number state + basis, for an oscillator in a thermal state defined + by the expectation value of number of particles. + + Parameters: + h_osc (dict): Dimension of oscillator subspace + h_qub (dict): Dimension of qubit subspace + noise_dict (dict): Dictionary of thermal particles for each oscillator subspace + Returns: + Qobj: State vector + """ + # reverse sort by index + rev_h_osc = sorted(h_osc.items(), key=lambda x: x[0])[::-1] + rev_h_qub = sorted(h_qub.items(), key=lambda x: x[0])[::-1] + + # osc_n * … * osc_0 * qubit_n * … * qubit_0 + sub_state_vecs = [] + for ii, dd in rev_h_osc: + n_thermal = noise_dict['oscillator']['n_th'].get(str(ii), 0) + if n_thermal == 0: + # no thermal particles + idx = 0 + else: + # consider finite thermal excitation + levels = np.arange(dd) + beta = np.log(1.0 / n_thermal + 1.0) + diags = np.exp(-beta * levels) + diags /= np.sum(diags) + cum_sum = np.cumsum(diags) + idx = np.where(np.random.random() < cum_sum)[0][0] + sub_state_vecs.append(op.basis(dd, idx)) + for ii, dd in rev_h_qub: + sub_state_vecs.append(op.basis(dd, 0)) + + return op.tensor(sub_state_vecs) diff --git a/qiskit/providers/aer/openpulse/qobj/opparse.py b/qiskit/providers/aer/openpulse/qobj/opparse.py new file mode 100644 index 0000000000..13903ec940 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qobj/opparse.py @@ -0,0 +1,420 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=invalid-name + +""" The openpulse simulator parser""" + +import re +import copy +from collections import namedtuple, OrderedDict +import numpy as np +from .op_qobj import get_func +from .operators import gen_oper + + +Token = namedtuple('Token', ('type', 'name')) + +ham_elements = OrderedDict( + QubOpr=re.compile(r"(?PO|Sp|Sm|X|Y|Z)(?P[0-9]+)"), + PrjOpr=re.compile(r"P(?P[0-9]+),(?P[0-9]+),(?P[0-9]+)"), + CavOpr=re.compile(r"(?PA|C|N)(?P[0-9]+)"), + Func=re.compile(r"(?P[a-z]+)\("), + Ext=re.compile(r"\.(?Pdag)"), + Var=re.compile(r"[a-z]+[0-9]*"), + Num=re.compile(r"[0-9.]+"), + MathOrd0=re.compile(r"[*/]"), + MathOrd1=re.compile(r"[+-]"), + BrkL=re.compile(r"\("), + BrkR=re.compile(r"\)") +) + + +class HamiltonianParser: + """ Generate QuTip hamiltonian object from string + """ + def __init__(self, h_str, dim_osc, dim_qub): + """ Create new quantum operator generator + + Parameters: + h_str (list): list of Hamiltonian string + dim_osc (dict): dimension of oscillator subspace + dim_qub (dict): dimension of qubit subspace + """ + self.h_str = h_str + self.dim_osc = dim_osc + self.dim_qub = dim_qub + self.__td_hams = [] + self.__tc_hams = [] + self.__str2qopr = {} + + @property + def compiled(self): + """ Return Hamiltonian in OpenPulse handler format + """ + return self.__tc_hams + self.__td_hams + + def parse(self, qubit_list=None): + """ Parse and generate quantum class object + """ + self.__td_hams = [] + self.__tc_hams = [] + + # expand sum + self._expand_sum() + + # convert to reverse Polish notation + for ham in self.h_str: + if len(re.findall(r"\|\|", ham)) > 1: + raise Exception("Multiple time-dependent terms in %s" % ham) + p_td = re.search(r"(?P[\S]+)\|\|(?P[\S]+)", ham) + + # find time-dependent term + if p_td: + coef, token = self._tokenizer(p_td.group('opr'), qubit_list) + if token is None: + continue + # combine coefficient to time-dependent term + if coef: + td = '*'.join([coef, p_td.group('ch')]) + else: + td = p_td.group('ch') + token = self._shunting_yard(token) + _td = [self._token2qobj(token), td] + + self.__td_hams.append(_td) + else: + coef, token = self._tokenizer(ham, qubit_list) + if token is None: + continue + token = self._shunting_yard(token) + _tc = self._token2qobj(token), coef + + self.__tc_hams.append(_tc) + + def _expand_sum(self): + """ Takes a string-based Hamiltonian list and expands the _SUM action items out. + """ + sum_str = re.compile(r"_SUM\[(?P[a-z]),(?P[a-z\d{}+-]+),(?P[a-z\d{}+-]+),") + brk_str = re.compile(r"]") + + ham_list = copy.copy(self.h_str) + ham_out = [] + + while any(ham_list): + ham = ham_list.pop(0) + p_sums = [p for p in sum_str.finditer(ham)] + p_brks = [p for p in brk_str.finditer(ham)] + if len(p_sums) != len(p_brks): + raise Exception('Missing correct number of brackets in %s' % ham) + + # find correct sum-bracket correspondence + if any(p_sums) == 0: + ham_out.append(ham) + else: + itr = p_sums[0].group('itr') + _l = int(p_sums[0].group('l')) + _u = int(p_sums[0].group('u')) + for ii in range(len(p_sums) - 1): + if p_sums[ii + 1].end() > p_brks[ii].start(): + break + else: + ii = len(p_sums) - 1 + + # substitute iterator value + _temp = [] + for kk in range(_l, _u+1): + trg_s = ham[p_sums[0].end():p_brks[ii].start()] + # generate replacement pattern + pattern = {} + for p in re.finditer(r"\{(?P[a-z0-9*/+-]+)\}", trg_s): + if p.group() not in pattern: + sub = parse_binop(p.group('op_str'), operands={itr: str(kk)}) + if sub.isdecimal(): + pattern[p.group()] = sub + else: + pattern[p.group()] = "{%s}" % sub + for key, val in pattern.items(): + trg_s = trg_s.replace(key, val) + _temp.append(''.join([ham[:p_sums[0].start()], + trg_s, ham[p_brks[ii].end():]])) + ham_list.extend(_temp) + + self.h_str = ham_out + + return ham_out + + def _tokenizer(self, op_str, qubit_list=None): + """ Convert string to token and coefficient + Check if the index is in qubit_list + """ + + # generate token + _op_str = copy.copy(op_str) + token_list = [] + prev = 'none' + while any(_op_str): + for key, parser in ham_elements.items(): + p = parser.match(_op_str) + if p: + # find quantum operators + if key in ['QubOpr', 'CavOpr']: + _key = key + _name = p.group() + if p.group() not in self.__str2qopr.keys(): + idx = int(p.group('idx')) + if qubit_list is not None and idx not in qubit_list: + return 0, None + name = p.group('opr') + opr = gen_oper(name, idx, self.dim_osc, self.dim_qub) + self.__str2qopr[p.group()] = opr + elif key == 'PrjOpr': + _key = key + _name = p.group() + if p.group() not in self.__str2qopr.keys(): + idx = int(p.group('idx')) + name = 'P' + lvs = int(p.group('ket')), int(p.group('bra')) + opr = gen_oper(name, idx, self.dim_osc, self.dim_qub, lvs) + self.__str2qopr[p.group()] = opr + elif key in ['Func', 'Ext']: + _name = p.group('name') + _key = key + elif key == 'MathOrd1': + _name = p.group() + if prev not in ['QubOpr', 'PrjOpr', 'CavOpr', 'Var', 'Num']: + _key = 'MathUnitary' + else: + _key = key + else: + _name = p.group() + _key = key + token_list.append(Token(_key, _name)) + _op_str = _op_str[p.end():] + prev = _key + break + else: + raise Exception('Invalid input string %s is found' % op_str) + + # split coefficient + coef = '' + if any([k.type == 'Var' for k in token_list]): + for ii, _ in enumerate(token_list): + if token_list[ii].name == '*': + if all([k.type != 'Var' for k in token_list[ii+1:]]): + coef = ''.join([k.name for k in token_list[:ii]]) + token_list = token_list[ii+1:] + break + else: + raise Exception('Invalid order of operators and coefficients in %s' % op_str) + + return coef, token_list + + def _shunting_yard(self, token_list): + """ Reformat token to reverse Polish notation + """ + stack = [] + queue = [] + while any(token_list): + token = token_list.pop(0) + if token.type in ['QubOpr', 'PrjOpr', 'CavOpr', 'Num']: + queue.append(token) + elif token.type in ['Func', 'Ext']: + stack.append(token) + elif token.type in ['MathUnitary', 'MathOrd0', 'MathOrd1']: + while stack and math_priority(token, stack[-1]): + queue.append(stack.pop(-1)) + stack.append(token) + elif token.type in ['BrkL']: + stack.append(token) + elif token.type in ['BrkR']: + while stack[-1].type not in ['BrkL', 'Func']: + queue.append(stack.pop(-1)) + if not any(stack): + raise Exception('Missing correct number of brackets') + pop = stack.pop(-1) + if pop.type == 'Func': + queue.append(pop) + else: + raise Exception('Invalid token %s is found' % token.name) + + while any(stack): + queue.append(stack.pop(-1)) + + return queue + + def _token2qobj(self, tokens): + """ Generate quantum class object from tokens + """ + stack = [] + for token in tokens: + if token.type in ['QubOpr', 'PrjOpr', 'CavOpr']: + stack.append(self.__str2qopr[token.name]) + elif token.type == 'Num': + stack.append(float(token.name)) + elif token.type in ['MathUnitary']: + if token.name == '-': + stack.append(-stack.pop(-1)) + elif token.type in ['MathOrd0', 'MathOrd1']: + op2 = stack.pop(-1) + op1 = stack.pop(-1) + if token.name == '+': + stack.append(op1 + op2) + elif token.name == '-': + stack.append(op1 - op2) + elif token.name == '*': + stack.append(op1 * op2) + elif token.name == '/': + stack.append(op1 / op2) + elif token.type in ['Func', 'Ext']: + stack.append(get_func(token.name, stack.pop(-1))) + else: + raise Exception('Invalid token %s is found' % token.name) + + if len(stack) > 1: + raise Exception('Invalid mathematical operation in ' % tokens) + + return stack[0] + + +class NoiseParser: + """ Generate QuTip noise object from dictionary + Qubit noise is given in the format of nested dictionary: + "qubit": { + "0": { + "Sm": 0.006 + } + } + and oscillator noise is given in the format of nested dictionary: + "oscillator": { + "n_th": { + "0": 0.001 + }, + "coupling": { + "0": 0.05 + } + } + these configurations are combined in the same dictionary + """ + def __init__(self, noise_dict, dim_osc, dim_qub): + """ Create new quantum operator generator + + Parameters: + noise_dict (dict): dictionary of noise configuration + dim_osc (dict): dimension of oscillator subspace + dim_qub (dict): dimension of qubit subspace + """ + self.noise_osc = noise_dict.get('oscillator', {'n_th': {}, 'coupling': {}}) + self.noise_qub = noise_dict.get('qubit', {}) + self.dim_osc = dim_osc + self.dim_qub = dim_qub + self.__c_list = [] + + @property + def compiled(self): + """ Return noise configuration in OpenPulse handler format + """ + return self.__c_list + + def parse(self): + """ Parse and generate quantum class object + """ + # Qubit noise + for index, config in self.noise_qub.items(): + for opname, coef in config.items(): + # TODO: support noise in multi-dimensional system + # TODO: support noise with math operation + if opname in ['X', 'Y', 'Z', 'Sp', 'Sm']: + opr = gen_oper(opname, int(index), self.dim_osc, self.dim_qub) + else: + raise Exception('Unsupported noise operator %s is given' % opname) + self.__c_list.append(np.sqrt(coef) * opr) + # Oscillator noise + ndic = self.noise_osc['n_th'] + cdic = self.noise_osc['coupling'] + for (n_ii, n_coef), (c_ii, c_coef) in zip(ndic.items(), cdic.items()): + if n_ii == c_ii: + if c_coef > 0: + opr = gen_oper('A', int(n_ii), self.dim_osc, self.dim_qub) + if n_coef: + self.__c_list.append(np.sqrt(c_coef * (1 + n_coef)) * opr) + self.__c_list.append(np.sqrt(c_coef * n_coef) * opr.dag()) + else: + self.__c_list.append(np.sqrt(c_coef) * opr) + else: + raise Exception('Invalid oscillator index in noise dictionary.') + + +def math_priority(o1, o2): + """ Check priority of given math operation + """ + rank = {'MathUnitary': 2, 'MathOrd0': 1, 'MathOrd1': 0} + diff_ops = rank.get(o1.type, -1) - rank.get(o2.type, -1) + + if diff_ops > 0: + return False + else: + return True + +# pylint: disable=dangerous-default-value +def parse_binop(op_str, operands={}, cast_str=True): + """ Calculate binary operation in string format + """ + oprs = OrderedDict( + sum=r"(?P[a-zA-Z0-9]+)\+(?P[a-zA-Z0-9]+)", + sub=r"(?P[a-zA-Z0-9]+)\-(?P[a-zA-Z0-9]+)", + mul=r"(?P[a-zA-Z0-9]+)\*(?P[a-zA-Z0-9]+)", + div=r"(?P[a-zA-Z0-9]+)\/(?P[a-zA-Z0-9]+)", + non=r"(?P[a-zA-Z0-9]+)" + ) + + for key, regr in oprs.items(): + p = re.match(regr, op_str) + if p: + val0 = operands.get(p.group('v0'), p.group('v0')) + if key == 'non': + # substitution + retv = val0 + else: + val1 = operands.get(p.group('v1'), p.group('v1')) + # binary operation + if key == 'sum': + if val0.isdecimal() and val1.isdecimal(): + retv = int(val0) + int(val1) + else: + retv = '+'.join(str(val0), str(val1)) + elif key == 'sub': + if val0.isdecimal() and val1.isdecimal(): + retv = int(val0) - int(val1) + else: + retv = '-'.join(str(val0), str(val1)) + elif key == 'mul': + if val0.isdecimal() and val1.isdecimal(): + retv = int(val0) * int(val1) + else: + retv = '*'.join(str(val0), str(val1)) + elif key == 'div': + if val0.isdecimal() and val1.isdecimal(): + retv = int(val0) / int(val1) + else: + retv = '/'.join(str(val0), str(val1)) + else: + retv = 0 + break + else: + raise Exception('Invalid string %s' % op_str) + + if cast_str: + return str(retv) + else: + return retv diff --git a/qiskit/providers/aer/openpulse/qutip_lite/__init__.py b/qiskit/providers/aer/openpulse/qutip_lite/__init__.py new file mode 100755 index 0000000000..cd51b99d40 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/__init__.py @@ -0,0 +1,47 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/__init__.py b/qiskit/providers/aer/openpulse/qutip_lite/cy/__init__.py new file mode 100755 index 0000000000..e69de29bb2 diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/complex_math.pxi b/qiskit/providers/aer/openpulse/qutip_lite/cy/complex_math.pxi new file mode 100755 index 0000000000..43f0fd1793 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/complex_math.pxi @@ -0,0 +1,24 @@ +cdef extern from "" namespace "std" nogil: + double abs(double complex x) + double complex acos(double complex x) + double complex acosh(double complex x) + double arg(double complex x) + double complex asin(double complex x) + double complex asinh(double complex x) + double complex atan(double complex x) + double complex atanh(double complex x) + double complex conj(double complex x) + double complex cos(double complex x) + double complex cosh(double complex x) + double complex exp(double complex x) + double imag(double complex x) + double complex log(double complex x) + double complex log10(double complex x) + double norm(double complex x) + double complex proj(double complex x) + double real(double complex x) + double complex sin(double complex x) + double complex sinh(double complex x) + double complex sqrt(double complex x) + double complex tan(double complex x) + double complex tanh(double complex x) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pxd b/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pxd new file mode 100755 index 0000000000..d75351dd13 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pxd @@ -0,0 +1,36 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### + +cdef double complex erf(double complex Z) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pyx b/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pyx new file mode 100755 index 0000000000..661cc2a219 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pyx @@ -0,0 +1,125 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +cimport cython +from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign) + +cdef extern from "" namespace "std" nogil: + double real(double complex x) + double imag(double complex x) + +# +# Shanjie Zhang and Jianming Jin +# +# Copyrighted but permission granted to use code in programs. +# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc. + +@cython.cdivision(True) +@cython.boundscheck(False) +cdef double complex erf(double complex Z): + """ + Parameters + ---------- + Z : double complex + Input parameter. + X : double + Real part of Z. + Y : double + Imag part of Z. + + Returns + ------- + erf(z) : double complex + """ + + cdef double EPS = 1e-12 + cdef double X = real(Z) + cdef double Y = imag(Z) + cdef double X2 = X * X + + cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1 + + cdef size_t K, N + + if X < 3.5: + ER = 1.0 + R = 1.0 + W = 0.0 + for K in range(1, 100): + R = R*X2/(K+0.5) + ER = ER+R + if (fabs(ER-W) < EPS*fabs(ER)): + break + W = ER + C0 = 2.0/sqrt(pi)*X*exp(-X2) + ER0 = C0*ER + else: + ER = 1.0 + R=1.0 + for K in range(1, 12): + R = -R*(K-0.5)/X2 + ER = ER+R + C0 = exp(-X2)/(X*sqrt(pi)) + ER0 = 1.0-C0*ER + + if Y == 0.0: + ERR = ER0 + ERI = 0.0 + else: + CS = cos(2.0*X*Y) + SS = sin(2.0*X*Y) + ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X) + EI1 = exp(-X2)*SS/(2.0*pi*X) + ER2 = 0.0 + W1 = 0.0 + + for N in range(1,100): + ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS) + if (fabs((ER2-W1)/ER2) < EPS): + break + W1 = ER2 + + C0 = 2.0*exp(-X2)/pi + ERR = ER0+ER1+C0*ER2 + EI2 = 0.0 + W2 = 0.0 + + for N in range(1,100): + EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS) + if (fabs((EI2-W2)/EI2) < EPS): + break + W2 = EI2 + ERI = EI1+C0*EI2 + + return ERR + 1j*ERI \ No newline at end of file diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/parameters.pxi b/qiskit/providers/aer/openpulse/qutip_lite/cy/parameters.pxi new file mode 100755 index 0000000000..66705ba064 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/parameters.pxi @@ -0,0 +1,14 @@ +import numpy as np +cimport numpy as cnp + +DTYPE = np.float64 +ctypedef cnp.float64_t DTYPE_t + +ITYPE = np.int32 +ctypedef cnp.int32_t ITYPE_t + +CTYPE = np.complex128 +ctypedef cnp.complex128_t CTYPE_t + +CTYPE = np.int64 +ctypedef cnp.int64_t LTYPE_t diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py b/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py new file mode 100755 index 0000000000..acd1e9fbe0 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py @@ -0,0 +1,66 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +import sys, os +import pyximport +from pyximport import install + +old_get_distutils_extension = pyximport.pyximport.get_distutils_extension + +def new_get_distutils_extension(modname, pyxfilename, language_level=None): + extension_mod, setup_args = old_get_distutils_extension(modname, pyxfilename, language_level) + extension_mod.language='c++' + # If on Win and Python version >= 3.5 and not in MSYS2 (i.e. Visual studio compile) + if sys.platform == 'win32' and int(str(sys.version_info[0])+str(sys.version_info[1])) >= 35 and os.environ.get('MSYSTEM') is None: + extension_mod.extra_compile_args = ['/w', '/O1'] + else: + extension_mod.extra_compile_args = ['-w', '-O1'] + if sys.platform == 'darwin': + extension_mod.extra_compile_args.append('-mmacosx-version-min=10.9') + extension_mod.extra_link_args = ['-mmacosx-version-min=10.9'] + return extension_mod,setup_args + +pyximport.pyximport.get_distutils_extension = new_get_distutils_extension diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_routines.pxi b/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_routines.pxi new file mode 100755 index 0000000000..983d21b908 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_routines.pxi @@ -0,0 +1,644 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +import numpy as np +from scipy.sparse import coo_matrix +from qiskit.providers.aer.openpulse.qutip_lite.fastsparse import fast_csr_matrix +cimport numpy as np +cimport cython +from libcpp.algorithm cimport sort +from libcpp.vector cimport vector +from qiskit.providers.aer.openpulse.qutip_lite.cy.sparse_structs cimport CSR_Matrix, COO_Matrix +np.import_array() + +cdef extern from "numpy/arrayobject.h" nogil: + void PyArray_ENABLEFLAGS(np.ndarray arr, int flags) + void PyDataMem_FREE(void * ptr) + void PyDataMem_RENEW(void * ptr, size_t size) + void PyDataMem_NEW_ZEROED(size_t size, size_t elsize) + void PyDataMem_NEW(size_t size) + + +#Struct used for CSR indices sorting +cdef struct _data_ind_pair: + double complex data + int ind + +ctypedef _data_ind_pair data_ind_pair +ctypedef int (*cfptr)(data_ind_pair, data_ind_pair) + + +cdef void raise_error_CSR(int E, CSR_Matrix * C = NULL): + if not C.numpy_lock and C != NULL: + free_CSR(C) + if E == -1: + raise MemoryError('Could not allocate memory.') + elif E == -2: + raise Exception('Error manipulating CSR_Matrix structure.') + elif E == -3: + raise Exception('CSR_Matrix is not initialized.') + elif E == -4: + raise Exception('NumPy already has lock on data.') + elif E == -5: + raise Exception('Cannot expand data structures past max_length.') + elif E == -6: + raise Exception('CSR_Matrix cannot be expanded.') + elif E == -7: + raise Exception('Data length cannot be larger than max_length') + else: + raise Exception('Error in Cython code.') + + +cdef void raise_error_COO(int E, COO_Matrix * C = NULL): + if not C.numpy_lock and C != NULL: + free_COO(C) + if E == -1: + raise MemoryError('Could not allocate memory.') + elif E == -2: + raise Exception('Error manipulating COO_Matrix structure.') + elif E == -3: + raise Exception('COO_Matrix is not initialized.') + elif E == -4: + raise Exception('NumPy already has lock on data.') + elif E == -5: + raise Exception('Cannot expand data structures past max_length.') + elif E == -6: + raise Exception('COO_Matrix cannot be expanded.') + elif E == -7: + raise Exception('Data length cannot be larger than max_length') + else: + raise Exception('Error in Cython code.') + + +cdef inline int int_min(int a, int b) nogil: + return b if b < a else a + +cdef inline int int_max(int a, int b) nogil: + return a if a > b else b + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void init_CSR(CSR_Matrix * mat, int nnz, int nrows, int ncols = 0, + int max_length = 0, int init_zeros = 1): + """ + Initialize CSR_Matrix struct. Matrix is assumed to be square with + shape nrows x nrows. Manually set mat.ncols otherwise + + Parameters + ---------- + mat : CSR_Matrix * + Pointer to struct. + nnz : int + Length of data and indices arrays. Also number of nonzero elements + nrows : int + Number of rows in matrix. Also gives length + of indptr array (nrows+1). + ncols : int (default = 0) + Number of cols in matrix. Default is ncols = nrows. + max_length : int (default = 0) + Maximum length of data and indices arrays. Used for resizing. + Default value of zero indicates no resizing. + """ + if max_length == 0: + max_length = nnz + if nnz > max_length: + raise_error_CSR(-7, mat) + if init_zeros: + mat.data = PyDataMem_NEW_ZEROED(nnz, sizeof(double complex)) + else: + mat.data = PyDataMem_NEW(nnz * sizeof(double complex)) + if mat.data == NULL: + raise_error_CSR(-1, mat) + if init_zeros: + mat.indices = PyDataMem_NEW_ZEROED(nnz, sizeof(int)) + mat.indptr = PyDataMem_NEW_ZEROED((nrows+1), sizeof(int)) + else: + mat.indices = PyDataMem_NEW(nnz * sizeof(int)) + mat.indptr = PyDataMem_NEW((nrows+1) * sizeof(int)) + mat.nnz = nnz + mat.nrows = nrows + if ncols == 0: + mat.ncols = nrows + else: + mat.ncols = ncols + mat.is_set = 1 + mat.max_length = max_length + mat.numpy_lock = 0 + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void copy_CSR(CSR_Matrix * out, CSR_Matrix * mat): + """ + Copy a CSR_Matrix. + """ + cdef size_t kk + if not mat.is_set: + raise_error_CSR(-3) + elif out.is_set: + raise_error_CSR(-2) + init_CSR(out, mat.nnz, mat.nrows, mat.nrows, mat.max_length) + # We cannot use memcpy here since there are issues with + # doing so on Win with the GCC compiler + for kk in range(mat.nnz): + out.data[kk] = mat.data[kk] + out.indices[kk] = mat.indices[kk] + for kk in range(mat.nrows+1): + out.indptr[kk] = mat.indptr[kk] + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void init_COO(COO_Matrix * mat, int nnz, int nrows, int ncols = 0, + int max_length = 0, int init_zeros = 1): + """ + Initialize COO_Matrix struct. Matrix is assumed to be square with + shape nrows x nrows. Manually set mat.ncols otherwise + + Parameters + ---------- + mat : COO_Matrix * + Pointer to struct. + nnz : int + Number of nonzero elements. + nrows : int + Number of rows in matrix. + nrows : int (default = 0) + Number of cols in matrix. Default is ncols = nrows. + max_length : int (default = 0) + Maximum length of arrays. Used for resizing. + Default value of zero indicates no resizing. + """ + if max_length == 0: + max_length = nnz + if nnz > max_length: + raise_error_COO(-7, mat) + if init_zeros: + mat.data = PyDataMem_NEW_ZEROED(nnz, sizeof(double complex)) + else: + mat.data = PyDataMem_NEW(nnz * sizeof(double complex)) + if mat.data == NULL: + raise_error_COO(-1, mat) + if init_zeros: + mat.rows = PyDataMem_NEW_ZEROED(nnz, sizeof(int)) + mat.cols = PyDataMem_NEW_ZEROED(nnz, sizeof(int)) + else: + mat.rows = PyDataMem_NEW(nnz * sizeof(int)) + mat.cols = PyDataMem_NEW(nnz * sizeof(int)) + mat.nnz = nnz + mat.nrows = nrows + if ncols == 0: + mat.ncols = nrows + else: + mat.ncols = ncols + mat.is_set = 1 + mat.max_length = max_length + mat.numpy_lock = 0 + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void free_CSR(CSR_Matrix * mat): + """ + Manually free CSR_Matrix data structures if + data is not locked by NumPy. + """ + if not mat.numpy_lock and mat.is_set: + if mat.data != NULL: + PyDataMem_FREE(mat.data) + if mat.indices != NULL: + PyDataMem_FREE(mat.indices) + if mat.indptr != NULL: + PyDataMem_FREE(mat.indptr) + mat.is_set = 0 + else: + raise_error_CSR(-2) + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void free_COO(COO_Matrix * mat): + """ + Manually free COO_Matrix data structures if + data is not locked by NumPy. + """ + if not mat.numpy_lock and mat.is_set: + if mat.data != NULL: + PyDataMem_FREE(mat.data) + if mat.rows != NULL: + PyDataMem_FREE(mat.rows) + if mat.cols != NULL: + PyDataMem_FREE(mat.cols) + mat.is_set = 0 + else: + raise_error_COO(-2) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void shorten_CSR(CSR_Matrix * mat, int N): + """ + Shortends the length of CSR data and indices arrays. + """ + if (not mat.numpy_lock) and mat.is_set: + mat.data = PyDataMem_RENEW(mat.data, N * sizeof(double complex)) + mat.indices = PyDataMem_RENEW(mat.indices, N * sizeof(int)) + mat.nnz = N + else: + if mat.numpy_lock: + raise_error_CSR(-4, mat) + elif not mat.is_set: + raise_error_CSR(-3, mat) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void expand_CSR(CSR_Matrix * mat, int init_zeros=0): + """ + Expands the length of CSR data and indices arrays to accomodate + more nnz. THIS IS CURRENTLY NOT USED + """ + cdef size_t ii + cdef int new_size + if mat.nnz == mat.max_length: + raise_error_CSR(-5, mat) #Cannot expand data past max_length. + elif (not mat.numpy_lock) and mat.is_set: + new_size = int_min(2*mat.nnz, mat.max_length) + new_data = PyDataMem_RENEW(mat.data, new_size * sizeof(double complex)) + if new_data == NULL: + raise_error_CSR(-1, mat) + else: + mat.data = new_data + if init_zeros == 1: + for ii in range(mat.nnz, new_size): + mat.data[ii] = 0 + + new_ind = PyDataMem_RENEW(mat.indices, new_size * sizeof(int)) + mat.indices = new_ind + if init_zeros == 1: + for ii in range(mat.nnz, new_size): + mat.indices[ii] = 0 + mat.nnz = new_size + else: + if mat.numpy_lock: + raise_error_CSR(-4, mat) + elif not mat.is_set: + raise_error_CSR(-3, mat) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef object CSR_to_scipy(CSR_Matrix * mat): + """ + Converts a CSR_Matrix struct to a SciPy csr_matrix class object. + The NumPy arrays are generated from the pointers, and the lifetime + of the pointer memory is tied to that of the NumPy array + (i.e. automatic garbage cleanup.) + + Parameters + ---------- + mat : CSR_Matrix * + Pointer to CSR_Matrix. + """ + cdef np.npy_intp dat_len, ptr_len + cdef np.ndarray[complex, ndim=1] _data + cdef np.ndarray[int, ndim=1] _ind, _ptr + if (not mat.numpy_lock) and mat.is_set: + dat_len = mat.nnz + ptr_len = mat.nrows+1 + _data = np.PyArray_SimpleNewFromData(1, &dat_len, np.NPY_COMPLEX128, mat.data) + PyArray_ENABLEFLAGS(_data, np.NPY_OWNDATA) + + _ind = np.PyArray_SimpleNewFromData(1, &dat_len, np.NPY_INT32, mat.indices) + PyArray_ENABLEFLAGS(_ind, np.NPY_OWNDATA) + + _ptr = np.PyArray_SimpleNewFromData(1, &ptr_len, np.NPY_INT32, mat.indptr) + PyArray_ENABLEFLAGS(_ptr, np.NPY_OWNDATA) + mat.numpy_lock = 1 + return fast_csr_matrix((_data, _ind, _ptr), shape=(mat.nrows,mat.ncols)) + else: + if mat.numpy_lock: + raise_error_CSR(-4) + elif not mat.is_set: + raise_error_CSR(-3) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef object COO_to_scipy(COO_Matrix * mat): + """ + Converts a COO_Matrix struct to a SciPy coo_matrix class object. + The NumPy arrays are generated from the pointers, and the lifetime + of the pointer memory is tied to that of the NumPy array + (i.e. automatic garbage cleanup.) + + Parameters + ---------- + mat : COO_Matrix * + Pointer to COO_Matrix. + """ + cdef np.npy_intp dat_len + cdef np.ndarray[complex, ndim=1] _data + cdef np.ndarray[int, ndim=1] _row, _col + if (not mat.numpy_lock) and mat.is_set: + dat_len = mat.nnz + _data = np.PyArray_SimpleNewFromData(1, &dat_len, np.NPY_COMPLEX128, mat.data) + PyArray_ENABLEFLAGS(_data, np.NPY_OWNDATA) + + _row = np.PyArray_SimpleNewFromData(1, &dat_len, np.NPY_INT32, mat.rows) + PyArray_ENABLEFLAGS(_row, np.NPY_OWNDATA) + + _col = np.PyArray_SimpleNewFromData(1, &dat_len, np.NPY_INT32, mat.cols) + PyArray_ENABLEFLAGS(_col, np.NPY_OWNDATA) + mat.numpy_lock = 1 + return coo_matrix((_data, (_row, _col)), shape=(mat.nrows,mat.ncols)) + else: + if mat.numpy_lock: + raise_error_COO(-4) + elif not mat.is_set: + raise_error_COO(-3) + + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void COO_to_CSR(CSR_Matrix * out, COO_Matrix * mat): + """ + Conversion from COO to CSR. Not in place, + but result is sorted correctly. + """ + cdef int i, j, iad, j0 + cdef double complex val + cdef size_t kk + init_CSR(out, mat.nnz, mat.nrows, mat.ncols, max_length=0, init_zeros=1) + # Determine row lengths + for kk in range(mat.nnz): + out.indptr[mat.rows[kk]] = out.indptr[mat.rows[kk]] + 1 + # Starting position of rows + j = 0 + for kk in range(mat.nrows): + j0 = out.indptr[kk] + out.indptr[kk] = j + j += j0 + #Do the data + for kk in range(mat.nnz): + i = mat.rows[kk] + j = mat.cols[kk] + val = mat.data[kk] + iad = out.indptr[i] + out.data[iad] = val + out.indices[iad] = j + out.indptr[i] = iad+1 + # Shift back + for kk in range(mat.nrows,0,-1): + out.indptr[kk] = out.indptr[kk-1] + out.indptr[0] = 0 + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void CSR_to_COO(COO_Matrix * out, CSR_Matrix * mat): + """ + Converts a CSR_Matrix to a COO_Matrix. + """ + cdef int k1, k2 + cdef size_t jj, kk + init_COO(out, mat.nnz, mat.nrows, mat.ncols) + for kk in range(mat.nnz): + out.data[kk] = mat.data[kk] + out.cols[kk] = mat.indices[kk] + for kk in range(mat.nrows-1,0,-1): + k1 = mat.indptr[kk+1] + k2 = mat.indptr[kk] + for jj in range(k2, k1): + out.rows[jj] = kk + + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void COO_to_CSR_inplace(CSR_Matrix * out, COO_Matrix * mat): + """ + In place conversion from COO to CSR. In place, but not sorted. + The length of the COO (data,rows,cols) must be equal to the NNZ + in the final matrix (i.e. no padded zeros on ends of arrays). + """ + cdef size_t kk + cdef int i, j, init, inext, jnext, ipos + cdef int * _tmp_rows + cdef complex val, val_next + cdef int * work = PyDataMem_NEW_ZEROED(mat.nrows+1, sizeof(int)) + # Determine output indptr array + for kk in range(mat.nnz): + i = mat.rows[kk] + work[i+1] += 1 + work[0] = 0 + for kk in range(mat.nrows): + work[kk+1] += work[kk] + + if mat.nnz < (mat.nrows+1): + _tmp_rows = PyDataMem_RENEW(mat.rows, (mat.nrows+1) * sizeof(int)) + mat.rows = _tmp_rows + init = 0 + while init < mat.nnz: + while (mat.rows[init] < 0): + init += 1 + val = mat.data[init] + i = mat.rows[init] + j = mat.cols[init] + mat.rows[init] = -1 + while 1: + ipos = work[i] + val_next = mat.data[ipos] + inext = mat.rows[ipos] + jnext = mat.cols[ipos] + + mat.data[ipos] = val + mat.cols[ipos] = j + mat.rows[ipos] = -1 + work[i] += 1 + if inext < 0: + break + val = val_next + i = inext + j = jnext + init += 1 + + for kk in range(mat.nrows): + mat.rows[kk+1] = work[kk] + mat.rows[0] = 0 + + if mat.nnz > (mat.nrows+1): + _tmp_rows = PyDataMem_RENEW(mat.rows, (mat.nrows+1) * sizeof(int)) + mat.rows = _tmp_rows + #Free working array + PyDataMem_FREE(work) + #Set CSR pointers to original COO data. + out.data = mat.data + out.indices = mat.cols + out.indptr = mat.rows + out.nrows = mat.nrows + out.ncols = mat.ncols + out.nnz = mat.nnz + out.max_length = mat.nnz + out.is_set = 1 + out.numpy_lock = 0 + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef int ind_sort(data_ind_pair x, data_ind_pair y): + return x.ind < y.ind + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void sort_indices(CSR_Matrix * mat): + """ + Sorts the indices of a CSR_Matrix inplace. + """ + cdef size_t ii, jj + cdef vector[data_ind_pair] pairs + cdef cfptr cfptr_ = &ind_sort + cdef int row_start, row_end, length + + for ii in range(mat.nrows): + row_start = mat.indptr[ii] + row_end = mat.indptr[ii+1] + length = row_end - row_start + pairs.resize(length) + + for jj in range(length): + pairs[jj].data = mat.data[row_start+jj] + pairs[jj].ind = mat.indices[row_start+jj] + + sort(pairs.begin(),pairs.end(),cfptr_) + + for jj in range(length): + mat.data[row_start+jj] = pairs[jj].data + mat.indices[row_start+jj] = pairs[jj].ind + + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef CSR_Matrix CSR_from_scipy(object A): + """ + Converts a SciPy CSR sparse matrix to a + CSR_Matrix struct. + """ + cdef complex[::1] data = A.data + cdef int[::1] ind = A.indices + cdef int[::1] ptr = A.indptr + cdef int nrows = A.shape[0] + cdef int ncols = A.shape[1] + cdef int nnz = ptr[nrows] + + cdef CSR_Matrix mat + + mat.data = &data[0] + mat.indices = &ind[0] + mat.indptr = &ptr[0] + mat.nrows = nrows + mat.ncols = ncols + mat.nnz = nnz + mat.max_length = nnz + mat.is_set = 1 + mat.numpy_lock = 1 + + return mat + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void CSR_from_scipy_inplace(object A, CSR_Matrix* mat): + """ + Converts a SciPy CSR sparse matrix to a + CSR_Matrix struct. + """ + cdef complex[::1] data = A.data + cdef int[::1] ind = A.indices + cdef int[::1] ptr = A.indptr + cdef int nrows = A.shape[0] + cdef int ncols = A.shape[1] + cdef int nnz = ptr[nrows] + + mat.data = &data[0] + mat.indices = &ind[0] + mat.indptr = &ptr[0] + mat.nrows = nrows + mat.ncols = ncols + mat.nnz = nnz + mat.max_length = nnz + mat.is_set = 1 + mat.numpy_lock = 1 + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef COO_Matrix COO_from_scipy(object A): + """ + Converts a SciPy COO sparse matrix to a + COO_Matrix struct. + """ + cdef complex[::1] data = A.data + cdef int[::1] rows = A.row + cdef int[::1] cols = A.col + cdef int nrows = A.shape[0] + cdef int ncols = A.shape[1] + cdef int nnz = data.shape[0] + + cdef COO_Matrix mat + mat.data = &data[0] + mat.rows = &rows[0] + mat.cols = &cols[0] + mat.nrows = nrows + mat.ncols = ncols + mat.nnz = nnz + mat.max_length = nnz + mat.is_set = 1 + mat.numpy_lock = 1 + + return mat + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void identity_CSR(CSR_Matrix * mat, unsigned int nrows): + cdef size_t kk + init_CSR(mat, nrows, nrows, nrows, 0, 0) + for kk in range(nrows): + mat.data[kk] = 1 + mat.indices[kk] = kk + mat.indptr[kk] = kk + mat.indptr[nrows] = nrows diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_structs.pxd b/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_structs.pxd new file mode 100755 index 0000000000..89c7971639 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_structs.pxd @@ -0,0 +1,59 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### + +cdef struct _csr_mat: + double complex * data + int * indices + int * indptr + int nnz + int nrows + int ncols + int is_set + int max_length + int numpy_lock + +cdef struct _coo_mat: + double complex * data + int * rows + int * cols + int nnz + int nrows + int ncols + int is_set + int max_length + int numpy_lock + +ctypedef _csr_mat CSR_Matrix +ctypedef _coo_mat COO_Matrix diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_utils.pyx b/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_utils.pyx new file mode 100755 index 0000000000..c0d925bb2b --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_utils.pyx @@ -0,0 +1,375 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +import numpy as np +from qiskit.providers.aer.openpulse.qutip_lite.fastsparse import fast_csr_matrix +cimport numpy as cnp +from libc.math cimport abs, fabs, sqrt +from libcpp cimport bool +cimport cython +cnp.import_array() + +cdef extern from "numpy/arrayobject.h" nogil: + void PyArray_ENABLEFLAGS(cnp.ndarray arr, int flags) + void PyDataMem_FREE(void * ptr) + void PyDataMem_RENEW(void * ptr, size_t size) + void PyDataMem_NEW_ZEROED(size_t size, size_t elsize) + void PyDataMem_NEW(size_t size) + + +cdef extern from "" namespace "std" nogil: + double abs(double complex x) + double real(double complex x) + double imag(double complex x) + +cdef extern from "" namespace "std" nogil: + double cabs "abs" (double complex x) + +cdef inline int int_max(int x, int y): + return x ^ ((x ^ y) & -(x < y)) + +include "parameters.pxi" + +@cython.boundscheck(False) +@cython.wraparound(False) +def _sparse_bandwidth( + int[::1] idx, + int[::1] ptr, + int nrows): + """ + Calculates the max (mb), lower(lb), and upper(ub) bandwidths of a + csr_matrix. + """ + cdef int ldist + cdef int lb = -nrows + cdef int ub = -nrows + cdef int mb = 0 + cdef size_t ii, jj + + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii + 1]): + ldist = ii - idx[jj] + lb = int_max(lb, ldist) + ub = int_max(ub, -ldist) + mb = int_max(mb, ub + lb + 1) + + return mb, lb, ub + + +@cython.boundscheck(False) +@cython.wraparound(False) +def _sparse_profile(int[::1] idx, + int[::1] ptr, + int nrows): + cdef int ii, jj, temp, ldist=0 + cdef LTYPE_t pro = 0 + for ii in range(nrows): + temp = 0 + for jj in range(ptr[ii], ptr[ii + 1]): + ldist = idx[jj] - ii + temp = int_max(temp, ldist) + pro += temp + return pro + + +@cython.boundscheck(False) +@cython.wraparound(False) +def _sparse_permute( + cnp.ndarray[cython.numeric, ndim=1] data, + int[::1] idx, + int[::1] ptr, + int nrows, + int ncols, + cnp.ndarray[ITYPE_t, ndim=1] rperm, + cnp.ndarray[ITYPE_t, ndim=1] cperm, + int flag): + """ + Permutes the rows and columns of a sparse CSR or CSC matrix according to + the permutation arrays rperm and cperm, respectively. + Here, the permutation arrays specify the new order of the rows and columns. + i.e. [0,1,2,3,4] -> [3,0,4,1,2]. + """ + cdef int ii, jj, kk, k0, nnz + cdef cnp.ndarray[cython.numeric] new_data = np.zeros_like(data) + cdef cnp.ndarray[ITYPE_t] new_idx = np.zeros_like(idx) + cdef cnp.ndarray[ITYPE_t] new_ptr = np.zeros_like(ptr) + cdef cnp.ndarray[ITYPE_t] perm_r + cdef cnp.ndarray[ITYPE_t] perm_c + cdef cnp.ndarray[ITYPE_t] inds + + if flag == 0: # CSR matrix + if rperm.shape[0] != 0: + inds = np.argsort(rperm).astype(ITYPE) + perm_r = np.arange(rperm.shape[0], dtype=ITYPE)[inds] + + for jj in range(nrows): + ii = perm_r[jj] + new_ptr[ii + 1] = ptr[jj + 1] - ptr[jj] + + for jj in range(nrows): + new_ptr[jj + 1] = new_ptr[jj+1] + new_ptr[jj] + + for jj in range(nrows): + k0 = new_ptr[perm_r[jj]] + for kk in range(ptr[jj], ptr[jj + 1]): + new_idx[k0] = idx[kk] + new_data[k0] = data[kk] + k0 = k0 + 1 + + if cperm.shape[0] != 0: + inds = np.argsort(cperm).astype(ITYPE) + perm_c = np.arange(cperm.shape[0], dtype=ITYPE)[inds] + nnz = new_ptr[new_ptr.shape[0] - 1] + for jj in range(nnz): + new_idx[jj] = perm_c[new_idx[jj]] + + elif flag == 1: # CSC matrix + if cperm.shape[0] != 0: + inds = np.argsort(cperm).astype(ITYPE) + perm_c = np.arange(cperm.shape[0], dtype=ITYPE)[inds] + + for jj in range(ncols): + ii = perm_c[jj] + new_ptr[ii + 1] = ptr[jj + 1] - ptr[jj] + + for jj in range(ncols): + new_ptr[jj + 1] = new_ptr[jj + 1] + new_ptr[jj] + + for jj in range(ncols): + k0 = new_ptr[perm_c[jj]] + for kk in range(ptr[jj], ptr[jj + 1]): + new_idx[k0] = idx[kk] + new_data[k0] = data[kk] + k0 = k0 + 1 + + if rperm.shape[0] != 0: + inds = np.argsort(rperm).astype(ITYPE) + perm_r = np.arange(rperm.shape[0], dtype=ITYPE)[inds] + nnz = new_ptr[new_ptr.shape[0] - 1] + for jj in range(nnz): + new_idx[jj] = perm_r[new_idx[jj]] + + return new_data, new_idx, new_ptr + + +@cython.boundscheck(False) +@cython.wraparound(False) +def _sparse_reverse_permute( + cnp.ndarray[cython.numeric, ndim=1] data, + int[::1] idx, + int[::1] ptr, + int nrows, + int ncols, + cnp.ndarray[ITYPE_t, ndim=1] rperm, + cnp.ndarray[ITYPE_t, ndim=1] cperm, + int flag): + """ + Reverse permutes the rows and columns of a sparse CSR or CSC matrix + according to the original permutation arrays rperm and cperm, respectively. + """ + cdef int ii, jj, kk, k0, nnz + cdef cnp.ndarray[cython.numeric, ndim=1] new_data = np.zeros_like(data) + cdef cnp.ndarray[ITYPE_t, ndim=1] new_idx = np.zeros_like(idx) + cdef cnp.ndarray[ITYPE_t, ndim=1] new_ptr = np.zeros_like(ptr) + + if flag == 0: # CSR matrix + if rperm.shape[0] != 0: + for jj in range(nrows): + ii = rperm[jj] + new_ptr[ii + 1] = ptr[jj + 1] - ptr[jj] + + for jj in range(nrows): + new_ptr[jj + 1] = new_ptr[jj + 1] + new_ptr[jj] + + for jj in range(nrows): + k0 = new_ptr[rperm[jj]] + for kk in range(ptr[jj], ptr[jj + 1]): + new_idx[k0] = idx[kk] + new_data[k0] = data[kk] + k0 = k0 + 1 + + if cperm.shape[0] > 0: + nnz = new_ptr[new_ptr.shape[0] - 1] + for jj in range(nnz): + new_idx[jj] = cperm[new_idx[jj]] + + if flag == 1: # CSC matrix + if cperm.shape[0] != 0: + for jj in range(ncols): + ii = cperm[jj] + new_ptr[ii + 1] = ptr[jj + 1] - ptr[jj] + + for jj in range(ncols): + new_ptr[jj + 1] = new_ptr[jj + 1] + new_ptr[jj] + + for jj in range(ncols): + k0 = new_ptr[cperm[jj]] + for kk in range(ptr[jj], ptr[jj + 1]): + new_idx[k0] = idx[kk] + new_data[k0] = data[kk] + k0 = k0 + 1 + + if cperm.shape[0] != 0: + nnz = new_ptr[new_ptr.shape[0] - 1] + for jj in range(nnz): + new_idx[jj] = rperm[new_idx[jj]] + + return new_data, new_idx, new_ptr + + +@cython.boundscheck(False) +@cython.wraparound(False) +def _isdiag(int[::1] idx, + int[::1] ptr, + int nrows): + + cdef int row, num_elems + for row in range(nrows): + num_elems = ptr[row+1] - ptr[row] + if num_elems > 1: + return 0 + elif num_elems == 1: + if idx[ptr[row]] != row: + return 0 + return 1 + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cnp.ndarray[complex, ndim=1, mode='c'] _csr_get_diag(complex[::1] data, + int[::1] idx, int[::1] ptr, int k=0): + + cdef size_t row, jj + cdef int num_rows = ptr.shape[0]-1 + cdef int abs_k = abs(k) + cdef int start, stop + cdef cnp.ndarray[complex, ndim=1, mode='c'] out = np.zeros(num_rows-abs_k, dtype=complex) + + if k >= 0: + start = 0 + stop = num_rows-abs_k + else: #k < 0 + start = abs_k + stop = num_rows + + for row in range(start, stop): + for jj in range(ptr[row], ptr[row+1]): + if idx[jj]-k == row: + out[row-start] = data[jj] + break + return out + + +@cython.boundscheck(False) +@cython.wraparound(False) +@cython.cdivision(True) +def unit_row_norm(complex[::1] data, int[::1] ptr, int nrows): + cdef size_t row, ii + cdef double total + for row in range(nrows): + total = 0 + for ii in range(ptr[row], ptr[row+1]): + total += real(data[ii]) * real(data[ii]) + imag(data[ii]) * imag(data[ii]) + total = sqrt(total) + for ii in range(ptr[row], ptr[row+1]): + data[ii] /= total + + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef double zcsr_one_norm(complex[::1] data, int[::1] ind, int[::1] ptr, + int nrows, int ncols): + + cdef int k + cdef size_t ii, jj + cdef double * col_sum = PyDataMem_NEW_ZEROED(ncols, sizeof(double)) + cdef double max_col = 0 + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii+1]): + k = ind[jj] + col_sum[k] += cabs(data[jj]) + for ii in range(ncols): + if col_sum[ii] > max_col: + max_col = col_sum[ii] + PyDataMem_FREE(col_sum) + return max_col + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef double zcsr_inf_norm(complex[::1] data, int[::1] ind, int[::1] ptr, + int nrows, int ncols): + + cdef int k + cdef size_t ii, jj + cdef double * row_sum = PyDataMem_NEW_ZEROED(nrows, sizeof(double)) + cdef double max_row = 0 + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii+1]): + row_sum[ii] += cabs(data[jj]) + for ii in range(nrows): + if row_sum[ii] > max_row: + max_row = row_sum[ii] + PyDataMem_FREE(row_sum) + return max_row + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef bool cy_tidyup(complex[::1] data, double atol, unsigned int nnz): + """ + Performs an in-place tidyup of CSR matrix data + """ + cdef size_t kk + cdef double re, im + cdef bool re_flag, im_flag, out_flag = 0 + for kk in range(nnz): + re_flag = 0 + im_flag = 0 + re = real(data[kk]) + im = imag(data[kk]) + if fabs(re) < atol: + re = 0 + re_flag = 1 + if fabs(im) < atol: + im = 0 + im_flag = 1 + + if re_flag or im_flag: + data[kk] = re + 1j*im + + if re_flag and im_flag: + out_flag = 1 + return out_flag diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/spconvert.pxd b/qiskit/providers/aer/openpulse/qutip_lite/cy/spconvert.pxd new file mode 100755 index 0000000000..8c74a9d3c0 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/spconvert.pxd @@ -0,0 +1,39 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### + +from qiskit.providers.aer.openpulse.qutip_lite.cy.sparse_structs cimport CSR_Matrix + +cdef void fdense2D_to_CSR(complex[::1, :] mat, CSR_Matrix * out, + unsigned int nrows, unsigned int ncols) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/spconvert.pyx b/qiskit/providers/aer/openpulse/qutip_lite/cy/spconvert.pyx new file mode 100755 index 0000000000..eeb5f0d51a --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/spconvert.pyx @@ -0,0 +1,303 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +import numpy as np +from qiskit.providers.aer.openpulse.qutip_lite.fastsparse import fast_csr_matrix +cimport numpy as cnp +cimport cython +from libc.stdlib cimport div, malloc, free + +cdef extern from "stdlib.h": + ctypedef struct div_t: + int quot + int rem + +include "sparse_routines.pxi" + +@cython.boundscheck(False) +@cython.wraparound(False) +def arr_coo2fast(complex[::1] data, int[::1] rows, int[::1] cols, int nrows, int ncols): + """ + Converts a set of ndarrays (data, rows, cols) that specify a COO sparse matrix + to CSR format. + """ + cdef int nnz = data.shape[0] + cdef COO_Matrix mat + mat.data = &data[0] + mat.rows = &rows[0] + mat.cols = &cols[0] + mat.nrows = nrows + mat.ncols = ncols + mat.nnz = nnz + mat.is_set = 1 + mat.max_length = nnz + + cdef CSR_Matrix out + COO_to_CSR(&out, &mat) + return CSR_to_scipy(&out) + + +@cython.boundscheck(False) +@cython.wraparound(False) +def dense2D_to_fastcsr_cmode(complex[:, ::1] mat, int nrows, int ncols): + """ + Converts a dense c-mode complex ndarray to a sparse CSR matrix. + + Parameters + ---------- + mat : ndarray + Input complex ndarray + nrows : int + Number of rows in matrix. + ncols : int + Number of cols in matrix. + + Returns + ------- + out : fast_csr_matrix + Output matrix in CSR format. + """ + cdef int nnz = 0 + cdef size_t ii, jj + cdef np.ndarray[complex, ndim=1, mode='c'] data = np.zeros(nrows*ncols, dtype=complex) + cdef np.ndarray[int, ndim=1, mode='c'] ind = np.zeros(nrows*ncols, dtype=np.int32) + cdef np.ndarray[int, ndim=1, mode='c'] ptr = np.zeros(nrows+1, dtype=np.int32) + + for ii in range(nrows): + for jj in range(ncols): + if mat[ii,jj] != 0: + ind[nnz] = jj + data[nnz] = mat[ii,jj] + nnz += 1 + ptr[ii+1] = nnz + + if nnz < (nrows*ncols): + return fast_csr_matrix((data[:nnz], ind[:nnz], ptr), shape=(nrows,ncols)) + else: + return fast_csr_matrix((data, ind, ptr), shape=(nrows,ncols)) + + +@cython.boundscheck(False) +@cython.wraparound(False) +def dense1D_to_fastcsr_ket(complex[::1] vec): + """ + Converts a dense c-mode complex ndarray to a sparse CSR matrix. + + Parameters + ---------- + mat : ndarray + Input complex ndarray + + Returns + ------- + out : fast_csr_matrix + Output matrix in CSR format. + """ + cdef int nnz = 0 + cdef size_t ii, nrows = vec.shape[0] + cdef np.ndarray[complex, ndim=1, mode='c'] data = np.zeros(nrows, dtype=complex) + cdef np.ndarray[int, ndim=1, mode='c'] ind = np.zeros(nrows, dtype=np.int32) + cdef np.ndarray[int, ndim=1, mode='c'] ptr = np.zeros(nrows+1, dtype=np.int32) + + for ii in range(nrows): + if vec[ii] != 0: + data[nnz] = vec[ii] + nnz += 1 + ptr[ii+1] = nnz + + if nnz < (nrows): + return fast_csr_matrix((data[:nnz], ind[:nnz], ptr), shape=(nrows,1)) + else: + return fast_csr_matrix((data, ind, ptr), shape=(nrows,1)) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void fdense2D_to_CSR(complex[::1, :] mat, CSR_Matrix * out, + unsigned int nrows, unsigned int ncols): + """ + Converts a dense complex ndarray to a CSR matrix struct. + + Parameters + ---------- + mat : ndarray + Input complex ndarray + nrows : int + Number of rows in matrix. + ncols : int + Number of cols in matrix. + + Returns + ------- + out : CSR_Matrix + Output matrix as CSR struct. + """ + cdef int nnz = 0 + cdef size_t ii, jj + init_CSR(out, nrows*ncols, nrows, ncols, nrows*ncols) + + for ii in range(nrows): + for jj in range(ncols): + if mat[ii,jj] != 0: + out.indices[nnz] = jj + out.data[nnz] = mat[ii,jj] + nnz += 1 + out.indptr[ii+1] = nnz + + if nnz < (nrows*ncols): + shorten_CSR(out, nnz) + + +@cython.boundscheck(False) +@cython.wraparound(False) +def dense2D_to_fastcsr_fmode(complex[::1, :] mat, int nrows, int ncols): + """ + Converts a dense fortran-mode complex ndarray to a sparse CSR matrix. + + Parameters + ---------- + mat : ndarray + Input complex ndarray + nrows : int + Number of rows in matrix. + ncols : int + Number of cols in matrix. + + Returns + ------- + out : fast_csr_matrix + Output matrix in CSR format. + """ + cdef int nnz = 0 + cdef size_t ii, jj + cdef np.ndarray[complex, ndim=1, mode='c'] data = np.zeros(nrows*ncols, dtype=complex) + cdef np.ndarray[int, ndim=1, mode='c'] ind = np.zeros(nrows*ncols, dtype=np.int32) + cdef np.ndarray[int, ndim=1, mode='c'] ptr = np.zeros(nrows+1, dtype=np.int32) + + for ii in range(nrows): + for jj in range(ncols): + if mat[ii,jj] != 0: + ind[nnz] = jj + data[nnz] = mat[ii,jj] + nnz += 1 + ptr[ii+1] = nnz + + if nnz < (nrows*ncols): + return fast_csr_matrix((data[:nnz], ind[:nnz], ptr), shape=(nrows,ncols)) + else: + return fast_csr_matrix((data, ind, ptr), shape=(nrows,ncols)) + + + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_reshape(object A not None, int new_rows, int new_cols): + """ + Reshapes a complex CSR matrix. + + Parameters + ---------- + A : fast_csr_matrix + Input CSR matrix. + new_rows : int + Number of rows in reshaped matrix. + new_cols : int + Number of cols in reshaped matrix. + + Returns + ------- + out : fast_csr_matrix + Reshaped CSR matrix. + + Notes + ----- + This routine does not need to make a temp. copy of the matrix. + """ + cdef CSR_Matrix inmat = CSR_from_scipy(A) + cdef COO_Matrix mat + CSR_to_COO(&mat, &inmat) + cdef CSR_Matrix out + cdef div_t new_inds + cdef size_t kk + + if (mat.nrows * mat.ncols) != (new_rows * new_cols): + raise Exception('Total size of array must be unchanged.') + + for kk in range(mat.nnz): + new_inds = div(mat.ncols*mat.rows[kk]+mat.cols[kk], new_cols) + mat.rows[kk] = new_inds.quot + mat.cols[kk] = new_inds.rem + + mat.nrows = new_rows + mat.ncols = new_cols + + COO_to_CSR_inplace(&out, &mat) + sort_indices(&out) + return CSR_to_scipy(&out) + + +@cython.boundscheck(False) +@cython.wraparound(False) +@cython.cdivision(True) +def cy_index_permute(int [::1] idx_arr, + int [::1] dims, + int [::1] order): + + cdef int ndims = dims.shape[0] + cdef int ii, n, dim, idx, orderr + + #the fastest way to allocate memory for a temporary array + cdef int * multi_idx = malloc(sizeof(int) * ndims) + + try: + for ii from 0 <= ii < idx_arr.shape[0]: + idx = idx_arr[ii] + + #First, decompose long index into multi-index + for n from ndims > n >= 0: + dim = dims[n] + multi_idx[n] = idx % dim + idx = idx // dim + + #Finally, assemble new long index from reordered multi-index + dim = 1 + idx = 0 + for n from ndims > n >= 0: + orderr = order[n] + idx += multi_idx[orderr] * dim + dim *= dims[orderr] + + idx_arr[ii] = idx + finally: + free(multi_idx) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/spmatfuncs.pxd b/qiskit/providers/aer/openpulse/qutip_lite/cy/spmatfuncs.pxd new file mode 100755 index 0000000000..1fe0259a9e --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/spmatfuncs.pxd @@ -0,0 +1,115 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### + +cimport numpy as cnp +cimport cython +from libcpp cimport bool + +include "parameters.pxi" + +cpdef cnp.ndarray[CTYPE_t, ndim=1, mode="c"] spmv_csr(complex[::1] data, + int[::1] ind, int[::1] ptr, complex[::1] vec) + + +cdef void spmvpy(complex * data, + int * ind, + int * ptr, + complex * vec, + complex a, + complex * out, + unsigned int nrows) + + +cpdef cy_expect_rho_vec_csr(complex[::1] data, + int[::1] idx, + int[::1] ptr, + complex[::1] rho_vec, + int herm) + + +cpdef cy_expect_psi(object A, + complex[::1] vec, + bool isherm) + + +cpdef cy_expect_psi_csr(complex[::1] data, + int[::1] ind, + int[::1] ptr, + complex[::1] vec, + bool isherm) + + +cdef void _spmm_c_py(complex * data, + int * ind, + int * ptr, + complex * mat, + complex a, + complex * out, + unsigned int sp_rows, + unsigned int nrows, + unsigned int ncols) + +cpdef void spmmpy_c(complex[::1] data, + int[::1] ind, + int[::1] ptr, + complex[:,::1] M, + complex a, + complex[:,::1] out) + +cpdef cnp.ndarray[complex, ndim=1, mode="c"] spmmc(object sparse, + complex[:,::1] mat) + +cdef void _spmm_f_py(complex * data, + int * ind, + int * ptr, + complex * mat, + complex a, + complex * out, + unsigned int sp_rows, + unsigned int nrows, + unsigned int ncols) + +cpdef void spmmpy_f(complex[::1] data, + int[::1] ind, + int[::1] ptr, + complex[::1,:] mat, + complex a, + complex[::1,:] out) + +cpdef cnp.ndarray[complex, ndim=1, mode="c"] spmmf(object sparse, + complex[::1,:] mat) + +cpdef cnp.ndarray[complex, ndim=1, mode="c"] spmm(object sparse, + cnp.ndarray[complex, ndim=2] mat) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/spmatfuncs.pyx b/qiskit/providers/aer/openpulse/qutip_lite/cy/spmatfuncs.pyx new file mode 100755 index 0000000000..2a0c994d3e --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/spmatfuncs.pyx @@ -0,0 +1,570 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +import numpy as np +cimport numpy as cnp +cimport cython +cimport libc.math +from libcpp cimport bool + +cdef extern from "src/zspmv.hpp" nogil: + void zspmvpy(double complex *data, int *ind, int *ptr, double complex *vec, + double complex a, double complex *out, int nrows) + +include "complex_math.pxi" + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cnp.ndarray[complex, ndim=1, mode="c"] spmv( + object super_op, + complex[::1] vec): + """ + Sparse matrix, dense vector multiplication. + Here the vector is assumed to have one-dimension. + Matrix must be in CSR format and have complex entries. + + Parameters + ---------- + super_op : csr matrix + vec : array + Dense vector for multiplication. Must be one-dimensional. + + Returns + ------- + out : array + Returns dense array. + + """ + return spmv_csr(super_op.data, super_op.indices, super_op.indptr, vec) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cnp.ndarray[complex, ndim=1, mode="c"] spmv_csr(complex[::1] data, + int[::1] ind, int[::1] ptr, complex[::1] vec): + """ + Sparse matrix, dense vector multiplication. + Here the vector is assumed to have one-dimension. + Matrix must be in CSR format and have complex entries. + + Parameters + ---------- + data : array + Data for sparse matrix. + idx : array + Indices for sparse matrix data. + ptr : array + Pointers for sparse matrix data. + vec : array + Dense vector for multiplication. Must be one-dimensional. + + Returns + ------- + out : array + Returns dense array. + + """ + cdef unsigned int num_rows = ptr.shape[0] - 1 + cdef cnp.ndarray[complex, ndim=1, mode="c"] out = np.zeros((num_rows), dtype=np.complex) + zspmvpy(&data[0], &ind[0], &ptr[0], &vec[0], 1.0, &out[0], num_rows) + return out + + +@cython.boundscheck(False) +@cython.wraparound(False) +def spmvpy_csr(complex[::1] data, + int[::1] ind, int[::1] ptr, complex[::1] vec, + complex alpha, complex[::1] out): + """ + Sparse matrix, dense vector multiplication. + Here the vector is assumed to have one-dimension. + Matrix must be in CSR format and have complex entries. + + Parameters + ---------- + data : array + Data for sparse matrix. + idx : array + Indices for sparse matrix data. + ptr : array + Pointers for sparse matrix data. + vec : array + Dense vector for multiplication. Must be one-dimensional. + alpha : complex + Numerical coefficient for sparse matrix. + out: array + Output array + + """ + cdef unsigned int num_rows = vec.shape[0] + zspmvpy(&data[0], &ind[0], &ptr[0], &vec[0], alpha, &out[0], num_rows) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef inline void spmvpy(complex* data, int* ind, int* ptr, + complex* vec, + complex a, + complex* out, + unsigned int nrows): + + zspmvpy(data, ind, ptr, vec, a, out, nrows) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _spmm_c_py(complex* data, int* ind, int* ptr, + complex* mat, complex a, complex* out, + unsigned int sp_rows, unsigned int nrows, unsigned int ncols): + """ + sparse*dense "C" ordered. + """ + cdef int row, col, ii, jj, row_start, row_end + for row from 0 <= row < sp_rows : + row_start = ptr[row] + row_end = ptr[row+1] + for jj from row_start <= jj < row_end: + for col in range(ncols): + out[row * ncols + col] += a*data[jj]*mat[ind[jj] * ncols + col] + + +cpdef void spmmpy_c(complex[::1] data, int[::1] ind, int[::1] ptr, + complex[:,::1] M, complex a, complex[:,::1] out): + """ + Sparse matrix, c ordered dense matrix multiplication. + The sparse matrix must be in CSR format and have complex entries. + + Parameters + ---------- + data : array + Data for sparse matrix. + idx : array + Indices for sparse matrix data. + ptr : array + Pointers for sparse matrix data. + mat : array 2d + Dense matrix for multiplication. Must be in c mode. + alpha : complex + Numerical coefficient for sparse matrix. + out: array + Output array. Must be in c mode. + + """ + cdef unsigned int sp_rows = ptr.shape[0]-1 + cdef unsigned int nrows = M.shape[0] + cdef unsigned int ncols = M.shape[1] + _spmm_c_py(&data[0], &ind[0], &ptr[0], &M[0,0], 1., + &out[0,0], sp_rows, nrows, ncols) + + +cpdef cnp.ndarray[complex, ndim=1, mode="c"] spmmc(object sparse, + complex[:,::1] mat): + """ + Sparse matrix, c ordered dense matrix multiplication. + The sparse matrix must be in CSR format and have complex entries. + + Parameters + ---------- + sparse : csr matrix + mat : array 2d + Dense matrix for multiplication. Must be in c mode. + + Returns + ------- + out : array + Keep input ordering + """ + cdef unsigned int sp_rows = sparse.indptr.shape[0]-1 + cdef unsigned int ncols = mat.shape[1] + cdef cnp.ndarray[complex, ndim=2, mode="c"] out = \ + np.zeros((sp_rows, ncols), dtype=complex) + spmmpy_c(sparse.data, sparse.indices, sparse.indptr, + mat, 1., out) + return out + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _spmm_f_py(complex* data, int* ind, int* ptr, + complex* mat, complex a, complex* out, + unsigned int sp_rows, unsigned int nrows, unsigned int ncols): + """ + sparse*dense "F" ordered. + """ + cdef int col + for col in range(ncols): + spmvpy(data, ind, ptr, mat+nrows*col, a, out+sp_rows*col, sp_rows) + + +cpdef void spmmpy_f(complex[::1] data, int[::1] ind, int[::1] ptr, + complex[::1,:] mat, complex a, complex[::1,:] out): + """ + Sparse matrix, fortran ordered dense matrix multiplication. + The sparse matrix must be in CSR format and have complex entries. + + Parameters + ---------- + data : array + Data for sparse matrix. + idx : array + Indices for sparse matrix data. + ptr : array + Pointers for sparse matrix data. + mat : array 2d + Dense matrix for multiplication. Must be in fortran mode. + alpha : complex + Numerical coefficient for sparse matrix. + out: array + Output array. Must be in fortran mode. + + """ + cdef unsigned int sp_rows = ptr.shape[0]-1 + cdef unsigned int nrows = mat.shape[0] + cdef unsigned int ncols = mat.shape[1] + _spmm_f_py(&data[0], &ind[0], &ptr[0], &mat[0,0], 1., + &out[0,0], sp_rows, nrows, ncols) + + +cpdef cnp.ndarray[complex, ndim=1, mode="c"] spmmf(object sparse, + complex[::1,:] mat): + """ + Sparse matrix, fortran ordered dense matrix multiplication. + The sparse matrix must be in CSR format and have complex entries. + + Parameters + ---------- + sparse : csr matrix + mat : array 2d + Dense matrix for multiplication. Must be in fortran mode. + + Returns + ------- + out : array + Keep input ordering + """ + cdef unsigned int sp_rows = sparse.indptr.shape[0]-1 + cdef unsigned int ncols = mat.shape[1] + cdef cnp.ndarray[complex, ndim=2, mode="fortran"] out = \ + np.zeros((sp_rows, ncols), dtype=complex, order="F") + spmmpy_f(sparse.data, sparse.indices, sparse.indptr, + mat, 1., out) + return out + + +cpdef cnp.ndarray[complex, ndim=1, mode="c"] spmm(object sparse, + cnp.ndarray[complex, ndim=2] mat): + """ + Sparse matrix, dense matrix multiplication. + The sparse matrix must be in CSR format and have complex entries. + + Parameters + ---------- + sparse : csr matrix + mat : array 2d + Dense matrix for multiplication. Can be in c or fortran mode. + + Returns + ------- + out : array + Keep input ordering + """ + if mat.flags["F_CONTIGUOUS"]: + return spmmf(sparse, mat) + else: + return spmmc(sparse, mat) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cnp.ndarray[complex, ndim=1, mode="c"] cy_ode_rhs( + double t, + complex[::1] rho, + complex[::1] data, + int[::1] ind, + int[::1] ptr): + + cdef unsigned int nrows = rho.shape[0] + cdef cnp.ndarray[complex, ndim=1, mode="c"] out = \ + np.zeros(nrows, dtype=complex) + zspmvpy(&data[0], &ind[0], &ptr[0], &rho[0], 1.0, &out[0], nrows) + + return out + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cnp.ndarray[complex, ndim=1, mode="c"] cy_ode_psi_func_td( + double t, + cnp.ndarray[complex, ndim=1, mode="c"] psi, + object H_func, + object args): + + H = H_func(t, args).data + return -1j * spmv_csr(H.data, H.indices, H.indptr, psi) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cnp.ndarray[complex, ndim=1, mode="c"] cy_ode_psi_func_td_with_state( + double t, + cnp.ndarray[complex, ndim=1, mode="c"] psi, + object H_func, + object args): + + H = H_func(t, psi, args) + return -1j * spmv_csr(H.data, H.indices, H.indptr, psi) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cnp.ndarray[complex, ndim=1, mode="c"] cy_ode_rho_func_td( + double t, + cnp.ndarray[complex, ndim=1, mode="c"] rho, + object L0, + object L_func, + object args): + cdef object L + L = L0 + L_func(t, args).data + return spmv_csr(L.data, L.indices, L.indptr, rho) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cy_expect_psi(object A, complex[::1] vec, bool isherm): + + cdef complex[::1] data = A.data + cdef int[::1] ind = A.indices + cdef int[::1] ptr = A.indptr + + cdef size_t row, jj + cdef int nrows = vec.shape[0] + cdef complex expt = 0, temp, cval + + for row in range(nrows): + cval = conj(vec[row]) + temp = 0 + for jj in range(ptr[row], ptr[row+1]): + temp += data[jj]*vec[ind[jj]] + expt += cval*temp + + if isherm : + return real(expt) + else: + return expt + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cy_expect_psi_csr(complex[::1] data, + int[::1] ind, + int[::1] ptr, + complex[::1] vec, + bool isherm): + + cdef size_t row, jj + cdef int nrows = vec.shape[0] + cdef complex expt = 0, temp, cval + + for row in range(nrows): + cval = conj(vec[row]) + temp = 0 + for jj in range(ptr[row], ptr[row+1]): + temp += data[jj]*vec[ind[jj]] + expt += cval*temp + + if isherm : + return real(expt) + else: + return expt + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cy_expect_rho_vec(object super_op, + complex[::1] rho_vec, + int herm): + + return cy_expect_rho_vec_csr(super_op.data, + super_op.indices, + super_op.indptr, + rho_vec, + herm) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cy_expect_rho_vec_csr(complex[::1] data, + int[::1] idx, + int[::1] ptr, + complex[::1] rho_vec, + int herm): + + cdef size_t row + cdef int jj,row_start,row_end + cdef int num_rows = rho_vec.shape[0] + cdef int n = libc.math.sqrt(num_rows) + cdef complex dot = 0.0 + + for row from 0 <= row < num_rows by n+1: + row_start = ptr[row] + row_end = ptr[row+1] + for jj from row_start <= jj < row_end: + dot += data[jj]*rho_vec[idx[jj]] + + if herm == 0: + return dot + else: + return real(dot) + + + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef cy_spmm_tr(object op1, object op2, int herm): + + cdef size_t row + cdef complex tr = 0.0 + + cdef int col1, row1_idx_start, row1_idx_end + cdef complex[::1] data1 = op1.data + cdef int[::1] idx1 = op1.indices + cdef int[::1] ptr1 = op1.indptr + + cdef int col2, row2_idx_start, row2_idx_end + cdef complex[::1] data2 = op2.data + cdef int[::1] idx2 = op2.indices + cdef int[::1] ptr2 = op2.indptr + + cdef int num_rows = ptr1.shape[0]-1 + + for row in range(num_rows): + + row1_idx_start = ptr1[row] + row1_idx_end = ptr1[row + 1] + for row1_idx from row1_idx_start <= row1_idx < row1_idx_end: + col1 = idx1[row1_idx] + + row2_idx_start = ptr2[col1] + row2_idx_end = ptr2[col1 + 1] + for row2_idx from row2_idx_start <= row2_idx < row2_idx_end: + col2 = idx2[row2_idx] + + if col2 == row: + tr += data1[row1_idx] * data2[row2_idx] + break + + if herm == 0: + return tr + else: + return real(tr) + + + +@cython.boundscheck(False) +@cython.wraparound(False) +def expect_csr_ket(object A, object B, int isherm): + + cdef complex[::1] Adata = A.data + cdef int[::1] Aind = A.indices + cdef int[::1] Aptr = A.indptr + cdef complex[::1] Bdata = B.data + cdef int[::1] Bptr = B.indptr + cdef int nrows = A.shape[0] + + cdef int j + cdef size_t ii, jj + cdef double complex cval=0, row_sum, expt = 0 + + for ii in range(nrows): + if (Bptr[ii+1] - Bptr[ii]) != 0: + cval = conj(Bdata[Bptr[ii]]) + row_sum = 0 + for jj in range(Aptr[ii], Aptr[ii+1]): + j = Aind[jj] + if (Bptr[j+1] - Bptr[j]) != 0: + row_sum += Adata[jj]*Bdata[Bptr[j]] + expt += cval*row_sum + if isherm: + return real(expt) + else: + return expt + +@cython.boundscheck(False) +@cython.wraparound(False) +cpdef double complex zcsr_mat_elem(object A, object left, object right, bool bra_ket=1): + """ + Computes the matrix element for an operator A and left and right vectors. + right must be a ket, but left can be a ket or bra vector. If left + is bra then bra_ket = 1, else set bra_ket = 0. + """ + cdef complex[::1] Adata = A.data + cdef int[::1] Aind = A.indices + cdef int[::1] Aptr = A.indptr + cdef int nrows = A.shape[0] + + cdef complex[::1] Ldata = left.data + cdef int[::1] Lind = left.indices + cdef int[::1] Lptr = left.indptr + cdef int Lnnz = Lind.shape[0] + + cdef complex[::1] Rdata = right.data + cdef int[::1] Rind = right.indices + cdef int[::1] Rptr = right.indptr + + cdef int j, go, head=0 + cdef size_t ii, jj, kk + cdef double complex cval=0, row_sum, mat_elem=0 + + for ii in range(nrows): + row_sum = 0 + go = 0 + if bra_ket: + for kk in range(head, Lnnz): + if Lind[kk] == ii: + cval = Ldata[kk] + head = kk + go = 1 + else: + if (Lptr[ii] - Lptr[ii+1]) != 0: + cval = conj(Ldata[Lptr[ii]]) + go = 1 + + if go: + for jj in range(Aptr[ii], Aptr[ii+1]): + j = Aind[jj] + if (Rptr[j] - Rptr[j+1]) != 0: + row_sum += Adata[jj]*Rdata[Rptr[j]] + mat_elem += cval*row_sum + + return mat_elem diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/spmath.pxd b/qiskit/providers/aer/openpulse/qutip_lite/cy/spmath.pxd new file mode 100755 index 0000000000..789c2c9fcc --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/spmath.pxd @@ -0,0 +1,59 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### + +from qiskit.providers.aer.openpulse.qutip_lite.cy.sparse_structs cimport CSR_Matrix + +cdef void _zcsr_add(CSR_Matrix * A, CSR_Matrix * B, + CSR_Matrix * C, double complex alpha) + +cdef int _zcsr_add_core(double complex * Adata, int * Aind, int * Aptr, + double complex * Bdata, int * Bind, int * Bptr, + double complex alpha, + CSR_Matrix * C, + int nrows, int ncols) nogil + +cdef void _zcsr_mult(CSR_Matrix * A, CSR_Matrix * B, CSR_Matrix * C) + + +cdef void _zcsr_kron(CSR_Matrix * A, CSR_Matrix * B, CSR_Matrix * C) + +cdef void _zcsr_kron_core(double complex * dataA, int * indsA, int * indptrA, + double complex * dataB, int * indsB, int * indptrB, + CSR_Matrix * out, + int rowsA, int rowsB, int colsB) nogil + +cdef void _zcsr_transpose(CSR_Matrix * A, CSR_Matrix * B) + +cdef void _zcsr_adjoint(CSR_Matrix * A, CSR_Matrix * B) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/spmath.pyx b/qiskit/providers/aer/openpulse/qutip_lite/cy/spmath.pyx new file mode 100755 index 0000000000..aa0273787c --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/spmath.pyx @@ -0,0 +1,763 @@ +#!python +#cython: language_level=3 +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +import numpy as np +cimport numpy as cnp +cimport cython +from libcpp cimport bool + +cdef extern from "" namespace "std" nogil: + double complex conj(double complex x) + double real(double complex) + double imag(double complex) + double abs(double complex) + +include "sparse_routines.pxi" + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_add(complex[::1] dataA, int[::1] indsA, int[::1] indptrA, + complex[::1] dataB, int[::1] indsB, int[::1] indptrB, + int nrows, int ncols, + int Annz, int Bnnz, + double complex alpha = 1): + + """ + Adds two sparse CSR matries. Like SciPy, we assume the worse case + for the fill A.nnz + B.nnz. + """ + cdef int worse_fill = Annz + Bnnz + cdef int nnz + #Both matrices are zero mats + if Annz == 0 and Bnnz == 0: + return fast_csr_matrix(([], [], []), shape=(nrows,ncols)) + #A is the zero matrix + elif Annz == 0: + return fast_csr_matrix((alpha*np.asarray(dataB), indsB, indptrB), + shape=(nrows,ncols)) + #B is the zero matrix + elif Bnnz == 0: + return fast_csr_matrix((dataA, indsA, indptrA), + shape=(nrows,ncols)) + # Out CSR_Matrix + cdef CSR_Matrix out + init_CSR(&out, worse_fill, nrows, ncols, worse_fill) + + nnz = _zcsr_add_core(&dataA[0], &indsA[0], &indptrA[0], + &dataB[0], &indsB[0], &indptrB[0], + alpha, + &out, + nrows, ncols) + #Shorten data and indices if needed + if out.nnz > nnz: + shorten_CSR(&out, nnz) + return CSR_to_scipy(&out) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _zcsr_add(CSR_Matrix * A, CSR_Matrix * B, CSR_Matrix * C, double complex alpha): + """ + Adds two sparse CSR matries. Like SciPy, we assume the worse case + for the fill A.nnz + B.nnz. + """ + cdef int worse_fill = A.nnz + B.nnz + cdef int nrows = A.nrows + cdef int ncols = A.ncols + cdef int nnz + init_CSR(C, worse_fill, nrows, ncols, worse_fill) + + nnz = _zcsr_add_core(A.data, A.indices, A.indptr, + B.data, B.indices, B.indptr, + alpha, C, nrows, ncols) + #Shorten data and indices if needed + if C.nnz > nnz: + shorten_CSR(C, nnz) + + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef int _zcsr_add_core(double complex * Adata, int * Aind, int * Aptr, + double complex * Bdata, int * Bind, int * Bptr, + double complex alpha, + CSR_Matrix * C, + int nrows, int ncols) nogil: + + cdef int j1, j2, kc = 0 + cdef int ka, kb, ka_max, kb_max + cdef size_t ii + cdef double complex tmp + C.indptr[0] = 0 + if alpha != 1: + for ii in range(nrows): + ka = Aptr[ii] + kb = Bptr[ii] + ka_max = Aptr[ii+1]-1 + kb_max = Bptr[ii+1]-1 + while (ka <= ka_max) or (kb <= kb_max): + if ka <= ka_max: + j1 = Aind[ka] + else: + j1 = ncols+1 + + if kb <= kb_max: + j2 = Bind[kb] + else: + j2 = ncols+1 + + if j1 == j2: + tmp = Adata[ka] + alpha*Bdata[kb] + if tmp != 0: + C.data[kc] = tmp + C.indices[kc] = j1 + kc += 1 + ka += 1 + kb += 1 + elif j1 < j2: + C.data[kc] = Adata[ka] + C.indices[kc] = j1 + ka += 1 + kc += 1 + elif j1 > j2: + C.data[kc] = alpha*Bdata[kb] + C.indices[kc] = j2 + kb += 1 + kc += 1 + + C.indptr[ii+1] = kc + else: + for ii in range(nrows): + ka = Aptr[ii] + kb = Bptr[ii] + ka_max = Aptr[ii+1]-1 + kb_max = Bptr[ii+1]-1 + while (ka <= ka_max) or (kb <= kb_max): + if ka <= ka_max: + j1 = Aind[ka] + else: + j1 = ncols+1 + + if kb <= kb_max: + j2 = Bind[kb] + else: + j2 = ncols+1 + + if j1 == j2: + tmp = Adata[ka] + Bdata[kb] + if tmp != 0: + C.data[kc] = tmp + C.indices[kc] = j1 + kc += 1 + ka += 1 + kb += 1 + elif j1 < j2: + C.data[kc] = Adata[ka] + C.indices[kc] = j1 + ka += 1 + kc += 1 + elif j1 > j2: + C.data[kc] = Bdata[kb] + C.indices[kc] = j2 + kb += 1 + kc += 1 + + C.indptr[ii+1] = kc + return kc + + + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_mult(object A, object B, int sorted = 1): + + cdef complex [::1] dataA = A.data + cdef int[::1] indsA = A.indices + cdef int[::1] indptrA = A.indptr + cdef int Annz = A.nnz + + cdef complex [::1] dataB = B.data + cdef int[::1] indsB = B.indices + cdef int[::1] indptrB = B.indptr + cdef int Bnnz = B.nnz + + cdef int nrows = A.shape[0] + cdef int ncols = B.shape[1] + + #Both matrices are zero mats + if Annz == 0 or Bnnz == 0: + return fast_csr_matrix(shape=(nrows,ncols)) + + cdef int nnz + cdef CSR_Matrix out + + nnz = _zcsr_mult_pass1(&dataA[0], &indsA[0], &indptrA[0], + &dataB[0], &indsB[0], &indptrB[0], + nrows, ncols) + + if nnz == 0: + return fast_csr_matrix(shape=(nrows,ncols)) + + init_CSR(&out, nnz, nrows, ncols) + _zcsr_mult_pass2(&dataA[0], &indsA[0], &indptrA[0], + &dataB[0], &indsB[0], &indptrB[0], + &out, + nrows, ncols) + + #Shorten data and indices if needed + if out.nnz > out.indptr[out.nrows]: + shorten_CSR(&out, out.indptr[out.nrows]) + + if sorted: + sort_indices(&out) + return CSR_to_scipy(&out) + + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _zcsr_mult(CSR_Matrix * A, CSR_Matrix * B, CSR_Matrix * C): + + nnz = _zcsr_mult_pass1(A.data, A.indices, A.indptr, + B.data, B.indices, B.indptr, + A.nrows, B.ncols) + + init_CSR(C, nnz, A.nrows, B.ncols) + _zcsr_mult_pass2(A.data, A.indices, A.indptr, + B.data, B.indices, B.indptr, + C, + A.nrows, B.ncols) + + #Shorten data and indices if needed + if C.nnz > C.indptr[C.nrows]: + shorten_CSR(C, C.indptr[C.nrows]) + sort_indices(C) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef int _zcsr_mult_pass1(double complex * Adata, int * Aind, int * Aptr, + double complex * Bdata, int * Bind, int * Bptr, + int nrows, int ncols) nogil: + + cdef int j, k, nnz = 0 + cdef size_t ii,jj,kk + #Setup mask array + cdef int * mask = PyDataMem_NEW(ncols*sizeof(int)) + for ii in range(ncols): + mask[ii] = -1 + #Pass 1 + for ii in range(nrows): + for jj in range(Aptr[ii], Aptr[ii+1]): + j = Aind[jj] + for kk in range(Bptr[j], Bptr[j+1]): + k = Bind[kk] + if mask[k] != ii: + mask[k] = ii + nnz += 1 + PyDataMem_FREE(mask) + return nnz + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _zcsr_mult_pass2(double complex * Adata, int * Aind, int * Aptr, + double complex * Bdata, int * Bind, int * Bptr, + CSR_Matrix * C, + int nrows, int ncols) nogil: + + cdef int head, length, temp, j, k, nnz = 0 + cdef size_t ii,jj,kk + cdef double complex val + cdef double complex * sums = PyDataMem_NEW_ZEROED(ncols, sizeof(double complex)) + cdef int * nxt = PyDataMem_NEW(ncols*sizeof(int)) + for ii in range(ncols): + nxt[ii] = -1 + + C.indptr[0] = 0 + for ii in range(nrows): + head = -2 + length = 0 + for jj in range(Aptr[ii], Aptr[ii+1]): + j = Aind[jj] + val = Adata[jj] + for kk in range(Bptr[j], Bptr[j+1]): + k = Bind[kk] + sums[k] += val*Bdata[kk] + if nxt[k] == -1: + nxt[k] = head + head = k + length += 1 + + for jj in range(length): + if sums[head] != 0: + C.indices[nnz] = head + C.data[nnz] = sums[head] + nnz += 1 + temp = head + head = nxt[head] + nxt[temp] = -1 + sums[temp] = 0 + + C.indptr[ii+1] = nnz + + #Free temp arrays + PyDataMem_FREE(sums) + PyDataMem_FREE(nxt) + + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_kron(object A, object B): + """ + Computes the kronecker product between two complex + sparse matrices in CSR format. + """ + cdef complex[::1] dataA = A.data + cdef int[::1] indsA = A.indices + cdef int[::1] indptrA = A.indptr + cdef int rowsA = A.shape[0] + cdef int colsA = A.shape[1] + + cdef complex[::1] dataB = B.data + cdef int[::1] indsB = B.indices + cdef int[::1] indptrB = B.indptr + cdef int rowsB = B.shape[0] + cdef int colsB = B.shape[1] + + cdef int out_nnz = _safe_multiply(dataA.shape[0], dataB.shape[0]) + cdef int rows_out = rowsA * rowsB + cdef int cols_out = colsA * colsB + + cdef CSR_Matrix out + init_CSR(&out, out_nnz, rows_out, cols_out) + + _zcsr_kron_core(&dataA[0], &indsA[0], &indptrA[0], + &dataB[0], &indsB[0], &indptrB[0], + &out, + rowsA, rowsB, colsB) + return CSR_to_scipy(&out) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _zcsr_kron(CSR_Matrix * A, CSR_Matrix * B, CSR_Matrix * C): + """ + Computes the kronecker product between two complex + sparse matrices in CSR format. + """ + + cdef int out_nnz = _safe_multiply(A.nnz, B.nnz) + cdef int rows_out = A.nrows * B.nrows + cdef int cols_out = A.ncols * B.ncols + + init_CSR(C, out_nnz, rows_out, cols_out) + + _zcsr_kron_core(A.data, A.indices, A.indptr, + B.data, B.indices, B.indptr, + C, + A.nrows, B.nrows, B.ncols) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _zcsr_kron_core(double complex * dataA, int * indsA, int * indptrA, + double complex * dataB, int * indsB, int * indptrB, + CSR_Matrix * out, + int rowsA, int rowsB, int colsB) nogil: + cdef size_t ii, jj, ptrA, ptr + cdef int row = 0 + cdef int ptr_start, ptr_end + cdef int row_startA, row_endA, row_startB, row_endB, distA, distB, ptrB + + for ii in range(rowsA): + row_startA = indptrA[ii] + row_endA = indptrA[ii+1] + distA = row_endA - row_startA + + for jj in range(rowsB): + row_startB = indptrB[jj] + row_endB = indptrB[jj+1] + distB = row_endB - row_startB + + ptr_start = out.indptr[row] + ptr_end = ptr_start + distB + + out.indptr[row+1] = out.indptr[row] + distA * distB + row += 1 + + for ptrA in range(row_startA, row_endA): + ptrB = row_startB + for ptr in range(ptr_start, ptr_end): + out.indices[ptr] = indsA[ptrA] * colsB + indsB[ptrB] + out.data[ptr] = dataA[ptrA] * dataB[ptrB] + ptrB += 1 + + ptr_start += distB + ptr_end += distB + + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_transpose(object A): + """ + Transpose of a sparse matrix in CSR format. + """ + cdef complex[::1] data = A.data + cdef int[::1] ind = A.indices + cdef int[::1] ptr = A.indptr + cdef int nrows = A.shape[0] + cdef int ncols = A.shape[1] + + cdef CSR_Matrix out + init_CSR(&out, data.shape[0], ncols, nrows) + + _zcsr_trans_core(&data[0], &ind[0], &ptr[0], + &out, nrows, ncols) + return CSR_to_scipy(&out) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _zcsr_transpose(CSR_Matrix * A, CSR_Matrix * B): + """ + Transpose of a sparse matrix in CSR format. + """ + init_CSR(B, A.nnz, A.ncols, A.nrows) + + _zcsr_trans_core(A.data, A.indices, A.indptr, B, A.nrows, A.ncols) + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _zcsr_trans_core(double complex * data, int * ind, int * ptr, + CSR_Matrix * out, + int nrows, int ncols) nogil: + + cdef int k, nxt + cdef size_t ii, jj + + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii+1]): + k = ind[jj] + 1 + out.indptr[k] += 1 + + for ii in range(ncols): + out.indptr[ii+1] += out.indptr[ii] + + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii+1]): + k = ind[jj] + nxt = out.indptr[k] + out.data[nxt] = data[jj] + out.indices[nxt] = ii + out.indptr[k] = nxt + 1 + + for ii in range(ncols,0,-1): + out.indptr[ii] = out.indptr[ii-1] + + out.indptr[0] = 0 + + + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_adjoint(object A): + """ + Adjoint of a sparse matrix in CSR format. + """ + cdef complex[::1] data = A.data + cdef int[::1] ind = A.indices + cdef int[::1] ptr = A.indptr + cdef int nrows = A.shape[0] + cdef int ncols = A.shape[1] + + cdef CSR_Matrix out + init_CSR(&out, data.shape[0], ncols, nrows) + + _zcsr_adjoint_core(&data[0], &ind[0], &ptr[0], + &out, nrows, ncols) + return CSR_to_scipy(&out) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _zcsr_adjoint(CSR_Matrix * A, CSR_Matrix * B): + """ + Adjoint of a sparse matrix in CSR format. + """ + init_CSR(B, A.nnz, A.ncols, A.nrows) + + _zcsr_adjoint_core(A.data, A.indices, A.indptr, + B, A.nrows, A.ncols) + + +@cython.boundscheck(False) +@cython.wraparound(False) +cdef void _zcsr_adjoint_core(double complex * data, int * ind, int * ptr, + CSR_Matrix * out, + int nrows, int ncols) nogil: + + cdef int k, nxt + cdef size_t ii, jj + + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii+1]): + k = ind[jj] + 1 + out.indptr[k] += 1 + + for ii in range(ncols): + out.indptr[ii+1] += out.indptr[ii] + + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii+1]): + k = ind[jj] + nxt = out.indptr[k] + out.data[nxt] = conj(data[jj]) + out.indices[nxt] = ii + out.indptr[k] = nxt + 1 + + for ii in range(ncols,0,-1): + out.indptr[ii] = out.indptr[ii-1] + + out.indptr[0] = 0 + + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_isherm(object A not None, double tol = 1e-12): + """ + Determines if a given input sparse CSR matrix is Hermitian + to within a specified floating-point tolerance. + + Parameters + ---------- + A : csr_matrix + Input sparse matrix. + tol : float (default is atol from settings) + Desired tolerance value. + + Returns + ------- + isherm : int + One if matrix is Hermitian, zero otherwise. + + Notes + ----- + This implimentation is esentially an adjoint calulation + where the data and indices are not stored, but checked + elementwise to see if they match those of the input matrix. + Thus we do not need to build the actual adjoint. Here we + only need a temp array of output indptr. + """ + cdef complex[::1] data = A.data + cdef int[::1] ind = A.indices + cdef int[::1] ptr = A.indptr + cdef int nrows = A.shape[0] + cdef int ncols = A.shape[1] + + cdef int k, nxt, isherm = 1 + cdef size_t ii, jj + cdef complex tmp, tmp2 + + if nrows != ncols: + return 0 + + cdef int * out_ptr = PyDataMem_NEW_ZEROED(ncols+1, sizeof(int)) + + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii+1]): + k = ind[jj] + 1 + out_ptr[k] += 1 + + for ii in range(nrows): + out_ptr[ii+1] += out_ptr[ii] + + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii+1]): + k = ind[jj] + nxt = out_ptr[k] + out_ptr[k] += 1 + #structure test + if ind[nxt] != ii: + isherm = 0 + break + tmp = conj(data[jj]) + tmp2 = data[nxt] + #data test + if abs(tmp-tmp2) > tol: + isherm = 0 + break + else: + continue + break + + PyDataMem_FREE(out_ptr) + return isherm + +@cython.overflowcheck(True) +cdef _safe_multiply(int A, int B): + """ + Computes A*B and checks for overflow. + """ + cdef int C = A*B + return C + + + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_trace(object A, bool isherm): + cdef complex[::1] data = A.data + cdef int[::1] ind = A.indices + cdef int[::1] ptr = A.indptr + cdef int nrows = ptr.shape[0]-1 + cdef size_t ii, jj + cdef complex tr = 0 + + for ii in range(nrows): + for jj in range(ptr[ii], ptr[ii+1]): + if ind[jj] == ii: + tr += data[jj] + break + if imag(tr) == 0 or isherm: + return real(tr) + else: + return tr + + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_proj(object A, bool is_ket=1): + """ + Computes the projection operator + from a given ket or bra vector + in CSR format. The flag 'is_ket' + is True if passed a ket. + + This is ~3x faster than doing the + conjugate transpose and sparse multiplication + directly. Also, does not need a temp matrix. + """ + cdef complex[::1] data = A.data + cdef int[::1] ind = A.indices + cdef int[::1] ptr = A.indptr + cdef int nrows + cdef int nnz + + cdef int offset = 0, new_idx, count, change_idx + cdef size_t jj, kk + + if is_ket: + nrows = A.shape[0] + nnz = ptr[nrows] + else: + nrows = A.shape[1] + nnz = ptr[1] + + cdef CSR_Matrix out + init_CSR(&out, nnz**2, nrows) + + if is_ket: + #Compute new ptrs and inds + for jj in range(nrows): + out.indptr[jj] = ptr[jj]*nnz + if ptr[jj+1] != ptr[jj]: + new_idx = jj + for kk in range(nnz): + out.indices[offset+kk*nnz] = new_idx + offset += 1 + #set nnz in new ptr + out.indptr[nrows] = nnz**2 + + #Compute the data + for jj in range(nnz): + for kk in range(nnz): + out.data[jj*nnz+kk] = data[jj]*conj(data[kk]) + + else: + count = nnz**2 + new_idx = nrows + for kk in range(nnz-1,-1,-1): + for jj in range(nnz-1,-1,-1): + out.indices[offset+jj] = ind[jj] + out.data[kk*nnz+jj] = conj(data[kk])*data[jj] + offset += nnz + change_idx = ind[kk] + while new_idx > change_idx: + out.indptr[new_idx] = count + new_idx -= 1 + count -= nnz + + + return CSR_to_scipy(&out) + + + +@cython.boundscheck(False) +@cython.wraparound(False) +def zcsr_inner(object A, object B, bool bra_ket): + """ + Computes the inner-product between ket-ket, + or bra-ket vectors in sparse CSR format. + """ + cdef complex[::1] a_data = A.data + cdef int[::1] a_ind = A.indices + cdef int[::1] a_ptr = A.indptr + + cdef complex[::1] b_data = B.data + cdef int[::1] b_ind = B.indices + cdef int[::1] b_ptr = B.indptr + cdef int nrows = B.shape[0] + + cdef double complex inner = 0 + cdef size_t jj, kk + cdef int a_idx, b_idx + + if bra_ket: + for kk in range(a_ind.shape[0]): + a_idx = a_ind[kk] + for jj in range(nrows): + if (b_ptr[jj+1]-b_ptr[jj]) != 0: + if jj == a_idx: + inner += a_data[kk]*b_data[b_ptr[jj]] + break + else: + for kk in range(nrows): + a_idx = a_ptr[kk] + b_idx = b_ptr[kk] + if (a_ptr[kk+1]-a_idx) != 0: + if (b_ptr[kk+1]-b_idx) != 0: + inner += conj(a_data[a_idx])*b_data[b_idx] + + return inner diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/src/zspmv.cpp b/qiskit/providers/aer/openpulse/qutip_lite/cy/src/zspmv.cpp new file mode 100755 index 0000000000..bf84d7ed72 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/src/zspmv.cpp @@ -0,0 +1,172 @@ +// This file is part of QuTiP: Quantum Toolbox in Python. +// +// Copyright (c) 2011 and later, QuSTaR. +// All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// 1. Redistributions of source code must retain the above copyright notice, +// this list of conditions and the following disclaimer. +// +// 2. Redistributions in binary form must reproduce the above copyright +// notice, this list of conditions and the following disclaimer in the +// documentation and/or other materials provided with the distribution. +// +// 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +// of its contributors may be used to endorse or promote products derived +// from this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +// PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +//############################################################################# +#include + +#if defined(__GNUC__) && defined(__SSE3__) // Using GCC or CLANG and SSE3 +#include +void zspmvpy(const std::complex * __restrict__ data, const int * __restrict__ ind, + const int * __restrict__ ptr, + const std::complex * __restrict__ vec, const std::complex a, + std::complex * __restrict__ out, const unsigned int nrows) +{ + size_t row, jj; + unsigned int row_start, row_end; + __m128d num1, num2, num3, num4; + for (row=0; row < nrows; row++) + { + num4 = _mm_setzero_pd(); + row_start = ptr[row]; + row_end = ptr[row+1]; + for (jj=row_start; jj (data[jj])[0]); + num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]])); + num3 = _mm_mul_pd(num2, num1); + num1 = _mm_loaddup_pd(&reinterpret_cast(data[jj])[1]); + num2 = _mm_shuffle_pd(num2, num2, 1); + num2 = _mm_mul_pd(num2, num1); + num3 = _mm_addsub_pd(num3, num2); + num4 = _mm_add_pd(num3, num4); + } + num1 = _mm_loaddup_pd(&reinterpret_cast(a)[0]); + num3 = _mm_mul_pd(num4, num1); + num1 = _mm_loaddup_pd(&reinterpret_cast(a)[1]); + num4 = _mm_shuffle_pd(num4, num4, 1); + num4 = _mm_mul_pd(num4, num1); + num3 = _mm_addsub_pd(num3, num4); + num2 = _mm_loadu_pd((double *)&out[row]); + num3 = _mm_add_pd(num2, num3); + _mm_storeu_pd((double *)&out[row], num3); + } +} +#elif defined(__GNUC__) // Using GCC or CLANG but no SSE3 +void zspmvpy(const std::complex * __restrict__ data, const int * __restrict__ ind, + const int * __restrict__ ptr, + const std::complex * __restrict__ vec, const std::complex a, + std::complex * __restrict__ out, const unsigned int nrows) +{ + size_t row, jj; + unsigned int row_start, row_end; + std::complex dot; + for (row=0; row < nrows; row++) + { + dot = 0; + row_start = ptr[row]; + row_end = ptr[row+1]; + for (jj=row_start; jj +void zspmvpy(const std::complex * __restrict data, const int * __restrict ind, + const int * __restrict ptr, + const std::complex * __restrict vec, const std::complex a, + std::complex * __restrict out, const unsigned int nrows) +{ + size_t row, jj; + unsigned int row_start, row_end; + __m128d num1, num2, num3, num4; + for (row=0; row < nrows; row++) + { + num4 = _mm_setzero_pd(); + row_start = ptr[row]; + row_end = ptr[row+1]; + for (jj=row_start; jj (data[jj])[0]); + num2 = _mm_set_pd(std::imag(vec[ind[jj]]),std::real(vec[ind[jj]])); + num3 = _mm_mul_pd(num2, num1); + num1 = _mm_loaddup_pd(&reinterpret_cast(data[jj])[1]); + num2 = _mm_shuffle_pd(num2, num2, 1); + num2 = _mm_mul_pd(num2, num1); + num3 = _mm_addsub_pd(num3, num2); + num4 = _mm_add_pd(num3, num4); + } + num1 = _mm_loaddup_pd(&reinterpret_cast(a)[0]); + num3 = _mm_mul_pd(num4, num1); + num1 = _mm_loaddup_pd(&reinterpret_cast(a)[1]); + num4 = _mm_shuffle_pd(num4, num4, 1); + num4 = _mm_mul_pd(num4, num1); + num3 = _mm_addsub_pd(num3, num4); + num2 = _mm_loadu_pd((double *)&out[row]); + num3 = _mm_add_pd(num2, num3); + _mm_storeu_pd((double *)&out[row], num3); + } +} +#elif defined(_MSC_VER) // Visual Studio no AVX +void zspmvpy(const std::complex * __restrict data, const int * __restrict ind, + const int * __restrict ptr, + const std::complex * __restrict vec, const std::complex a, + std::complex * __restrict out, const unsigned int nrows) +{ + size_t row, jj; + unsigned int row_start, row_end; + std::complex dot; + for (row=0; row < nrows; row++) + { + dot = 0; + row_start = ptr[row]; + row_end = ptr[row+1]; + for (jj=row_start; jj * data, const int * ind, + const int * ptr, + const std::complex * vec, const std::complex a, + std::complex * out, const unsigned int nrows) +{ + size_t row, jj; + unsigned int row_start, row_end; + std::complex dot; + for (row=0; row < nrows; row++) + { + dot = 0; + row_start = ptr[row]; + row_end = ptr[row+1]; + for (jj=row_start; jj + +#ifdef __GNUC__ +void zspmvpy(const std::complex * __restrict__ data, const int * __restrict__ ind, + const int *__restrict__ ptr, + const std::complex * __restrict__ vec, const std::complex a, + std::complex * __restrict__ out, + const unsigned int nrows); +#elif defined(_MSC_VER) +void zspmvpy(const std::complex * __restrict data, const int * __restrict ind, + const int *__restrict ptr, + const std::complex * __restrict vec, const std::complex a, + std::complex * __restrict out, + const unsigned int nrows); +#else +void zspmvpy(const std::complex * data, const int * ind, + const int * ptr, + const std::complex * vec, const std::complex a, + std::complex * out, + const unsigned int nrows); +#endif \ No newline at end of file diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/utilities.py b/qiskit/providers/aer/openpulse/qutip_lite/cy/utilities.py new file mode 100755 index 0000000000..f79772eaa5 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/utilities.py @@ -0,0 +1,67 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +import os + +def _cython_build_cleanup(tdname, build_dir=None): + if build_dir is None: + build_dir = os.path.join(os.path.expanduser('~'), '.pyxbld') + + # Remove tdname.pyx + pyx_file = tdname + ".pyx" + try: + os.remove(pyx_file) + except: + pass + + # Remove temp build files + for dirpath, subdirs, files in os.walk(build_dir): + for f in files: + if f.startswith(tdname): + try: + os.remove(os.path.join(dirpath,f)) + except: + pass diff --git a/qiskit/providers/aer/openpulse/qutip_lite/dimensions.py b/qiskit/providers/aer/openpulse/qutip_lite/dimensions.py new file mode 100755 index 0000000000..394ee124a3 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/dimensions.py @@ -0,0 +1,199 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +# pylint: disable=invalid-name +""" +Internal use module for manipulating dims specifications. +""" + +__all__ = [] # Everything should be explicitly imported, not made available + # by default. + +import numpy as np + +def flatten(l): + """Flattens a list of lists to the first level. + + Given a list containing a mix of scalars and lists, + flattens down to a list of the scalars within the original + list. + + Args: + l (list): Input list + + Returns: + list: Flattened list. + + """ + if not isinstance(l, list): + return [l] + else: + return sum(map(flatten, l), []) + +def is_scalar(dims): + """ + Returns True if a dims specification is effectively + a scalar (has dimension 1). + """ + return np.prod(flatten(dims)) == 1 + +def is_vector(dims): + """Is a vector""" + return ( + isinstance(dims, list) and + isinstance(dims[0], (int, np.integer)) + ) + +def is_vectorized_oper(dims): + """Is a vectorized operator.""" + return ( + isinstance(dims, list) and + isinstance(dims[0], list) + ) + + +def type_from_dims(dims, enforce_square=True): + """Get the type of operator from dims structure""" + bra_like, ket_like = map(is_scalar, dims) + + if bra_like: + if is_vector(dims[1]): + return 'bra' + elif is_vectorized_oper(dims[1]): + return 'operator-bra' + + if ket_like: + if is_vector(dims[0]): + return 'ket' + elif is_vectorized_oper(dims[0]): + return 'operator-ket' + + elif is_vector(dims[0]) and (dims[0] == dims[1] or not enforce_square): + return 'oper' + + elif ( + is_vectorized_oper(dims[0]) and + ( + ( + dims[0] == dims[1] and + dims[0][0] == dims[1][0] + ) or not enforce_square + ) + ): + return 'super' + + return 'other' + + +def _enumerate_flat(l, idx=0): + if not isinstance(l, list): + # Found a scalar, so return and increment. + return idx, idx + 1 + else: + # Found a list, so append all the scalars + # from it and recurse to keep the increment + # correct. + acc = [] + for elem in l: + labels, idx = _enumerate_flat(elem, idx) + acc.append(labels) + return acc, idx + +def _collapse_composite_index(dims): + """ + Given the dimensions specification for a composite index + (e.g.: [2, 3] for the right index of a ket with dims [[1], [2, 3]]), + returns a dimensions specification for an index of the same shape, + but collapsed to a single "leg." In the previous example, [2, 3] + would collapse to [6]. + """ + return [np.prod(dims)] + +def _collapse_dims_to_level(dims, level=1): + """ + Recursively collapses all indices in a dimensions specification + appearing at a given level, such that the returned dimensions + specification does not represent any composite systems. + """ + if level == 0: + return _collapse_composite_index(dims) + else: + return [_collapse_dims_to_level(index, level=level - 1) for index in dims] + +def collapse_dims_super(dims): + """ + Given the dimensions specifications for an operator-ket-, operator-bra- or + super-type Qobj, returns a dimensions specification describing the same shape + by collapsing all composite systems. For instance, the super-type + dimensions specification ``[[[2, 3], [2, 3]], [[2, 3], [2, 3]]]`` collapses to + ``[[[6], [6]], [[6], [6]]]``. + + Args: + dims (list): Dimensions specifications to be collapsed. + + Returns: + list: Collapsed dimensions specification describing the same shape + such that ``len(collapsed_dims[i][j]) == 1`` for ``i`` and ``j`` + in ``range(2)``. + """ + return _collapse_dims_to_level(dims, 2) + + +def enumerate_flat(l): + """Labels the indices at which scalars occur in a flattened list. + + Given a list containing a mix of scalars and lists, + returns a list of the same structure, where each scalar + has been replaced by an index into the flattened list. + + Examples + -------- + + >>> print(enumerate_flat([[[10], [20, 30]], 40])) + [[[0], [1, 2]], 3] + + """ + return _enumerate_flat(l)[0] diff --git a/qiskit/providers/aer/openpulse/qutip_lite/expect.py b/qiskit/providers/aer/openpulse/qutip_lite/expect.py new file mode 100755 index 0000000000..edaeba7be1 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/expect.py @@ -0,0 +1,143 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +# pylint: disable=invalid-name + +""" +Module for expectation values. +""" + +__all__ = ['expect', 'variance'] + +import numpy as np +from .qobj import Qobj +# pylint: disable=import-error, no-name-in-module +from .cy.spmatfuncs import (cy_expect_rho_vec, cy_expect_psi, cy_spmm_tr, + expect_csr_ket) + +expect_rho_vec = cy_expect_rho_vec +expect_psi = cy_expect_psi + + +def expect(oper, state): + """Calculates the expectation value for operator(s) and state(s). + + Args: + oper (Qobj or list): A single or a `list` or operators + for expectation value. + + state (Qobj or list): A single or a `list` of quantum states + or density matrices. + + Returns: + real or complex or ndarray: Expectation value. ``real`` if `oper` is + Hermitian, ``complex`` otherwise. A (nested) + array of expectaction values of state or + operator are arrays. + + Raises: + TypeError: Inputs are not quantum objects. + """ + if isinstance(state, Qobj) and isinstance(oper, Qobj): + return _single_qobj_expect(oper, state) + + elif isinstance(oper, (list, np.ndarray)): + if isinstance(state, Qobj): + if (all([op.isherm for op in oper]) and + (state.isket or state.isherm)): + return np.array([_single_qobj_expect(o, state) for o in oper]) + else: + return np.array([_single_qobj_expect(o, state) for o in oper], + dtype=complex) + else: + return [expect(o, state) for o in oper] + + elif isinstance(state, (list, np.ndarray)): + if oper.isherm and all([(op.isherm or op.type == 'ket') + for op in state]): + return np.array([_single_qobj_expect(oper, x) for x in state]) + else: + return np.array([_single_qobj_expect(oper, x) for x in state], + dtype=complex) + else: + raise TypeError('Arguments must be quantum objects') + +# pylint: disable=inconsistent-return-statements +def _single_qobj_expect(oper, state): + """ + Private function used by expect to calculate expectation values of Qobjs. + """ + if oper.isoper: + if oper.dims[1] != state.dims[0]: + raise Exception('Operator and state do not have same tensor ' + + 'structure: %s and %s' % + (oper.dims[1], state.dims[0])) + + if state.type == 'oper': + # calculates expectation value via TR(op*rho) + return cy_spmm_tr(oper.data, state.data, + oper.isherm and state.isherm) + + elif state.type == 'ket': + # calculates expectation value via + return expect_csr_ket(oper.data, state.data, + oper.isherm) + else: + raise TypeError('Invalid operand types') + + +def variance(oper, state): + """ + Variance of an operator for the given state vector or density matrix. + + Args: + oper (qobj.Qobj): Operator for expectation value. + state (qobj.Qobj or list): A single or `list` of quantum states or density matrices.. + + Returns: + float: Variance of operator 'oper' for given state. + """ + return expect(oper ** 2, state) - expect(oper, state) ** 2 diff --git a/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py b/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py new file mode 100755 index 0000000000..353111401f --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py @@ -0,0 +1,435 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, The QuTiP Project. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +# pylint: disable=invalid-name + +""" +Module for fast versions of SciPy sparse CSR matrices +""" + +import operator +from warnings import warn +import numpy as np +from scipy.sparse import (_sparsetools, isspmatrix, csr_matrix, dia_matrix) +from scipy.sparse.sputils import (upcast, isdense, isscalarlike, get_index_dtype) +from scipy.sparse.base import SparseEfficiencyWarning + +class fast_csr_matrix(csr_matrix): + """ + A subclass of scipy.sparse.csr_matrix that skips the data format + checks that are run everytime a new csr_matrix is created. + """ + # pylint: disable=super-init-not-called + def __init__(self, args=None, shape=None, dtype=None, copy=False): + if args is None: #Build zero matrix + if shape is None: + raise Exception('Shape must be given when building zero matrix.') + self.data = np.array([], dtype=complex) + self.indices = np.array([], dtype=np.int32) + self.indptr = np.zeros(shape[0]+1, dtype=np.int32) + self._shape = tuple(int(s) for s in shape) + + else: + if args[0].shape[0] and args[0].dtype != complex: + raise TypeError('fast_csr_matrix allows only complex data.') + if args[1].shape[0] and args[1].dtype != np.int32: + raise TypeError('fast_csr_matrix allows only int32 indices.') + if args[2].shape[0] and args[1].dtype != np.int32: + raise TypeError('fast_csr_matrix allows only int32 indptr.') + self.data = np.array(args[0], dtype=complex, copy=copy) + self.indices = np.array(args[1], dtype=np.int32, copy=copy) + self.indptr = np.array(args[2], dtype=np.int32, copy=copy) + if shape is None: + self._shape = tuple([len(self.indptr)-1]*2) + else: + self._shape = tuple(int(s) for s in shape) + self.dtype = complex + self.maxprint = 50 + self.format = 'csr' + + def _binopt(self, other, op): + """ + Do the binary operation fn to two sparse matrices using + fast_csr_matrix only when other is also a fast_csr_matrix. + """ + # e.g. csr_plus_csr, csr_minus_csr, etc. + if not isinstance(other, fast_csr_matrix): + other = csr_matrix(other) + # e.g. csr_plus_csr, csr_minus_csr, etc. + fn = getattr(_sparsetools, self.format + op + self.format) + + maxnnz = self.nnz + other.nnz + idx_dtype = get_index_dtype((self.indptr, self.indices, + other.indptr, other.indices), + maxval=maxnnz) + indptr = np.empty(self.indptr.shape, dtype=idx_dtype) + indices = np.empty(maxnnz, dtype=idx_dtype) + + bool_ops = ['_ne_', '_lt_', '_gt_', '_le_', '_ge_'] + if op in bool_ops: + data = np.empty(maxnnz, dtype=np.bool_) + else: + data = np.empty(maxnnz, dtype=upcast(self.dtype, other.dtype)) + + fn(self.shape[0], self.shape[1], + np.asarray(self.indptr, dtype=idx_dtype), + np.asarray(self.indices, dtype=idx_dtype), + self.data, + np.asarray(other.indptr, dtype=idx_dtype), + np.asarray(other.indices, dtype=idx_dtype), + other.data, + indptr, indices, data) + + actual_nnz = indptr[-1] + indices = indices[:actual_nnz] + data = data[:actual_nnz] + if actual_nnz < maxnnz // 2: + # too much waste, trim arrays + indices = indices.copy() + data = data.copy() + if isinstance(other, fast_csr_matrix) and (not op in bool_ops): + A = fast_csr_matrix((data, indices, indptr), dtype=data.dtype, shape=self.shape) + else: + A = csr_matrix((data, indices, indptr), dtype=data.dtype, shape=self.shape) + return A + + def multiply(self, other): + """Point-wise multiplication by another matrix, vector, or + scalar. + """ + # Scalar multiplication. + if isscalarlike(other): + return self._mul_scalar(other) + # Sparse matrix or vector. + if isspmatrix(other): + if self.shape == other.shape: + if not isinstance(other, fast_csr_matrix): + other = csr_matrix(other) + return self._binopt(other, '_elmul_') + # Single element. + elif other.shape == (1, 1): + return self._mul_scalar(other.toarray()[0, 0]) + elif self.shape == (1, 1): + return other._mul_scalar(self.toarray()[0, 0]) + # A row times a column. + elif self.shape[1] == other.shape[0] and self.shape[1] == 1: + return self._mul_sparse_matrix(other.tocsc()) + elif self.shape[0] == other.shape[1] and self.shape[0] == 1: + return other._mul_sparse_matrix(self.tocsc()) + # Row vector times matrix. other is a row. + elif other.shape[0] == 1 and self.shape[1] == other.shape[1]: + other = dia_matrix((other.toarray().ravel(), [0]), + shape=(other.shape[1], other.shape[1])) + return self._mul_sparse_matrix(other) + # self is a row. + elif self.shape[0] == 1 and self.shape[1] == other.shape[1]: + copy = dia_matrix((self.toarray().ravel(), [0]), + shape=(self.shape[1], self.shape[1])) + return other._mul_sparse_matrix(copy) + # Column vector times matrix. other is a column. + elif other.shape[1] == 1 and self.shape[0] == other.shape[0]: + other = dia_matrix((other.toarray().ravel(), [0]), + shape=(other.shape[0], other.shape[0])) + return other._mul_sparse_matrix(self) + # self is a column. + elif self.shape[1] == 1 and self.shape[0] == other.shape[0]: + copy = dia_matrix((self.toarray().ravel(), [0]), + shape=(self.shape[0], self.shape[0])) + return copy._mul_sparse_matrix(other) + else: + raise ValueError("inconsistent shapes") + # Dense matrix. + if isdense(other): + if self.shape == other.shape: + ret = self.tocoo() + ret.data = np.multiply(ret.data, other[ret.row, ret.col] + ).view(np.ndarray).ravel() + return ret + # Single element. + elif other.size == 1: + return self._mul_scalar(other.flat[0]) + # Anything else. + return np.multiply(self.todense(), other) + + def _mul_sparse_matrix(self, other): + """ + Do the sparse matrix mult returning fast_csr_matrix only + when other is also fast_csr_matrix. + """ + M, _ = self.shape + _, N = other.shape + + major_axis = self._swap((M, N))[0] + if isinstance(other, fast_csr_matrix): + A = zcsr_mult(self, other, sorted=1) + return A + + other = csr_matrix(other) # convert to this format + idx_dtype = get_index_dtype((self.indptr, self.indices, + other.indptr, other.indices), + maxval=M*N) + indptr = np.empty(major_axis + 1, dtype=idx_dtype) + + fn = getattr(_sparsetools, self.format + '_matmat_pass1') + fn(M, N, + np.asarray(self.indptr, dtype=idx_dtype), + np.asarray(self.indices, dtype=idx_dtype), + np.asarray(other.indptr, dtype=idx_dtype), + np.asarray(other.indices, dtype=idx_dtype), + indptr) + + nnz = indptr[-1] + idx_dtype = get_index_dtype((self.indptr, self.indices, + other.indptr, other.indices), + maxval=nnz) + indptr = np.asarray(indptr, dtype=idx_dtype) + indices = np.empty(nnz, dtype=idx_dtype) + data = np.empty(nnz, dtype=upcast(self.dtype, other.dtype)) + + fn = getattr(_sparsetools, self.format + '_matmat_pass2') + fn(M, N, np.asarray(self.indptr, dtype=idx_dtype), + np.asarray(self.indices, dtype=idx_dtype), + self.data, + np.asarray(other.indptr, dtype=idx_dtype), + np.asarray(other.indices, dtype=idx_dtype), + other.data, + indptr, indices, data) + A = csr_matrix((data, indices, indptr), shape=(M, N)) + return A + + def _scalar_binopt(self, other, op): + """Scalar version of self._binopt, for cases in which no new nonzeros + are added. Produces a new spmatrix in canonical form. + """ + self.sum_duplicates() + res = self._with_data(op(self.data, other), copy=True) + res.eliminate_zeros() + return res + + def __eq__(self, other): + # Scalar other. + if isscalarlike(other): + if np.isnan(other): + return csr_matrix(self.shape, dtype=np.bool_) + + if other == 0: + warn("Comparing a sparse matrix with 0 using == is inefficient" + ", try using != instead.", SparseEfficiencyWarning) + all_true = _all_true(self.shape) + inv = self._scalar_binopt(other, operator.ne) + return all_true - inv + else: + return self._scalar_binopt(other, operator.eq) + # Dense other. + elif isdense(other): + return self.todense() == other + # Sparse other. + elif isspmatrix(other): + warn("Comparing sparse matrices using == is inefficient, try using" + " != instead.", SparseEfficiencyWarning) + #TODO sparse broadcasting + if self.shape != other.shape: + return False + elif self.format != other.format: + other = other.asformat(self.format) + res = self._binopt(other, '_ne_') + all_true = _all_true(self.shape) + return all_true - res + else: + return False + + def __ne__(self, other): + # Scalar other. + if isscalarlike(other): + if np.isnan(other): + warn("Comparing a sparse matrix with nan using != is inefficient", + SparseEfficiencyWarning) + all_true = _all_true(self.shape) + return all_true + elif other != 0: + warn("Comparing a sparse matrix with a nonzero scalar using !=" + " is inefficient, try using == instead.", SparseEfficiencyWarning) + all_true = _all_true(self.shape) + inv = self._scalar_binopt(other, operator.eq) + return all_true - inv + else: + return self._scalar_binopt(other, operator.ne) + # Dense other. + elif isdense(other): + return self.todense() != other + # Sparse other. + elif isspmatrix(other): + #TODO sparse broadcasting + if self.shape != other.shape: + return True + elif self.format != other.format: + other = other.asformat(self.format) + return self._binopt(other, '_ne_') + else: + return True + + def _inequality(self, other, op, op_name, bad_scalar_msg): + # Scalar other. + if isscalarlike(other): + if other == 0 and op_name in ('_le_', '_ge_'): + raise NotImplementedError(" >= and <= don't work with 0.") + elif op(0, other): + warn(bad_scalar_msg, SparseEfficiencyWarning) + other_arr = np.empty(self.shape, dtype=np.result_type(other)) + other_arr.fill(other) + other_arr = csr_matrix(other_arr) + return self._binopt(other_arr, op_name) + else: + return self._scalar_binopt(other, op) + # Dense other. + elif isdense(other): + return op(self.todense(), other) + # Sparse other. + elif isspmatrix(other): + #TODO sparse broadcasting + if self.shape != other.shape: + raise ValueError("inconsistent shapes") + elif self.format != other.format: + other = other.asformat(self.format) + if op_name not in ('_ge_', '_le_'): + return self._binopt(other, op_name) + + warn("Comparing sparse matrices using >= and <= is inefficient, " + "using <, >, or !=, instead.", SparseEfficiencyWarning) + all_true = _all_true(self.shape) + res = self._binopt(other, '_gt_' if op_name == '_le_' else '_lt_') + return all_true - res + else: + raise ValueError("Operands could not be compared.") + + def _with_data(self, data, copy=True): + """Returns a matrix with the same sparsity structure as self, + but with different data. By default the structure arrays + (i.e. .indptr and .indices) are copied. + """ + # We need this just in case something like abs(data) gets called + # does nothing if data.dtype is complex. + data = np.asarray(data, dtype=complex) + if copy: + return fast_csr_matrix((data, self.indices.copy(), self.indptr.copy()), + shape=self.shape, dtype=data.dtype) + else: + return fast_csr_matrix((data, self.indices, self.indptr), + shape=self.shape, dtype=data.dtype) + # pylint: disable=arguments-differ + def transpose(self): + """ + Returns the transpose of the matrix, keeping + it in fast_csr format. + """ + return zcsr_transpose(self) + + def trans(self): + """ + Same as transpose + """ + return zcsr_transpose(self) + + def getH(self): + """ + Returns the conjugate-transpose of the matrix, keeping + it in fast_csr format. + """ + return zcsr_adjoint(self) + + def adjoint(self): + """ + Same as getH + """ + return zcsr_adjoint(self) + + +def csr2fast(A, copy=False): + """Converts a SciPy CSR matrix + to the internal fast version. + + Args: + A (csr_matrx): Input csr_matrix. + copy (bool): Make a copy of the data arrays. + + Returns: + fast_csr: The equivilent fast CSR matrix. + """ + if (not isinstance(A, fast_csr_matrix)) or copy: + # Do not need to do any type checking here + # since fast_csr_matrix does that. + return fast_csr_matrix((A.data, A.indices, A.indptr), + shape=A.shape, copy=copy) + else: + return A + + +def fast_identity(N): + """Generates a sparse identity matrix in + fast_csr format. + """ + data = np.ones(N, dtype=complex) + ind = np.arange(N, dtype=np.int32) + ptr = np.arange(N+1, dtype=np.int32) + ptr[-1] = N + return fast_csr_matrix((data, ind, ptr), shape=(N, N)) + + +#Convenience functions +#-------------------- +def _all_true(shape): + A = csr_matrix((np.ones(np.prod(shape), dtype=np.bool_), + np.tile(np.arange(shape[1], dtype=np.int32), shape[0]), + np.arange(0, np.prod(shape)+1, shape[1], dtype=np.int32)), + shape=shape) + return A + + + +#Need to do some trailing imports here +#------------------------------------- +# pylint: disable=no-name-in-module, wrong-import-position +from .cy.spmath import (zcsr_transpose, zcsr_adjoint, zcsr_mult) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/operators.py b/qiskit/providers/aer/openpulse/qutip_lite/operators.py new file mode 100755 index 0000000000..b26e643220 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/operators.py @@ -0,0 +1,611 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +# pylint: disable=invalid-name + +""" +This module contains functions for generating Qobj representation of a variety +of commonly occuring quantum operators. +""" + +import numpy as np +import scipy +import scipy.sparse as sp +from .fastsparse import fast_csr_matrix, fast_identity + +# +# Spin operators +# +def jmat(j, *args): + """Higher-order spin operators: + + Args: + j (float): Spin of operator + + args (str): Which operator to return 'x','y','z','+','-'. + If no args given, then output is ['x','y','z'] + + Returns: + Qobj: Requested spin operator(s). + + Raises: + TypeError: Invalid input. + """ + if (scipy.fix(2 * j) != 2 * j) or (j < 0): + raise TypeError('j must be a non-negative integer or half-integer') + + if not args: + return jmat(j, 'x'), jmat(j, 'y'), jmat(j, 'z') + + if args[0] == '+': + A = _jplus(j) + elif args[0] == '-': + A = _jplus(j).getH() + elif args[0] == 'x': + A = 0.5 * (_jplus(j) + _jplus(j).getH()) + elif args[0] == 'y': + A = -0.5 * 1j * (_jplus(j) - _jplus(j).getH()) + elif args[0] == 'z': + A = _jz(j) + else: + raise TypeError('Invalid type') + + return Qobj(A) + + +def _jplus(j): + """ + Internal functions for generating the data representing the J-plus + operator. + """ + m = np.arange(j, -j - 1, -1, dtype=complex) + data = (np.sqrt(j * (j + 1.0) - (m + 1.0) * m))[1:] + N = m.shape[0] + ind = np.arange(1, N, dtype=np.int32) + ptr = np.array(list(range(N-1))+[N-1]*2, dtype=np.int32) + ptr[-1] = N-1 + return fast_csr_matrix((data, ind, ptr), shape=(N, N)) + + +def _jz(j): + """ + Internal functions for generating the data representing the J-z operator. + """ + N = int(2*j+1) + data = np.array([j-k for k in range(N) if (j-k) != 0], dtype=complex) + # Even shaped matrix + if N % 2 == 0: + ind = np.arange(N, dtype=np.int32) + ptr = np.arange(N+1, dtype=np.int32) + ptr[-1] = N + # Odd shaped matrix + else: + j = int(j) + ind = np.array(list(range(j))+list(range(j+1, N)), dtype=np.int32) + ptr = np.array(list(range(j+1))+list(range(j, N)), dtype=np.int32) + ptr[-1] = N-1 + return fast_csr_matrix((data, ind, ptr), shape=(N, N)) + + +# +# Spin j operators: +# +def spin_Jx(j): + """Spin-j x operator + + Parameters + ---------- + j : float + Spin of operator + + Returns + ------- + op : Qobj + ``qobj`` representation of the operator. + + """ + return jmat(j, 'x') + + +def spin_Jy(j): + """Spin-j y operator + + Args: + j (float): Spin of operator + + Returns: + Qobj: representation of the operator. + + """ + return jmat(j, 'y') + + +def spin_Jz(j): + """Spin-j z operator + + Args: + j (float): Spin of operator + + Returns: + Qobj: representation of the operator. + + """ + return jmat(j, 'z') + + +def spin_Jm(j): + """Spin-j annihilation operator + + Parameters: + j (float): Spin of operator + + Returns: + Qobj: representation of the operator. + + """ + return jmat(j, '-') + + +def spin_Jp(j): + """Spin-j creation operator + + Args: + j (float): Spin of operator + + Returns: + Qobj: representation of the operator. + + """ + return jmat(j, '+') + + +def spin_J_set(j): + """Set of spin-j operators (x, y, z) + + Args: + j (float): Spin of operators + + Returns: + list: list of ``qobj`` representating of the spin operator. + + """ + return jmat(j) + + +# +# Pauli spin 1/2 operators: +# +def sigmap(): + """Creation operator for Pauli spins. + + Examples + -------- + >>> sigmap() + Quantum object: dims = [[2], [2]], \ +shape = [2, 2], type = oper, isHerm = False + Qobj data = + [[ 0. 1.] + [ 0. 0.]] + + """ + return jmat(1 / 2., '+') + + +def sigmam(): + """Annihilation operator for Pauli spins. + + Examples + -------- + >>> sigmam() + Quantum object: dims = [[2], [2]], \ +shape = [2, 2], type = oper, isHerm = False + Qobj data = + [[ 0. 0.] + [ 1. 0.]] + + """ + return jmat(1 / 2., '-') + + +def sigmax(): + """Pauli spin 1/2 sigma-x operator + + Examples + -------- + >>> sigmax() + Quantum object: dims = [[2], [2]], \ +shape = [2, 2], type = oper, isHerm = False + Qobj data = + [[ 0. 1.] + [ 1. 0.]] + + """ + return 2.0 * jmat(1.0 / 2, 'x') + + +def sigmay(): + """Pauli spin 1/2 sigma-y operator. + + Examples + -------- + >>> sigmay() + Quantum object: dims = [[2], [2]], \ +shape = [2, 2], type = oper, isHerm = True + Qobj data = + [[ 0.+0.j 0.-1.j] + [ 0.+1.j 0.+0.j]] + + """ + return 2.0 * jmat(1.0 / 2, 'y') + + +def sigmaz(): + """Pauli spin 1/2 sigma-z operator. + + Examples + -------- + >>> sigmaz() + Quantum object: dims = [[2], [2]], \ +shape = [2, 2], type = oper, isHerm = True + Qobj data = + [[ 1. 0.] + [ 0. -1.]] + + """ + return 2.0 * jmat(1.0 / 2, 'z') + + +# +# DESTROY returns annihilation operator for N dimensional Hilbert space +# out = destroy(N), N is integer value & N>0 +# +def destroy(N, offset=0): + """Destruction (lowering) operator. + + Args: + N (int): Dimension of Hilbert space. + + offset (int): (default 0) The lowest number state that is included + in the finite number state representation of the operator. + + Returns: + Qobj: Qobj for lowering operator. + + Raises: + ValueError: Invalid input. + + """ + if not isinstance(N, (int, np.integer)): # raise error if N not integer + raise ValueError("Hilbert space dimension must be integer value") + data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex)) + ind = np.arange(1, N, dtype=np.int32) + ptr = np.arange(N+1, dtype=np.int32) + ptr[-1] = N-1 + return Qobj(fast_csr_matrix((data, ind, ptr), shape=(N, N)), isherm=False) + + +# +# create returns creation operator for N dimensional Hilbert space +# out = create(N), N is integer value & N>0 +# +def create(N, offset=0): + """Creation (raising) operator. + + Args: + N (int): Dimension of Hilbert space. + + offset (int): (default 0) The lowest number state that is included + in the finite number state representation of the operator. + + Returns: + Qobj: Qobj for raising operator. + + Raises: + ValueError: Invalid inputs. + + """ + if not isinstance(N, (int, np.integer)): # raise error if N not integer + raise ValueError("Hilbert space dimension must be integer value") + qo = destroy(N, offset=offset) # create operator using destroy function + return qo.dag() + + +# +# QEYE returns identity operator for an N dimensional space +# a = qeye(N), N is integer & N>0 +# +def qeye(N): + """ + Identity operator + + Args: + N (int): Dimension of Hilbert space. If provided as a list of ints, + then the dimension is the product over this list, but the + ``dims`` property of the new Qobj are set to this list. + + Returns: + Qobj: Identity operator Qobj. + + Raises: + ValueError: Invalid input. + """ + N = int(N) + if N < 0: + raise ValueError("N must be integer N>=0") + return Qobj(fast_identity(N), isherm=True, isunitary=True) + + +def identity(N): + """Identity operator. Alternative name to :func:`qeye`. + + Parameters + ---------- + N : int or list of ints + Dimension of Hilbert space. If provided as a list of ints, + then the dimension is the product over this list, but the + ``dims`` property of the new Qobj are set to this list. + + Returns + ------- + oper : qobj + Identity operator Qobj. + """ + return qeye(N) + + +def position(N, offset=0): + """ + Position operator x=1/sqrt(2)*(a+a.dag()) + + Args: + N (int): Number of Fock states in Hilbert space. + + offset (int): (default 0) The lowest number state that is included + in the finite number state representation of the operator. + Returns: + Qobj: Position operator as Qobj. + """ + a = destroy(N, offset=offset) + return 1.0 / np.sqrt(2.0) * (a + a.dag()) + + +def momentum(N, offset=0): + """ + Momentum operator p=-1j/sqrt(2)*(a-a.dag()) + + Args: + N (int): Number of Fock states in Hilbert space. + + offset (int): (default 0) The lowest number state that is + included in the finite number state + representation of the operator. + Returns: + Qobj: Momentum operator as Qobj. + """ + a = destroy(N, offset=offset) + return -1j / np.sqrt(2.0) * (a - a.dag()) + + +def num(N, offset=0): + """Quantum object for number operator. + + Args: + N (int): The dimension of the Hilbert space. + + offset(int): (default 0) The lowest number state that is included + in the finite number state representation of the operator. + + Returns: + Qobj: Qobj for number operator. + + """ + if offset == 0: + data = np.arange(1, N, dtype=complex) + ind = np.arange(1, N, dtype=np.int32) + ptr = np.array([0]+list(range(0, N)), dtype=np.int32) + ptr[-1] = N-1 + else: + data = np.arange(offset, offset + N, dtype=complex) + ind = np.arange(N, dtype=np.int32) + ptr = np.arange(N+1, dtype=np.int32) + ptr[-1] = N + + return Qobj(fast_csr_matrix((data, ind, ptr), + shape=(N, N)), isherm=True) + + +def squeeze(N, z, offset=0): + """Single-mode Squeezing operator. + + Args: + N (int): Dimension of hilbert space. + + z (complex): Squeezing parameter. + + offset (int): (default 0) The lowest number state that is included + in the finite number state representation of the operator. + + Returns: + Qobj:`Squeezing operator. + + """ + a = destroy(N, offset=offset) + op = (1 / 2.0) * np.conj(z) * (a ** 2) - (1 / 2.0) * z * (a.dag()) ** 2 + return op.expm() + + +def squeezing(a1, a2, z): + """Generalized squeezing operator. + + Args: + a1 (Qobj): Operator 1. + + a2 (Qobj): Operator 2. + + z (complex): Squeezing parameter. + + Returns: + Qobj: Squeezing operator. + + """ + b = 0.5 * (np.conj(z) * (a1 * a2) - z * (a1.dag() * a2.dag())) + return b.expm() + + +def displace(N, alpha, offset=0): + """Single-mode displacement operator. + + Args: + N (int): Dimension of Hilbert space. + + alpha (complex): Displacement amplitude. + + offset (int): The lowest number state that is included + in the finite number state + representation of the operator. + + Returns: + Qobj: Displacement operator. + """ + a = destroy(N, offset=offset) + D = (alpha * a.dag() - np.conj(alpha) * a).expm() + return D + + +def commutator(A, B, kind="normal"): + """ + Return the commutator of kind `kind` (normal, anti) of the + two operators A and B. + + Args: + A (Qobj): Operator A. + + B (Qobj): Operator B. + + kind (str): 'normal' or 'anti' commutator. + + Returns: + Qobj: Commutator + + Raises: + TypeError: Invalid input. + """ + if kind == 'normal': + return A * B - B * A + + elif kind == 'anti': + return A * B + B * A + + else: + raise TypeError("Unknown commutator kind '%s'" % kind) + + +def qzero(N): + """ + Zero operator + + Args: + N (int or list): Dimension of Hilbert space. If provided as a + list of ints, then the dimension is the product + over this list, but the ``dims`` property of the + new Qobj are set to this list. + Returns: + Qobj: Zero operator Qobj. + + Raises: + ValueError: Invalid input. + """ + N = int(N) + if (not isinstance(N, (int, np.integer))) or N < 0: + raise ValueError("N must be integer N>=0") + return Qobj(sp.csr_matrix((N, N), dtype=complex), isherm=True) + + +def charge(Nmax, Nmin=None, frac=1): + """ + Generate the diagonal charge operator over charge states + from Nmin to Nmax. + + Args: + Nmax (int): Maximum charge state to consider. + + Nmin (int): (default = -Nmax) Lowest charge state to consider. + + frac (float): (default = 1) Specify fractional charge if needed. + + Returns: + Qobj: Charge operator over [Nmin,Nmax]. + """ + if Nmin is None: + Nmin = -Nmax + diag = np.arange(Nmin, Nmax+1, dtype=float) + if frac != 1: + diag *= frac + C = sp.diags(diag, 0, format='csr', dtype=complex) + return Qobj(C, isherm=True) + + + +def tunneling(N, m=1): + """ + Tunneling operator with elements of the form + :math:`\\sum |N> atol)): + return True + else: + return False + + def __ne__(self, other): + """ + INEQUALITY operator. + """ + return not self == other + + def __pow__(self, n, m=None): # calculates powers of Qobj + """ + POWER operation. + """ + if self.type not in ['oper', 'super']: + raise Exception("Raising a qobj to some power works only for " + + "operators and super-operators (square matrices).") + + if m is not None: + raise NotImplementedError("modulo is not implemented for Qobj") + + try: + data = self.data ** n + out = Qobj(data, dims=self.dims) + out.superrep = self.superrep + return out.tidyup() if auto_tidyup else out + + except: + raise ValueError('Invalid choice of exponent.') + + def __abs__(self): + return abs(self.data) + + def __str__(self): + s = "" + t = self.type + shape = self.shape + if self.type in ['oper', 'super']: + s += ("Quantum object: " + + "dims = " + str(self.dims) + + ", shape = " + str(shape) + + ", type = " + t + + ", isherm = " + str(self.isherm) + + ( + ", superrep = {0.superrep}".format(self) + if t == "super" and self.superrep != "super" + else "" + ) + "\n") + else: + s += ("Quantum object: " + + "dims = " + str(self.dims) + + ", shape = " + str(shape) + + ", type = " + t + "\n") + s += "Qobj data =\n" + + if shape[0] > 10000 or shape[1] > 10000: + # if the system is huge, don't attempt to convert to a + # dense matrix and then to string, because it is pointless + # and is likely going to produce memory errors. Instead print the + # sparse data string representation + s += str(self.data) + + elif all(np.imag(self.data.data) == 0): + s += str(np.real(self.full())) + + else: + s += str(self.full()) + + return s + + def __repr__(self): + # give complete information on Qobj without print statement in + # command-line we cant realistically serialize a Qobj into a string, + # so we simply return the informal __str__ representation instead.) + return self.__str__() + + def __call__(self, other): + """ + Acts this Qobj on another Qobj either by left-multiplication, + or by vectorization and devectorization, as + appropriate. + """ + if not isinstance(other, Qobj): + raise TypeError("Only defined for quantum objects.") + + elif self.type == "oper": + if other.type == "ket": + return self * other + else: + raise TypeError("Can only act oper on ket.") + + def __getstate__(self): + # defines what happens when Qobj object gets pickled + self.__dict__.update({'qiskit_version': __version__[:5]}) + return self.__dict__ + + def __setstate__(self, state): + # defines what happens when loading a pickled Qobj + if 'qiskit_version' in state.keys(): + del state['qiskit_version'] + (self.__dict__).update(state) + + def _repr_latex_(self): + """ + Generate a LaTeX representation of the Qobj instance. Can be used for + formatted output in ipython notebook. + """ + t = self.type + shape = self.shape + s = r'' + if self.type in ['oper', 'super']: + s += ("Quantum object: " + + "dims = " + str(self.dims) + + ", shape = " + str(shape) + + ", type = " + t + + ", isherm = " + str(self.isherm) + + ( + ", superrep = {0.superrep}".format(self) + if t == "super" and self.superrep != "super" + else "" + )) + else: + s += ("Quantum object: " + + "dims = " + str(self.dims) + + ", shape = " + str(shape) + + ", type = " + t) + + M, N = self.data.shape + + s += r'\begin{equation*}\left(\begin{array}{*{11}c}' + + def _format_float(value): + if value == 0.0: + return "0.0" + elif abs(value) > 1000.0 or abs(value) < 0.001: + return ("%.3e" % value).replace("e", r"\times10^{") + "}" + elif abs(value - int(value)) < 0.001: + return "%.1f" % value + else: + return "%.3f" % value + + def _format_element(_, n, d): + s = " & " if n > 0 else "" + if isinstance(d, str): + return s + d + else: + if abs(np.imag(d)) < atol: + return s + _format_float(np.real(d)) + elif abs(np.real(d)) < atol: + return s + _format_float(np.imag(d)) + "j" + else: + s_re = _format_float(np.real(d)) + s_im = _format_float(np.imag(d)) + if np.imag(d) > 0.0: + return s + "(" + s_re + "+" + s_im + "j)" + else: + return s + "(" + s_re + s_im + "j)" + + if M > 10 and N > 10: + # truncated matrix output + for m in range(5): + for n in range(5): + s += _format_element(m, n, self.data[m, n]) + s += r' & \cdots' + for n in range(N - 5, N): + s += _format_element(m, n, self.data[m, n]) + s += r'\\' + + for n in range(5): + s += _format_element(m, n, r'\vdots') + s += r' & \ddots' + for n in range(N - 5, N): + s += _format_element(m, n, r'\vdots') + s += r'\\' + + for m in range(M - 5, M): + for n in range(5): + s += _format_element(m, n, self.data[m, n]) + s += r' & \cdots' + for n in range(N - 5, N): + s += _format_element(m, n, self.data[m, n]) + s += r'\\' + + elif M > 10 and N <= 10: + # truncated vertically elongated matrix output + for m in range(5): + for n in range(N): + s += _format_element(m, n, self.data[m, n]) + s += r'\\' + + for n in range(N): + s += _format_element(m, n, r'\vdots') + s += r'\\' + + for m in range(M - 5, M): + for n in range(N): + s += _format_element(m, n, self.data[m, n]) + s += r'\\' + + elif M <= 10 and N > 10: + # truncated horizontally elongated matrix output + for m in range(M): + for n in range(5): + s += _format_element(m, n, self.data[m, n]) + s += r' & \cdots' + for n in range(N - 5, N): + s += _format_element(m, n, self.data[m, n]) + s += r'\\' + + else: + # full output + for m in range(M): + for n in range(N): + s += _format_element(m, n, self.data[m, n]) + s += r'\\' + + s += r'\end{array}\right)\end{equation*}' + return s + + def dag(self): + """Adjoint operator of quantum object. + """ + out = Qobj() + out.data = zcsr_adjoint(self.data) + out.dims = [self.dims[1], self.dims[0]] + out._isherm = self._isherm + out.superrep = self.superrep + return out + + def conj(self): + """Conjugate operator of quantum object. + """ + out = Qobj() + out.data = self.data.conj() + out.dims = [self.dims[0], self.dims[1]] + return out + + def norm(self, norm=None, sparse=False, tol=0, maxiter=100000): + """Norm of a quantum object. + + Default norm is L2-norm for kets and trace-norm for operators. + Other ket and operator norms may be specified using the `norm` and + argument. + + Args: + norm (str): Which norm to use for ket/bra vectors: L2 'l2', + max norm 'max', or for operators: trace 'tr', Frobius + 'fro', one 'one', or max 'max'. + + sparse (bool): Use sparse eigenvalue solver for trace norm. + Other norms are not affected by this parameter. + + tol (float): Tolerance for sparse solver (if used) for trace norm. + The sparse solver may not converge if the tolerance + is set too low. + + maxiter (int): Maximum number of iterations performed by sparse + solver (if used) for trace norm. + + Returns: + float: The requested norm of the operator or state quantum object. + + Raises: + ValueError: Invalid input. + """ + if self.type in ['oper', 'super']: + if norm is None or norm == 'tr': + _op = self*self.dag() + vals = sp_eigs(_op.data, _op.isherm, vecs=False, + sparse=sparse, tol=tol, maxiter=maxiter) + return np.sum(np.sqrt(np.abs(vals))) + elif norm == 'fro': + return sp_fro_norm(self.data) + elif norm == 'one': + return sp_one_norm(self.data) + elif norm == 'max': + return sp_max_norm(self.data) + else: + raise ValueError( + "For matrices, norm must be 'tr', 'fro', 'one', or 'max'.") + else: + if norm is None or norm == 'l2': + return sp_L2_norm(self.data) + elif norm == 'max': + return sp_max_norm(self.data) + else: + raise ValueError("For vectors, norm must be 'l2', or 'max'.") + + def proj(self): + """Form the projector from a given ket or bra vector. + + Returns: + qobj.Qobj: Projection operator. + Raises: + TypeError: Project from only bra or ket. + """ + if self.isket: + _out = zcsr_proj(self.data, 1) + _dims = [self.dims[0], self.dims[0]] + elif self.isbra: + _out = zcsr_proj(self.data, 0) + _dims = [self.dims[1], self.dims[1]] + else: + raise TypeError('Projector can only be formed from a bra or ket.') + + return Qobj(_out, dims=_dims) + + def tr(self): + """Trace of a quantum object. + + Returns + ------- + trace : float + Returns ``real`` if operator is Hermitian, returns ``complex`` + otherwise. + + """ + return zcsr_trace(self.data, self.isherm) + + def full(self, order='C', squeeze=False): + """Dense array from quantum object. + + Parameters + ---------- + order : str {'C', 'F'} + Return array in C (default) or Fortran ordering. + squeeze : bool {False, True} + Squeeze output array. + + Returns + ------- + data : array + Array of complex data from quantum objects `data` attribute. + """ + if squeeze: + return self.data.toarray(order=order).squeeze() + else: + return self.data.toarray(order=order) + + # pylint: disable=unused-argument + def __array__(self, *arg, **kwarg): + """Numpy array from Qobj + For compatibility with np.array + """ + return self.full() + + def diag(self): + """Diagonal elements of quantum object. + + Returns + ------- + diags : array + Returns array of ``real`` values if operators is Hermitian, + otherwise ``complex`` values are returned. + + """ + out = self.data.diagonal() + if np.any(np.imag(out) > atol) or not self.isherm: + return out + else: + return np.real(out) + + def expm(self, method='dense'): + """Matrix exponential of quantum operator. + + Input operator must be square. + + Args: + method (str): Use set method to use to calculate the matrix + exponentiation. The available choices includes + 'dense' and 'sparse'. Since the exponential of + a matrix is nearly always dense, method='dense' + is set as default. + Returns: + Qobj: Exponentiated quantum operator. + + Raises: + TypeError: Quantum operator is not square. + ValueError: Invalid input. + + """ + if self.dims[0][0] != self.dims[1][0]: + raise TypeError('Invalid operand for matrix exponential') + + if method == 'dense': + F = sp_expm(self.data, sparse=False) + + elif method == 'sparse': + F = sp_expm(self.data, sparse=True) + + else: + raise ValueError("method must be 'dense' or 'sparse'.") + + out = Qobj(F, dims=self.dims) + return out.tidyup() if auto_tidyup else out + + def check_herm(self): + """Check if the quantum object is hermitian. + + Returns: + bool: Returns the new value of isherm property. + """ + self._isherm = None + return self.isherm + + def sqrtm(self, sparse=False, tol=0, maxiter=100000): + """Sqrt of a quantum operator. + + Operator must be square. + + Args: + sparse (bool): Use sparse eigenvalue/vector solver. + + tol (float): Tolerance used by sparse solver + (0 = machine precision). + + maxiter (int): Maximum number of iterations used by + sparse solver. + + Returns: + Qobj: Matrix square root of operator. + + Raises: + TypeError: Quantum object is not square. + """ + if self.dims[0][0] == self.dims[1][0]: + evals, evecs = sp_eigs(self.data, self.isherm, sparse=sparse, + tol=tol, maxiter=maxiter) + numevals = len(evals) + dV = sp.spdiags(np.sqrt(evals, dtype=complex), 0, numevals, + numevals, format='csr') + if self.isherm: + spDv = dV.dot(evecs.T.conj().T) + else: + spDv = dV.dot(np.linalg.inv(evecs.T)) + + out = Qobj(evecs.T.dot(spDv), dims=self.dims) + return out.tidyup() if auto_tidyup else out + + else: + raise TypeError('Invalid operand for matrix square root') + + + def cosm(self): + """Cosine of a quantum operator. + + Operator must be square. + + Returns + ------- + oper : :class:`qutip.Qobj` + Matrix cosine of operator. + + Raises + ------ + TypeError + Quantum object is not square. + + Notes + ----- + Uses the Q.expm() method. + + """ + if self.dims[0][0] == self.dims[1][0]: + return 0.5 * ((1j * self).expm() + (-1j * self).expm()) + else: + raise TypeError('Invalid operand for matrix square root') + + + def sinm(self): + """Sine of a quantum operator. + + Operator must be square. + + Returns + ------- + oper : :class:`qutip.Qobj` + Matrix sine of operator. + + Raises + ------ + TypeError + Quantum object is not square. + + Notes + ----- + Uses the Q.expm() method. + + """ + if self.dims[0][0] == self.dims[1][0]: + return -0.5j * ((1j * self).expm() - (-1j * self).expm()) + else: + raise TypeError('Invalid operand for matrix square root') + + def unit(self, inplace=False, + norm=None, sparse=False, + tol=0, maxiter=100000): + """Operator or state normalized to unity. + + Uses norm from Qobj.norm(). + + Args: + inplace (bool): Do an in-place normalization + norm (str): Requested norm for states / operators. + sparse (bool): Use sparse eigensolver for trace norm. Does not affect other norms. + tol (float): Tolerance used by sparse eigensolver. + maxiter (int): Number of maximum iterations performed by sparse eigensolver. + + Returns: + qobj.Qobj: Normalized quantum object if not in-place, else None. + + Raises: + TypeError: Inplace value must be a bool. + """ + if inplace: + nrm = self.norm(norm=norm, sparse=sparse, + tol=tol, maxiter=maxiter) + + self.data /= nrm + elif not inplace: + out = self / self.norm(norm=norm, sparse=sparse, + tol=tol, maxiter=maxiter) + if auto_tidyup: + return out.tidyup() + else: + return out + else: + raise TypeError('inplace kwarg must be bool.') + + def tidyup(self, atol=auto_tidyup_atol): + """Removes small elements from the quantum object. + + Parameters + ---------- + atol : float + Absolute tolerance used by tidyup. Default is set + via qutip global settings parameters. + + Returns + ------- + oper : :class:`qutip.Qobj` + Quantum object with small elements removed. + + """ + if self.data.nnz: + #This does the tidyup and returns True if + #The sparse data needs to be shortened + if cy_tidyup(self.data.data, atol, self.data.nnz): + self.data.eliminate_zeros() + return self + else: + return self + + def transform(self, inpt, inverse=False, sparse=True): + """Basis transform defined by input array. + + Input array can be a ``matrix`` defining the transformation, + or a ``list`` of kets that defines the new basis. + + Args: + inpt (ndarray): A ``matrix`` or ``list`` of kets defining + the transformation. + inverse (bool): Whether to return inverse transformation. + + sparse (bool): Use sparse matrices when possible. Can be slower. + + Returns: + Qobj: Operator in new basis. + + Raises: + TypeError: Invalid input. + + """ + if isinstance(inpt, list) or (isinstance(inpt, np.ndarray) and + len(inpt.shape) == 1): + if len(inpt) != max(self.shape): + raise TypeError( + 'Invalid size of ket list for basis transformation') + if sparse: + S = sp.hstack([psi.data for psi in inpt], + format='csr', dtype=complex).conj().T + else: + S = np.hstack([psi.full() for psi in inpt], + dtype=complex).conj().T + elif isinstance(inpt, Qobj) and inpt.isoper: + S = inpt.data + elif isinstance(inpt, np.ndarray): + S = inpt.conj() + sparse = False + else: + raise TypeError('Invalid operand for basis transformation') + + + # transform data + if inverse: + if self.isket: + data = (S.conj().T) * self.data + elif self.isbra: + data = self.data.dot(S) + else: + if sparse: + data = (S.conj().T) * self.data * S + else: + data = (S.conj().T).dot(self.data.dot(S)) + else: + if self.isket: + data = S * self.data + elif self.isbra: + data = self.data.dot(S.conj().T) + else: + if sparse: + data = S * self.data * (S.conj().T) + else: + data = S.dot(self.data.dot(S.conj().T)) + + out = Qobj(data, dims=self.dims) + out._isherm = self._isherm + out.superrep = self.superrep + + if auto_tidyup: + return out.tidyup() + else: + return out + + + def matrix_element(self, bra, ket): + """Calculates a matrix element. + + Gives the matrix element for the quantum object sandwiched between a + `bra` and `ket` vector. + + Args: + bra (Qobj): Quantum object of type 'bra' or 'ket' + + ket (Qobj): Quantum object of type 'ket'. + + Returns: + complex: Complex valued matrix element. + + Raises: + TypeError: Invalid input. + + """ + if not self.isoper: + raise TypeError("Can only get matrix elements for an operator.") + + else: + if bra.isbra and ket.isket: + return zcsr_mat_elem(self.data, bra.data, ket.data, 1) + + elif bra.isket and ket.isket: + return zcsr_mat_elem(self.data, bra.data, ket.data, 0) + else: + raise TypeError("Can only calculate matrix elements for bra and ket vectors.") + + def overlap(self, other): + """Overlap between two state vectors or two operators. + + Gives the overlap (inner product) between the current bra or ket Qobj + and and another bra or ket Qobj. It gives the Hilbert-Schmidt overlap + when one of the Qobj is an operator/density matrix. + + Parameters + ----------- + other : :class:`qutip.Qobj` + Quantum object for a state vector of type 'ket', 'bra' or density + matrix. + + Returns + ------- + overlap : complex + Complex valued overlap. + + Raises + ------ + TypeError + Can only calculate overlap between a bra, ket and density matrix + quantum objects. + + Notes + ----- + Since QuTiP mainly deals with ket vectors, the most efficient inner + product call is the ket-ket version that computes the product + with both vectors expressed as kets. + """ + + if isinstance(other, Qobj): + + if self.isbra: + if other.isket: + return zcsr_inner(self.data, other.data, 1) + elif other.isbra: + #Since we deal mainly with ket vectors, the bra-bra combo + #is not common, and not optimized. + return zcsr_inner(self.data, other.dag().data, 1) + elif other.isoper: + return (states.ket2dm(self).dag() * other).tr() + else: + raise TypeError("Can only calculate overlap for state vector Qobjs") + + elif self.isket: + if other.isbra: + return zcsr_inner(other.data, self.data, 1) + elif other.isket: + return zcsr_inner(self.data, other.data, 0) + elif other.isoper: + return (states.ket2dm(self).dag() * other).tr() + else: + raise TypeError("Can only calculate overlap for state vector Qobjs") + + elif self.isoper: + if other.isket or other.isbra: + return (self.dag() * states.ket2dm(other)).tr() + elif other.isoper: + return (self.dag() * other).tr() + else: + raise TypeError("Can only calculate overlap for state vector Qobjs") + + + raise TypeError("Can only calculate overlap for state vector Qobjs") + + + def eigenstates(self, sparse=False, sort='low', + eigvals=0, tol=0, maxiter=100000): + """Eigenstates and eigenenergies. + + Eigenstates and eigenenergies are defined for operators and + superoperators only. + + Parameters + ---------- + sparse : bool + Use sparse Eigensolver + + sort : str + Sort eigenvalues (and vectors) 'low' to high, or 'high' to low. + + eigvals : int + Number of requested eigenvalues. Default is all eigenvalues. + + tol : float + Tolerance used by sparse Eigensolver (0 = machine precision). + The sparse solver may not converge if the tolerance is set too low. + + maxiter : int + Maximum number of iterations performed by sparse solver (if used). + + Returns + ------- + eigvals : array + Array of eigenvalues for operator. + + eigvecs : array + Array of quantum operators representing the oprator eigenkets. + Order of eigenkets is determined by order of eigenvalues. + + Notes + ----- + The sparse eigensolver is much slower than the dense version. + Use sparse only if memory requirements demand it. + + """ + evals, evecs = sp_eigs(self.data, self.isherm, sparse=sparse, + sort=sort, eigvals=eigvals, tol=tol, + maxiter=maxiter) + new_dims = [self.dims[0], [1] * len(self.dims[0])] + ekets = np.array([Qobj(vec, dims=new_dims) for vec in evecs], + dtype=object) + norms = np.array([ket.norm() for ket in ekets]) + return evals, ekets / norms + + + def eigenenergies(self, sparse=False, sort='low', + eigvals=0, tol=0, maxiter=100000): + """Eigenenergies of a quantum object. + + Eigenenergies (eigenvalues) are defined for operators or superoperators + only. + + Parameters + ---------- + sparse : bool + Use sparse Eigensolver + sort : str + Sort eigenvalues 'low' to high, or 'high' to low. + eigvals : int + Number of requested eigenvalues. Default is all eigenvalues. + tol : float + Tolerance used by sparse Eigensolver (0=machine precision). + The sparse solver may not converge if the tolerance is set too low. + maxiter : int + Maximum number of iterations performed by sparse solver (if used). + + Returns + ------- + eigvals : array + Array of eigenvalues for operator. + + Notes + ----- + The sparse eigensolver is much slower than the dense version. + Use sparse only if memory requirements demand it. + + """ + return sp_eigs(self.data, self.isherm, vecs=False, sparse=sparse, + sort=sort, eigvals=eigvals, tol=tol, maxiter=maxiter) + + def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True): + """Ground state Eigenvalue and Eigenvector. + + Defined for quantum operators or superoperators only. + + Args: + sparse (bool): Use sparse Eigensolver + + tol (float): Tolerance used by sparse Eigensolver + (0 = machine precision). The sparse solver + may not converge if the tolerance is set too low. + + maxiter (int): Maximum number of iterations performed by + sparse solver (if used). + + safe (bool): Check for degenerate ground state + + Returns: + tuple: Eigenenergy and eigenstate of ground state. + + """ + if safe: + evals = 2 + else: + evals = 1 + grndval, grndvec = sp_eigs(self.data, self.isherm, sparse=sparse, + eigvals=evals, tol=tol, maxiter=maxiter) + if safe: + if tol == 0: + tol = 1e-15 + if (grndval[1]-grndval[0]) <= 10*tol: + print("WARNING: Ground state may be degenerate. " + "Use Q.eigenstates()") + new_dims = [self.dims[0], [1] * len(self.dims[0])] + grndvec = Qobj(grndvec[0], dims=new_dims) + grndvec = grndvec / grndvec.norm() + return grndval[0], grndvec + + def trans(self): + """Transposed operator. + + Returns: + Qobj: Transpose of input operator. + + """ + out = Qobj() + out.data = zcsr_transpose(self.data) + out.dims = [self.dims[1], self.dims[0]] + return out + + @property + def isherm(self): + """Is operator Hermitian. + + Returns: + bool: Operator is Hermitian or not. + """ + + if self._isherm is not None: + # used previously computed value + return self._isherm + + self._isherm = bool(zcsr_isherm(self.data)) + + return self._isherm + + @isherm.setter + def isherm(self, isherm): + self._isherm = isherm + + def check_isunitary(self): + """ + Checks whether qobj is a unitary matrix + """ + if self.isoper: + eye_data = fast_identity(self.shape[0]) + return not (np.any(np.abs((self.data*self.dag().data + - eye_data).data) + > atol) + or + np.any(np.abs((self.dag().data*self.data + - eye_data).data) > + atol) + ) + + else: + return False + + @property + def isunitary(self): + """Is operator unitary. + + Returns: + bool: Is operator unitary or not. + """ + if self._isunitary is not None: + # used previously computed value + return self._isunitary + + self._isunitary = self.check_isunitary() + + return self._isunitary + + @isunitary.setter + def isunitary(self, isunitary): + self._isunitary = isunitary + + @property + def type(self): + """Type of Qobj + """ + if not self._type: + self._type = type_from_dims(self.dims) + + return self._type + + @property + def shape(self): + """Shape of Qobj + """ + if self.data.shape == (1, 1): + return tuple([np.prod(self.dims[0]), np.prod(self.dims[1])]) + else: + return tuple(self.data.shape) + + @property + def isbra(self): + """Is bra vector""" + return self.type == 'bra' + + @property + def isket(self): + """Is ket vector""" + return self.type == 'ket' + + @property + def isoperbra(self): + """Is operator-bra""" + return self.type == 'operator-bra' + + @property + def isoperket(self): + """Is operator-ket""" + return self.type == 'operator-ket' + + @property + def isoper(self): + """Is operator""" + return self.type == 'oper' + + @property + def issuper(self): + """Is super operator""" + return self.type == 'super' + + @staticmethod + def evaluate(qobj_list, t, args): + """Evaluate a time-dependent quantum object in list format. For + example, + + qobj_list = [H0, [H1, func_t]] + + is evaluated to + + Qobj(t) = H0 + H1 * func_t(t, args) + + and + + qobj_list = [H0, [H1, 'sin(w * t)']] + + is evaluated to + + Qobj(t) = H0 + H1 * sin(args['w'] * t) + + Args: + qobj_list (list): A nested list of Qobj instances and + corresponding time-dependent coefficients. + + t (float): The time for which to evaluate the time-dependent + Qobj instance. + + args (dict): A dictionary with parameter values required + to evaluate the time-dependent Qobj intance. + + Returns: + Qobj: A Qobj instance that represents the value of qobj_list + at time t. + + Raises: + TypeError: Invalid input. + + """ + q_sum = 0 + if isinstance(qobj_list, Qobj): + q_sum = qobj_list + elif isinstance(qobj_list, list): + for q in qobj_list: + if isinstance(q, Qobj): + q_sum += q + elif (isinstance(q, list) and len(q) == 2 and + isinstance(q[0], Qobj)): + if isinstance(q[1], types.FunctionType): + q_sum += q[0] * q[1](t, args) + elif isinstance(q[1], str): + args['t'] = t + # pylint: disable=eval-used + q_sum += q[0] * float(eval(q[1], globals(), args)) + else: + raise TypeError('Unrecognized format for ' + + 'specification of time-dependent Qobj') + else: + raise TypeError('Unrecognized format for specification ' + + 'of time-dependent Qobj') + else: + raise TypeError( + 'Unrecongized format for specification of time-dependent Qobj') + + return q_sum + + +# pylint: disable=wrong-import-position +from ..qutip_lite import states diff --git a/qiskit/providers/aer/openpulse/qutip_lite/settings.py b/qiskit/providers/aer/openpulse/qutip_lite/settings.py new file mode 100755 index 0000000000..cee33c3bcc --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/settings.py @@ -0,0 +1,61 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +# pylint: disable=invalid-name + +""" +This module contains settings for qutip_lite functionality +""" +# use auto tidyup +auto_tidyup = True +# use auto tidyup dims on multiplication +auto_tidyup_dims = True +# detect hermiticity +auto_herm = True +# general absolute tolerance +atol = 1e-12 +# use auto tidyup absolute tolerance +auto_tidyup_atol = 1e-12 diff --git a/qiskit/providers/aer/openpulse/qutip_lite/sparse.py b/qiskit/providers/aer/openpulse/qutip_lite/sparse.py new file mode 100755 index 0000000000..4c44e6671d --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/sparse.py @@ -0,0 +1,588 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +# pylint: disable=invalid-name, len-as-condition, no-name-in-module +# pylint: disable=import-error + +""" +This module contains a collection of routines for operating on sparse +matrices on the scipy.sparse formats, for use internally by other modules +throughout QuTiP. +""" + +__all__ = ['sp_fro_norm', 'sp_inf_norm', 'sp_L2_norm', 'sp_max_norm', + 'sp_one_norm', 'sp_reshape', 'sp_eigs', 'sp_expm', 'sp_permute', + 'sp_reverse_permute', 'sp_bandwidth', 'sp_profile'] + +import numpy as np +import scipy.linalg as la +import scipy.sparse as sp +import scipy.sparse.linalg as spla +from scipy.linalg.blas import get_blas_funcs +from .cy.sparse_utils import (_sparse_profile, _sparse_permute, + _sparse_reverse_permute, _sparse_bandwidth, + _isdiag, zcsr_one_norm, zcsr_inf_norm) +from .fastsparse import fast_csr_matrix +from .cy.spconvert import (zcsr_reshape) + + +_dznrm2 = get_blas_funcs("znrm2") + +def sp_fro_norm(data): + """ + Frobius norm for sparse matrix + """ + out = np.sum(np.abs(data.data)**2) + return np.sqrt(out) + + +def sp_inf_norm(A): + """ + Infinity norm for sparse matrix + """ + return zcsr_inf_norm(A.data, A.indices, + A.indptr, A.shape[0], + A.shape[1]) + + +def sp_L2_norm(A): + """ + L2 norm sparse vector + """ + if 1 not in A.shape: + raise TypeError("Use L2-norm only for vectors.") + + if len(A.data): + return _dznrm2(A.data) + else: + return 0 + + +def sp_max_norm(A): + """ + Max norm for sparse matrix + """ + return np.max(np.abs(A.data)) if any(A.data) else 0 + + +def sp_one_norm(A): + """ + One norm for sparse matrix + """ + return zcsr_one_norm(A.data, A.indices, + A.indptr, A.shape[0], + A.shape[1]) + +# pylint: disable=redefined-builtin +def sp_reshape(A, shape, format='csr'): + """ + Reshapes a sparse matrix. + + Args: + A (sparse): Input matrix in any format + + shape (list):Desired shape of new matrix + + format (str): Optional string indicating + desired output format + + Returns: + csr_matrix: Reshaped sparse matrix + + Raises: + ValueError: Invalid input. + + """ + if not hasattr(shape, '__len__') or len(shape) != 2: + raise ValueError('Shape must be a list of two integers') + + if format == 'csr': + return zcsr_reshape(A, shape[0], shape[1]) + + C = A.tocoo() + nrows, ncols = C.shape + size = nrows * ncols + new_size = shape[0] * shape[1] + + if new_size != size: + raise ValueError('Total size of new array must be unchanged.') + + flat_indices = ncols * C.row + C.col + new_row, new_col = divmod(flat_indices, shape[1]) + + B = sp.coo_matrix((C.data, (new_row, new_col)), shape=shape) + if format == 'coo': + return B + elif format == 'csc': + return B.tocsc() + elif format == 'lil': + return B.tolil() + else: + raise ValueError('Return format not valid.') + + +def _dense_eigs(data, isherm, vecs, N, eigvals, num_large, num_small): + """ + Internal functions for computing eigenvalues and eigenstates for a dense + matrix. + """ + evecs = None + + if vecs: + if isherm: + if eigvals == 0: + evals, evecs = la.eigh(data) + else: + if num_small > 0: + evals, evecs = la.eigh( + data, eigvals=[0, num_small - 1]) + if num_large > 0: + evals, evecs = la.eigh( + data, eigvals=[N - num_large, N - 1]) + else: + evals, evecs = la.eig(data) + else: + if isherm: + if eigvals == 0: + evals = la.eigvalsh(data) + else: + if num_small > 0: + evals = la.eigvalsh(data, eigvals=[0, num_small - 1]) + if num_large > 0: + evals = la.eigvalsh(data, eigvals=[N - num_large, N - 1]) + else: + evals = la.eigvals(data) + + _zipped = list(zip(evals, range(len(evals)))) + _zipped.sort() + evals, perm = list(zip(*_zipped)) + + if vecs: + evecs = np.array([evecs[:, k] for k in perm]) + + if not isherm and eigvals > 0: + if vecs: + if num_small > 0: + evals, evecs = evals[:num_small], evecs[:num_small] + elif num_large > 0: + evals, evecs = evals[(N - num_large):], evecs[(N - num_large):] + else: + if num_small > 0: + evals = evals[:num_small] + elif num_large > 0: + evals = evals[(N - num_large):] + + return np.array(evals), np.array(evecs) + + +def _sp_eigs(data, isherm, vecs, N, eigvals, num_large, num_small, tol, + maxiter): + """ + Internal functions for computing eigenvalues and eigenstates for a sparse + matrix. + """ + + big_vals = np.array([]) + small_vals = np.array([]) + evecs = None + + remove_one = False + if eigvals == (N - 1): + # calculate all eigenvalues and remove one at output if using sparse + eigvals = 0 + num_small = int(np.ceil(N / 2.0)) + num_large = N - num_small + remove_one = True + + if vecs: + if isherm: + if num_large > 0: + big_vals, big_vecs = sp.linalg.eigsh(data, k=num_large, + which='LA', tol=tol, + maxiter=maxiter) + big_vecs = sp.csr_matrix(big_vecs, dtype=complex) + if num_small > 0: + small_vals, small_vecs = sp.linalg.eigsh( + data, k=num_small, which='SA', + tol=tol, maxiter=maxiter) + + else: + if num_large > 0: + big_vals, big_vecs = sp.linalg.eigs(data, k=num_large, + which='LR', tol=tol, + maxiter=maxiter) + big_vecs = sp.csr_matrix(big_vecs, dtype=complex) + if num_small > 0: + small_vals, small_vecs = sp.linalg.eigs( + data, k=num_small, which='SR', + tol=tol, maxiter=maxiter) + + if num_large != 0 and num_small != 0: + evecs = sp.hstack([small_vecs, big_vecs], format='csr') + elif num_large != 0 and num_small == 0: + evecs = big_vecs + elif num_large == 0 and num_small != 0: + evecs = small_vecs + else: + if isherm: + if num_large > 0: + big_vals = sp.linalg.eigsh( + data, k=num_large, which='LA', + return_eigenvectors=False, tol=tol, maxiter=maxiter) + if num_small > 0: + small_vals = sp.linalg.eigsh( + data, k=num_small, which='SA', + return_eigenvectors=False, tol=tol, maxiter=maxiter) + else: + if num_large > 0: + big_vals = sp.linalg.eigs( + data, k=num_large, which='LR', + return_eigenvectors=False, tol=tol, maxiter=maxiter) + if num_small > 0: + small_vals = sp.linalg.eigs( + data, k=num_small, which='SR', + return_eigenvectors=False, tol=tol, maxiter=maxiter) + + evals = np.hstack((small_vals, big_vals)) + if isherm: + evals = np.real(evals) + + _zipped = list(zip(evals, range(len(evals)))) + _zipped.sort() + evals, perm = list(zip(*_zipped)) + + if vecs: + evecs = np.array([evecs[:, k] for k in perm]) + + # remove last element if requesting N-1 eigs and using sparse + if remove_one: + evals = np.delete(evals, -1) + if vecs: + evecs = np.delete(evecs, -1) + + return np.array(evals), np.array(evecs) + + +def sp_eigs(data, isherm, vecs=True, sparse=False, sort='low', + eigvals=0, tol=0, maxiter=100000): + """Returns Eigenvalues and Eigenvectors for a sparse matrix. + Uses dense eigen-solver unless user sets sparse=True. + + Args: + data (csr_matrix): Input matrix. + + isherm (bool): Indicate whether the matrix is hermitian or not + + vecs (bool): Flag for requesting eigenvectors + + sparse (bool): Flag to use sparse solver + + sort (str): Return lowest or highest eigenvals/vecs + + eigvals (int): Number of eigenvals/vecs to return. + Default = 0 (return all) + + tol (float): Tolerance for sparse eigensolver. + Default = 0 (Machine precision) + + maxiter (int): Max. number of iterations used by sparse sigensolver. + + Returns: + array: Eigenvalues and (by default) array of corresponding Eigenvectors. + + Raises: + TypeError: Invalid input. + ValueError: Invalid input. + + """ + if data.shape[0] != data.shape[1]: + raise TypeError("Can only diagonalize square matrices") + + N = data.shape[0] + if eigvals == N: + eigvals = 0 + + if eigvals > N: + raise ValueError("Number of requested eigen vals/vecs must be <= N.") + + # set number of large and small eigenvals/vecs + if eigvals == 0: # user wants all eigs (default) + D = int(np.ceil(N / 2.0)) + num_large = N - D + if not np.mod(N, 2): + M = D + else: + M = D - 1 + num_small = N - M + else: # if user wants only a few eigen vals/vecs + if sort == 'low': + num_small = eigvals + num_large = 0 + elif sort == 'high': + num_large = eigvals + num_small = 0 + else: + raise ValueError("Invalid option for 'sort'.") + + # Dispatch to sparse/dense solvers + if sparse: + evals, evecs = _sp_eigs(data, isherm, vecs, N, eigvals, num_large, + num_small, tol, maxiter) + else: + evals, evecs = _dense_eigs(data.todense(), isherm, vecs, N, eigvals, + num_large, num_small) + + if sort == 'high': # flip arrays to largest values first + if vecs: + evecs = np.flipud(evecs) + evals = np.flipud(evals) + + return (evals, evecs) if vecs else evals + + +def sp_expm(A, sparse=False): + """ + Sparse matrix exponential. + """ + if _isdiag(A.indices, A.indptr, A.shape[0]): + A = sp.diags(np.exp(A.diagonal()), shape=A.shape, + format='csr', dtype=complex) + return A + if sparse: + E = spla.expm(A.tocsc()) + else: + E = spla.expm(A.toarray()) + return sp.csr_matrix(E) + + +def sp_permute(A, rperm=(), cperm=(), safe=True): + """ + Permutes the rows and columns of a sparse CSR/CSC matrix + according to the permutation arrays rperm and cperm, respectively. + Here, the permutation arrays specify the new order of the rows and + columns. i.e. [0,1,2,3,4] -> [3,0,4,1,2]. + + Args: + A (csr_matrix): Input matrix. + + rperm (ndarray): Array of row permutations. + + cperm (ndarray): Array of column permutations. + + safe (bool): Check structure of permutation arrays. + + Returns: + csr_matrix: CSR matrix with permuted rows/columns. + + Raises: + ValueError: Invalid input. + + """ + rperm = np.asarray(rperm, dtype=np.int32) + cperm = np.asarray(cperm, dtype=np.int32) + nrows = A.shape[0] + ncols = A.shape[1] + if len(rperm) == 0: + rperm = np.arange(nrows, dtype=np.int32) + if len(cperm) == 0: + cperm = np.arange(ncols, dtype=np.int32) + if safe: + if len(np.setdiff1d(rperm, np.arange(nrows))) != 0: + raise ValueError('Invalid row permutation array.') + if len(np.setdiff1d(cperm, np.arange(ncols))) != 0: + raise ValueError('Invalid column permutation array.') + + shp = A.shape + kind = A.getformat() + if kind == 'csr': + flag = 0 + elif kind == 'csc': + flag = 1 + else: + raise ValueError('Input must be Qobj, CSR, or CSC matrix.') + + data, ind, ptr = _sparse_permute(A.data, A.indices, A.indptr, + nrows, ncols, rperm, cperm, flag) + if kind == 'csr': + return fast_csr_matrix((data, ind, ptr), shape=shp) + elif kind == 'csc': + return sp.csc_matrix((data, ind, ptr), shape=shp, dtype=data.dtype) + + +def sp_reverse_permute(A, rperm=(), cperm=(), safe=True): + """ + Performs a reverse permutations of the rows and columns of a sparse CSR/CSC + matrix according to the permutation arrays rperm and cperm, respectively. + Here, the permutation arrays specify the order of the rows and columns used + to permute the original array. + + Args: + A (csr_matrix): Input matrix. + + rperm (ndarray): Array of row permutations. + + cperm (ndarray): Array of column permutations. + + safe (bool): Check structure of permutation arrays. + + Returns: + csr_matrix: CSR matrix with permuted rows/columns. + + Raises: + Exception: Invalid permutation. + + """ + rperm = np.asarray(rperm, dtype=np.int32) + cperm = np.asarray(cperm, dtype=np.int32) + nrows = A.shape[0] + ncols = A.shape[1] + if len(rperm) == 0: + rperm = np.arange(nrows, dtype=np.int32) + if len(cperm) == 0: + cperm = np.arange(ncols, dtype=np.int32) + if safe: + if len(np.setdiff1d(rperm, np.arange(nrows))) != 0: + raise Exception('Invalid row permutation array.') + if len(np.setdiff1d(cperm, np.arange(ncols))) != 0: + raise Exception('Invalid column permutation array.') + + shp = A.shape + kind = A.getformat() + if kind == 'csr': + flag = 0 + elif kind == 'csc': + flag = 1 + else: + raise Exception('Input must be Qobj, CSR, or CSC matrix.') + + data, ind, ptr = _sparse_reverse_permute(A.data, A.indices, A.indptr, + nrows, ncols, rperm, cperm, flag) + + if kind == 'csr': + return fast_csr_matrix((data, ind, ptr), shape=shp) + elif kind == 'csc': + return sp.csc_matrix((data, ind, ptr), shape=shp, dtype=data.dtype) + + +def sp_bandwidth(A): + """ + Returns the max(mb), lower(lb), and upper(ub) bandwidths of a + sparse CSR/CSC matrix. + + If the matrix is symmetric then the upper and lower bandwidths are + identical. Diagonal matrices have a bandwidth equal to one. + + Args: + A (csr_matrix): Input matrix + + Returns: + tuple: Maximum, lower, and upper bandwidths + + Raises: + Exception: Invalid input. + + """ + nrows = A.shape[0] + ncols = A.shape[1] + + if A.getformat() == 'csr': + return _sparse_bandwidth(A.indices, A.indptr, nrows) + elif A.getformat() == 'csc': + # Normal output is mb,lb,ub but since CSC + # is transpose of CSR switch lb and ub + mb, ub, lb = _sparse_bandwidth(A.indices, A.indptr, ncols) + return mb, lb, ub + else: + raise Exception('Invalid sparse input format.') + + +def sp_profile(A): + """Returns the total, lower, and upper profiles of a sparse matrix. + + If the matrix is symmetric then the upper and lower profiles are + identical. Diagonal matrices have zero profile. + + Args: + A (csr_matrix): Input matrix + + Returns: + tuple: Maximum, lower, and upper profiles. + + Raises: + TypeError: Invalid inputs. + """ + if sp.isspmatrix_csr(A): + up = _sparse_profile(A.indices, A.indptr, A.shape[0]) + A = A.tocsc() + lp = _sparse_profile(A.indices, A.indptr, A.shape[0]) + + elif sp.isspmatrix_csc(A): + lp = _sparse_profile(A.indices, A.indptr, A.shape[0]) + A = A.tocsr() + up = _sparse_profile(A.indices, A.indptr, A.shape[0]) + + else: + raise TypeError('Input sparse matrix must be in CSR or CSC format.') + + return up+lp, lp, up + + +def sp_isdiag(A): + """Determine if sparse CSR matrix is diagonal. + + Args: + A (csr_matrix); Input matrix + + Returns: + int: True if matix is diagonal, False otherwise. + + Raises: + TypeError: Invalid input. + + """ + if not sp.isspmatrix_csr(A): + raise TypeError('Input sparse matrix must be in CSR format.') + return _isdiag(A.indices, A.indptr, A.shape[0]) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/states.py b/qiskit/providers/aer/openpulse/qutip_lite/states.py new file mode 100755 index 0000000000..bce56a0272 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/states.py @@ -0,0 +1,358 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +# pylint: disable=invalid-name + +"""States +""" + +import numpy as np +from scipy import arange, conj +import scipy.sparse as sp + +from .qobj import Qobj +from .operators import destroy +from .fastsparse import fast_csr_matrix + + +def basis(N, n=0, offset=0): + """Generates the vector representation of a Fock state. + + Args: + N (int): Number of Fock states in Hilbert space. + + n (int): Integer corresponding to desired number + state, defaults to 0 if omitted. + + offset (int): The lowest number state that is included + in the finite number state representation + of the state. + + Returns: + Qobj: Qobj representing the requested number state ``|n>``. + + Raises: + ValueError: Invalid input value. + + """ + if (not isinstance(N, (int, np.integer))) or N < 0: + raise ValueError("N must be integer N >= 0") + + if (not isinstance(n, (int, np.integer))) or n < offset: + raise ValueError("n must be integer n >= 0") + + if n - offset > (N - 1): # check if n is within bounds + raise ValueError("basis vector index need to be in n <= N-1") + + data = np.array([1], dtype=complex) + ind = np.array([0], dtype=np.int32) + ptr = np.array([0]*((n - offset)+1)+[1]*(N-(n-offset)), dtype=np.int32) + + return Qobj(fast_csr_matrix((data, ind, ptr), shape=(N, 1)), isherm=False) + + +def qutrit_basis(): + """Basis states for a three level system (qutrit) + + Returns: + array: Array of qutrit basis vectors + + """ + return np.array([basis(3, 0), basis(3, 1), basis(3, 2)], dtype=object) + + +def coherent(N, alpha, offset=0, method='operator'): + """Generates a coherent state with eigenvalue alpha. + + Constructed using displacement operator on vacuum state. + + Args: + N (int): Number of Fock states in Hilbert space. + + alpha (complex): Eigenvalue of coherent state. + + offset (int): The lowest number state that is included in the finite + number state representation of the state. Using a + non-zero offset will make the default method 'analytic'. + + method (str): Method for generating coherent state. + + Returns: + Qobj: Qobj quantum object for coherent state + + Raises: + TypeError: Invalid input. + + """ + if method == "operator" and offset == 0: + + x = basis(N, 0) + a = destroy(N) + D = (alpha * a.dag() - conj(alpha) * a).expm() + return D * x + + elif method == "analytic" or offset > 0: + + sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex)) + sqrtn[0] = 1 # Get rid of divide by zero warning + data = alpha/sqrtn + if offset == 0: + data[0] = np.exp(-abs(alpha)**2 / 2.0) + else: + s = np.prod(np.sqrt(np.arange(1, offset + 1))) # sqrt factorial + data[0] = np.exp(-abs(alpha)**2 / 2.0) * alpha**(offset) / s + np.cumprod(data, out=sqrtn) # Reuse sqrtn array + return Qobj(sqrtn) + + else: + raise TypeError( + "The method option can only take values 'operator' or 'analytic'") + + +def coherent_dm(N, alpha, offset=0, method='operator'): + """Density matrix representation of a coherent state. + + Constructed via outer product of :func:`qutip.states.coherent` + + Parameters: + N (int): Number of Fock states in Hilbert space. + + alpha (complex): Eigenvalue for coherent state. + + offset (int): The lowest number state that is included in the + finite number state representation of the state. + + method (str): Method for generating coherent density matrix. + + Returns: + Qobj: Density matrix representation of coherent state. + + Raises: + TypeError: Invalid input. + + """ + if method == "operator": + psi = coherent(N, alpha, offset=offset) + return psi * psi.dag() + + elif method == "analytic": + psi = coherent(N, alpha, offset=offset, method='analytic') + return psi * psi.dag() + + else: + raise TypeError( + "The method option can only take values 'operator' or 'analytic'") + + +def fock_dm(N, n=0, offset=0): + """Density matrix representation of a Fock state + + Constructed via outer product of :func:`qutip.states.fock`. + + Args: + N (int): Number of Fock states in Hilbert space. + + n (int): Desired number state, defaults to 0 if omitted. + + offset (int): Energy level offset. + + Returns: + Qobj: Density matrix representation of Fock state. + + """ + psi = basis(N, n, offset=offset) + + return psi * psi.dag() + + +def fock(N, n=0, offset=0): + """Bosonic Fock (number) state. + + Same as :func:`qutip.states.basis`. + + Args: + N (int): Number of states in the Hilbert space. + + n (int): Desired number state, defaults to 0 if omitted. + + offset (int): Energy level offset. + + Returns: + Qobj: Requested number state :math:`\\left|n\\right>`. + + """ + return basis(N, n, offset=offset) + + +def thermal_dm(N, n, method='operator'): + """Density matrix for a thermal state of n particles + + Args: + N (int): Number of basis states in Hilbert space. + + n (float): Expectation value for number of particles + in thermal state. + + method (str): Sets the method used to generate the + thermal state probabilities + + Returns: + Qobj: Thermal state density matrix. + + Raises: + ValueError: Invalid input. + + """ + if n == 0: + return fock_dm(N, 0) + else: + i = arange(N) + if method == 'operator': + beta = np.log(1.0 / n + 1.0) + diags = np.exp(-beta * i) + diags = diags / np.sum(diags) + # populates diagonal terms using truncated operator expression + rm = sp.spdiags(diags, 0, N, N, format='csr') + elif method == 'analytic': + # populates diagonal terms using analytic values + rm = sp.spdiags((1.0 + n) ** (-1.0) * (n / (1.0 + n)) ** (i), + 0, N, N, format='csr') + else: + raise ValueError( + "'method' keyword argument must be 'operator' or 'analytic'") + return Qobj(rm) + + +def maximally_mixed_dm(N): + """ + Returns the maximally mixed density matrix for a Hilbert space of + dimension N. + + Args: + N (int): Number of basis states in Hilbert space. + + Returns: + Qobj: Thermal state density matrix. + + Raises: + ValueError: Invalid input. + """ + if (not isinstance(N, (int, np.int64))) or N <= 0: + raise ValueError("N must be integer N > 0") + + dm = sp.spdiags(np.ones(N, dtype=complex)/float(N), 0, N, N, format='csr') + + return Qobj(dm, isherm=True) + + +def ket2dm(Q): + """Takes input ket or bra vector and returns density matrix + formed by outer product. + + Args: + Q (Qobj): Ket or bra type quantum object. + + Returns: + Qobj: Density matrix formed by outer product of `Q`. + + Raises: + TypeError: Invalid input. + """ + if Q.type == 'ket': + out = Q * Q.dag() + elif Q.type == 'bra': + out = Q.dag() * Q + else: + raise TypeError("Input is not a ket or bra vector.") + return Qobj(out) + + +# +# projection operator +# +def projection(N, n, m, offset=0): + """The projection operator that projects state :math:`|m>` on state :math:`|n>`. + + Args: + N (int): Number of basis states in Hilbert space. + + n (float): The number states in the projection. + + m (float): The number states in the projection. + + offset (int): The lowest number state that is included in + the finite number state representation of the projector. + + Returns: + Qobj: Requested projection operator. + + """ + ket1 = basis(N, n, offset=offset) + ket2 = basis(N, m, offset=offset) + + return ket1 * ket2.dag() + + +def zero_ket(N, dims=None): + """ + Creates the zero ket vector with shape Nx1 and + dimensions `dims`. + + Parameters + ---------- + N : int + Hilbert space dimensionality + dims : list + Optional dimensions if ket corresponds to + a composite Hilbert space. + + Returns + ------- + zero_ket : qobj + Zero ket on given Hilbert space. + + """ + return Qobj(sp.csr_matrix((N, 1), dtype=complex), dims=dims) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py b/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py new file mode 100755 index 0000000000..8d701db624 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py @@ -0,0 +1,326 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +# pylint: disable=invalid-name + +""" +Module for super operators. +""" + +import numpy as np +from .qobj import Qobj +from .fastsparse import fast_csr_matrix, fast_identity +from .sparse import sp_reshape +from .cy.spmath import zcsr_kron # pylint: disable=no-name-in-module + +# pylint: disable=dangerous-default-value +def liouvillian(H, c_ops=[], data_only=False, chi=None): + """Assembles the Liouvillian superoperator from a Hamiltonian + and a ``list`` of collapse operators. + + Args: + H (qobj.Qobj): System Hamiltonian. + + c_ops (qobj.Qobj or array_like): A single collapse operator + or an array. + data_only (bool): Return data only. + + chi (flaot): Multiplication factor. + + Returns: + qobj.Qobj: Liouvillian superoperator. + + Raises: + ValueError: Chi must be list of len(c_ops). + TypeError: Invalidinput types. + + """ + if isinstance(c_ops, (Qobj)): + c_ops = [c_ops] + if chi and len(chi) != len(c_ops): + raise ValueError('chi must be a list with same length as c_ops') + + h = None + if H is not None: + h = H + if h.isoper: + op_dims = h.dims + op_shape = h.shape + elif h.issuper: + op_dims = h.dims[0] + op_shape = [np.prod(op_dims[0]), np.prod(op_dims[0])] + else: + raise TypeError("Invalid type for Hamiltonian.") + else: + # no hamiltonian given, pick system size from a collapse operator + if isinstance(c_ops, list) and any(c_ops) > 0: + c = c_ops[0] + if c.isoper: + op_dims = c.dims + op_shape = c.shape + elif c.issuper: + op_dims = c.dims[0] + op_shape = [np.prod(op_dims[0]), np.prod(op_dims[0])] + else: + raise TypeError("Invalid type for collapse operator.") + else: + raise TypeError("Either H or c_ops must be given.") + + sop_dims = [[op_dims[0], op_dims[0]], [op_dims[1], op_dims[1]]] + sop_shape = [np.prod(op_dims), np.prod(op_dims)] + + spI = fast_identity(op_shape[0]) + + L = None + if isinstance(H, Qobj): + if H.isoper: + Ht = H.data.T + data = -1j * zcsr_kron(spI, H.data) + data += 1j * zcsr_kron(Ht, spI) + else: + data = H.data + else: + data = fast_csr_matrix(shape=(sop_shape[0], sop_shape[1])) + + for idx, c_op in enumerate(c_ops): + c_ = c_op + + if c_.issuper: + data = data + c_.data + else: + cd = c_.data.H + c = c_.data + if chi: + data = data + np.exp(1j * chi[idx]) * \ + zcsr_kron(c.conj(), c) + else: + data = data + zcsr_kron(c.conj(), c) + cdc = cd * c + cdct = cdc.T + data = data - 0.5 * zcsr_kron(spI, cdc) + data = data - 0.5 * zcsr_kron(cdct, spI) + + if data_only: + return data + else: + L = Qobj() + L.dims = sop_dims + L.data = data + L.superrep = 'super' + return L + + +def lindblad_dissipator(a, b=None, data_only=False, chi=None): + """ + Lindblad dissipator (generalized) for a single pair of collapse operators + (a, b), or for a single collapse operator (a) when b is not specified: + + .. math:: + + \\mathcal{D}[a,b]\\rho = a \\rho b^\\dagger - + \\frac{1}{2}a^\\dagger b\\rho - \\frac{1}{2}\\rho a^\\dagger b + + Args: + a (Qobj): Left part of collapse operator. + + b (Qobj): Right part of collapse operator. If not specified, + b defaults to a. + + data_only (bool): Return data only. + + chi (flaot): Multiplication factor. + + Returns: + Qobj: Lindblad dissipator superoperator. + """ + if b is None: + b = a + ad_b = a.dag() * b + if chi: + D = spre(a) * spost(b.dag()) * np.exp(1j * chi) \ + - 0.5 * spre(ad_b) - 0.5 * spost(ad_b) + else: + D = spre(a) * spost(b.dag()) - 0.5 * spre(ad_b) - 0.5 * spost(ad_b) + + return D.data if data_only else D + + +def operator_to_vector(op): + """ + Create a vector representation of a quantum operator given + the matrix representation. + """ + q = Qobj() + q.dims = [op.dims, [1]] + q.data = sp_reshape(op.data.T, (np.prod(op.shape), 1)) + return q + + +def vector_to_operator(op): + """ + Create a matrix representation given a quantum operator in + vector form. + """ + q = Qobj() + q.dims = op.dims[0] + n = int(np.sqrt(op.shape[0])) + q.data = sp_reshape(op.data.T, (n, n)).T + return q + + +def mat2vec(mat): + """ + Private function reshaping matrix to vector. + """ + return mat.T.reshape(np.prod(np.shape(mat)), 1) + + +def vec2mat(vec): + """ + Private function reshaping vector to matrix. + """ + n = int(np.sqrt(len(vec))) + return vec.reshape((n, n)).T + + +def vec2mat_index(N, I): + """ + Convert a vector index to a matrix index pair that is compatible with the + vector to matrix rearrangement done by the vec2mat function. + """ + j = int(I / N) + i = I - N * j + return i, j + + +def mat2vec_index(N, i, j): + """ + Convert a matrix index pair to a vector index that is compatible with the + matrix to vector rearrangement done by the mat2vec function. + """ + return i + N * j + + +def spost(A): + """Superoperator formed from post-multiplication by operator A + + Args: + A (Qobj): Quantum operator for post multiplication. + + Returns: + Qobj: Superoperator formed from input qauntum object. + + Raises: + TypeError: Invalid inputs. + """ + if not isinstance(A, Qobj): + raise TypeError('Input is not a quantum object') + + if not A.isoper: + raise TypeError('Input is not a quantum operator') + + S = Qobj(isherm=A.isherm, superrep='super') + S.dims = [[A.dims[0], A.dims[1]], [A.dims[0], A.dims[1]]] + S.data = zcsr_kron(A.data.T, + fast_identity(np.prod(A.shape[0]))) + return S + + +def spre(A): + """Superoperator formed from pre-multiplication by operator A. + + Args: + A (Qobj): Quantum operator for pre-multiplication. + + Returns: + Qobj: Superoperator formed from input quantum object. + + Raises: + TypeError: Invalid input type. + """ + if not isinstance(A, Qobj): + raise TypeError('Input is not a quantum object') + + if not A.isoper: + raise TypeError('Input is not a quantum operator') + + S = Qobj(isherm=A.isherm, superrep='super') + S.dims = [[A.dims[0], A.dims[1]], [A.dims[0], A.dims[1]]] + S.data = zcsr_kron(fast_identity(np.prod(A.shape[1])), A.data) + return S + + +def _drop_projected_dims(dims): + """ + Eliminate subsystems that has been collapsed to only one state due to + a projection. + """ + return [d for d in dims if d != 1] + + +def sprepost(A, B): + """Superoperator formed from pre-multiplication by operator A and post- + multiplication of operator B. + + Parameters + ---------- + A : Qobj or QobjEvo + Quantum operator for pre-multiplication. + + B : Qobj or QobjEvo + Quantum operator for post-multiplication. + + Returns + -------- + super : Qobj or QobjEvo + Superoperator formed from input quantum objects. + """ + dims = [[_drop_projected_dims(A.dims[0]), + _drop_projected_dims(B.dims[1])], + [_drop_projected_dims(A.dims[1]), + _drop_projected_dims(B.dims[0])]] + data = zcsr_kron(B.data.T, A.data) + return Qobj(data, dims=dims, superrep='super') diff --git a/qiskit/providers/aer/openpulse/qutip_lite/tensor.py b/qiskit/providers/aer/openpulse/qutip_lite/tensor.py new file mode 100755 index 0000000000..636c84ba21 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/tensor.py @@ -0,0 +1,111 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# +# Redistribution and use in source and binary forms, with or without +# modification, are permitted provided that the following conditions are +# met: +# +# 1. Redistributions of source code must retain the above copyright notice, +# this list of conditions and the following disclaimer. +# +# 2. Redistributions in binary form must reproduce the above copyright +# notice, this list of conditions and the following disclaimer in the +# documentation and/or other materials provided with the distribution. +# +# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names +# of its contributors may be used to endorse or promote products derived +# from this software without specific prior written permission. +# +# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A +# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. +############################################################################### +""" +Module for the creation of composite quantum objects via the tensor product. +""" + +import numpy as np +from .cy.spmath import zcsr_kron # pylint: disable=no-name-in-module +from .qobj import Qobj +from ..qutip_lite.settings import auto_tidyup + + +def tensor(*args): + """Calculates the tensor product of input operators. + + Args: + args (array_like): List or array of quantum objects for tensor product. + + Returns: + qobj.Qobj: A composite quantum object. + + Raises: + TypeError: Requires at least one input argument. + """ + if not args: + raise TypeError("Requires at least one input argument") + + if len(args) == 1 and isinstance(args[0], (list, np.ndarray)): + # this is the case when tensor is called on the form: + # tensor([q1, q2, q3, ...]) + qlist = args[0] + + elif len(args) == 1 and isinstance(args[0], Qobj): + # tensor is called with a single Qobj as an argument, do nothing + return args[0] + + else: + # this is the case when tensor is called on the form: + # tensor(q1, q2, q3, ...) + qlist = args + + if not all([isinstance(q, Qobj) for q in qlist]): + # raise error if one of the inputs is not a quantum object + raise TypeError("One of inputs is not a quantum object") + + out = Qobj() + if qlist[0].issuper: + out.superrep = qlist[0].superrep + if not all([q.superrep == out.superrep for q in qlist]): + raise TypeError("In tensor products of superroperators, all must" + + "have the same representation") + + out.isherm = True + for n, q in enumerate(qlist): + if n == 0: + out.data = q.data + out.dims = q.dims + else: + out.data = zcsr_kron(out.data, q.data) + out.dims = [out.dims[0] + q.dims[0], out.dims[1] + q.dims[1]] + + out.isherm = out.isherm and q.isherm + + if not out.isherm: + out._isherm = None + + return out.tidyup() if auto_tidyup else out diff --git a/qiskit/providers/aer/openpulse/readme.md b/qiskit/providers/aer/openpulse/readme.md new file mode 100644 index 0000000000..87c74c5ed3 --- /dev/null +++ b/qiskit/providers/aer/openpulse/readme.md @@ -0,0 +1,59 @@ +# Openpulse + +This simulates job using the open pulse format (see the spec). + +## Example + +XXX + +## Hamiltonian + +One of the main components of the open pulse simulator is the specification +of the Hamiltonian. The Hamiltonian dictates how the simulation will evolve +the dynamics based on the pulse schedule. + +There are two allowed components to a simulation, *qubits* and *oscillators*. +*Qubits* are the objects that will be measured at the end of the simulation. +The operators for qubits are defined as Pauli's but if the number of levels +is defined by be greater than 2 these will be internally converted to +creation and annhilation operators. + +The Hamiltonian is a dictionary comparised of +- `h_str`: Definition of the Hamiltonian in terms of operators, drives and +coefficients +- `vars`: Numeric values for the variables in the Hamiltonian +- `qubs`: Dictionary indicating the number of levels for each qubit to +use in the simulation +- `osc`: Dictionary indicating the number of levels for each oscillator to +use in the simulation + +There must be qubits, but there does not need to be oscillators. Measurements +are given by the qubit state; the measurement process is not simulated. + +### `h_str` Syntax + +The `h_str` is a list of strings which indicate various terms in the +Hamiltonian. These can have the form + +`||` or `` + +where `` is a string form of an operator with coefficients and `` +indicates one of the time-dependent drive channels (e.g. `D2` or `U10`). +Additionally, there is a sum form +`_SUM[i,n1,n2,F[{i}]]` where {i} is replaced in each loop by the value. + +## Solving + +The solver takes the Hamiltonian (`H(t=0)`) and sets all drive/control channels to zero. +Consider `H_d` to be the diagonal elements of `H(t=0)`, then the transformation applied is +`U=e^{-i H_d t/hbar}`. For all drive/control channels, the LO is applied so +`d(t) -> D(t)e^{-i w t}`. If the drive is associated with some operator *B* then +the upper triangular part of *B* is multiplied by `d(t)` and the lower triangular part +by `d*(t)`. This ensures the Hamiltonian is Hermitian and also that in the transformed +frame that a resonant pulse is close to DC. + +### Measurement + +The measurement operators are the projections onto the 1 excitation subsystem for qubit `l` +where qubit `l` is defined by diagonalizing `H(t=0)` (i.e. the dressed basis). + diff --git a/qiskit/providers/aer/openpulse/solver/__init__.py b/qiskit/providers/aer/openpulse/solver/__init__.py new file mode 100644 index 0000000000..7909fc6dac --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/__init__.py @@ -0,0 +1,13 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. diff --git a/qiskit/providers/aer/openpulse/solver/codegen.py b/qiskit/providers/aer/openpulse/solver/codegen.py new file mode 100644 index 0000000000..c6dbfe3f85 --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/codegen.py @@ -0,0 +1,282 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# pylint: disable=invalid-name + +"""OpenPulse runtime code generator""" + +import os +import sys +from ..qutip_lite import cy +from . import settings + +_cython_path = os.path.abspath(cy.__file__).replace('__init__.py', '') +_cython_path = _cython_path.replace("\\", "/") +_include_string = "'"+_cython_path+"complex_math.pxi'" + + +class OPCodegen(object): + """ + Class for generating cython code files at runtime. + """ + def __init__(self, op_system): + + sys.path.append(os.getcwd()) + + # Hamiltonian time-depdendent pieces + self.op_system = op_system + self.dt = op_system.dt + + self.num_ham_terms = self.op_system.global_data['num_h_terms'] + + # Code generator properties + self._file = None + self.code = [] # strings to be written to file + self.level = 0 # indent level + self.spline_count = 0 + + def write(self, string): + """write lines of code to self.code""" + self.code.append(" " * self.level + string + "\n") + + def file(self, filename): + """open file called filename for writing""" + self._file = open(filename, "w") + + def generate(self, filename="rhs.pyx"): + """generate the file""" + + for line in cython_preamble(): + self.write(line) + + # write function for Hamiltonian terms (there is always at least one + # term) + for line in cython_checks() + self.ODE_func_header(): + self.write(line) + self.indent() + for line in func_header(self.op_system): + self.write(line) + for line in self.channels(): + self.write(line) + for line in self.func_vars(): + self.write(line) + for line in self.func_end(): + self.write(line) + self.dedent() + + self.file(filename) + self._file.writelines(self.code) + self._file.close() + settings.CGEN_NUM += 1 + + def indent(self): + """increase indention level by one""" + self.level += 1 + + def dedent(self): + """decrease indention level by one""" + if self.level == 0: + raise SyntaxError("Error in code generator") + self.level -= 1 + + def ODE_func_header(self): + """Creates function header for time-dependent ODE RHS.""" + func_name = "def cy_td_ode_rhs(" + # strings for time and vector variables + input_vars = ("\n double t" + + ",\n complex[::1] vec") + + # add diagonal hamiltonian terms + input_vars += (",\n double[::1] energ") + + for k in range(self.num_ham_terms): + input_vars += (",\n " + + "complex[::1] data%d, " % k + + "int[::1] idx%d, " % k + + "int[::1] ptr%d" % k) + + #Add global vaiables + input_vars += (",\n " + "complex[::1] pulse_array") + input_vars += (",\n " + "unsigned int[::1] pulse_indices") + + #Add per experiment variables + for key in self.op_system.channels.keys(): + input_vars += (",\n " + "double[::1] %s_pulses" % key) + input_vars += (",\n " + "double[::1] %s_fc" % key) + + # add Hamiltonian variables + for key in self.op_system.vars.keys(): + input_vars += (",\n " + "complex %s" % key) + + # add Freq variables + for key in self.op_system.freqs.keys(): + input_vars += (",\n " + "double %s_freq" % key) + + # register + input_vars += (",\n " + "unsigned char[::1] register") + + func_end = "):" + return [func_name + input_vars + func_end] + + + def channels(self): + """Write out the channels + """ + channel_lines = [""] + + channel_lines.append("# Compute complex channel values at time `t`") + for chan, idx in self.op_system.channels.items(): + chan_str = "%s = chan_value(t, %s, %s_freq, " %(chan, idx, chan) + \ + "%s_pulses, pulse_array, pulse_indices, " % chan + \ + "%s_fc, register)" % (chan) + channel_lines.append(chan_str) + channel_lines.append('') + return channel_lines + + + def func_vars(self): + """Writes the variables and spmv parts""" + func_vars = [] + sp1 = " " + sp2 = sp1+sp1 + + func_vars.append("# Eval the time-dependent terms and do SPMV.") + for idx in range(len(self.op_system.system)+1): + + if (idx == len(self.op_system.system) and + (len(self.op_system.system) < self.num_ham_terms)): + #this is the noise term + term = [1.0, 1.0] + elif idx < len(self.op_system.system): + term = self.op_system.system[idx] + else: + continue + + if isinstance(term, list) or term[1]: + func_vars.append("td%s = %s" % (idx, term[1])) + else: + func_vars.append("td%s = 1.0" % (idx)) + + func_vars.append("if abs(td%s) > 1e-15:" % idx) + + func_vars.append(sp1 + "for row in range(num_rows):") + func_vars.append(sp2 + "dot = 0;") + func_vars.append(sp2 + "row_start = ptr%d[row];"%idx) + func_vars.append(sp2 + "row_end = ptr%d[row+1];"%idx) + func_vars.append(sp2 + "for jj in range(row_start,row_end):") + func_vars.append(sp1 + + sp2 + + "osc_term = exp(1j*(energ[row]-energ[idx%d[jj]])*t)"%idx) + func_vars.append(sp1 + sp2 + "if rowPyDataMem_NEW_ZEROED(num_rows,sizeof(complex))' + ] + func_vars.append("") + + for val in op_system.channels: + func_vars.append("cdef double complex %s" % val) + + for kk in range(len(op_system.system)+1): + func_vars.append("cdef double complex td%s" % kk) + + return func_vars + +def cython_preamble(): + """ + Returns list of code segments for Cython preamble. + """ + preamble = ["""\ +#!python +#cython: language_level=3 +# This code is part of Qiskit. +# +# (C) Copyright IBM 2017, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +import numpy as np +cimport numpy as np +cimport cython +np.import_array() +cdef extern from "numpy/arrayobject.h" nogil: + void PyDataMem_NEW_ZEROED(size_t size, size_t elsize) + void PyArray_ENABLEFLAGS(np.ndarray arr, int flags) + +cdef extern from "" namespace "std" nogil: + double complex exp(double complex x) + +cdef extern from "" namespace "std" nogil: + double complex conj(double complex x) + +from qiskit.providers.aer.openpulse.qutip_lite.cy.spmatfuncs cimport spmvpy +from qiskit.providers.aer.openpulse.qutip_lite.cy.math cimport erf +from libc.math cimport pi + +from qiskit.providers.aer.openpulse.cy.channel_value cimport chan_value + +include """+_include_string+""" +"""] + return preamble + + +def cython_checks(): + """ + List of strings that turn off Cython checks. + """ + return ["""@cython.cdivision(True) +@cython.boundscheck(False) +@cython.wraparound(False)"""] diff --git a/qiskit/providers/aer/openpulse/solver/data_config.py b/qiskit/providers/aer/openpulse/solver/data_config.py new file mode 100644 index 0000000000..01deec2ae3 --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/data_config.py @@ -0,0 +1,124 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=invalid-name + +"""Data configuration module""" + +import numpy as np +pi = np.pi + +def op_data_config(op_system): + """ Preps the data for the opsolver. + + Everything is stored in the passed op_system. + + Args: + op_system (OPSystem): An openpulse system. + """ + + num_h_terms = len(op_system.system) + H = [hpart[0] for hpart in op_system.system] + op_system.global_data['num_h_terms'] = num_h_terms + + # take care of collapse operators, if any + op_system.global_data['c_num'] = 0 + if op_system.noise: + op_system.global_data['c_num'] = len(op_system.noise) + op_system.global_data['num_h_terms'] += 1 + + op_system.global_data['c_ops_data'] = [] + op_system.global_data['c_ops_ind'] = [] + op_system.global_data['c_ops_ptr'] = [] + op_system.global_data['n_ops_data'] = [] + op_system.global_data['n_ops_ind'] = [] + op_system.global_data['n_ops_ptr'] = [] + + op_system.global_data['h_diag_elems'] = op_system.h_diag + + # if there are any collapse operators + H_noise = 0 + for kk in range(op_system.global_data['c_num']): + c_op = op_system.noise[kk] + n_op = c_op.dag() * c_op + # collapse ops + op_system.global_data['c_ops_data'].append(c_op.data.data) + op_system.global_data['c_ops_ind'].append(c_op.data.indices) + op_system.global_data['c_ops_ptr'].append(c_op.data.indptr) + # norm ops + op_system.global_data['n_ops_data'].append(n_op.data.data) + op_system.global_data['n_ops_ind'].append(n_op.data.indices) + op_system.global_data['n_ops_ptr'].append(n_op.data.indptr) + # Norm ops added to time-independent part of + # Hamiltonian to decrease norm + H_noise -= 0.5j * n_op + + if H_noise: + H = H + [H_noise] + + # construct data sets + op_system.global_data['h_ops_data'] = [-1.0j* hpart.data.data for hpart in H] + op_system.global_data['h_ops_ind'] = [hpart.data.indices for hpart in H] + op_system.global_data['h_ops_ptr'] = [hpart.data.indptr for hpart in H] + + # setup ode args string + ode_var_str = "" + + #diagonal elements + ode_var_str += "global_data['h_diag_elems'], " + + # Hamiltonian data + for kk in range(op_system.global_data['num_h_terms']): + h_str = "global_data['h_ops_data'][%s], " % kk + h_str += "global_data['h_ops_ind'][%s], " % kk + h_str += "global_data['h_ops_ptr'][%s], " % kk + ode_var_str += h_str + + # Add pulse array and pulse indices + ode_var_str += "global_data['pulse_array'], " + ode_var_str += "global_data['pulse_indices'], " + + var_list = list(op_system.vars.keys()) + final_var = var_list[-1] + + freq_list = list(op_system.freqs.keys()) + final_freq = freq_list[-1] + + # Now add channel variables + chan_list = list(op_system.channels.keys()) + final_chan = chan_list[-1] + for chan in chan_list: + ode_var_str += "exp['channels']['%s'][0], " % chan + ode_var_str += "exp['channels']['%s'][1]" % chan + if chan != final_chan or var_list: + ode_var_str += ', ' + + #now do the variables + for idx, var in enumerate(var_list): + ode_var_str += "global_data['vars'][%s]" % idx + if var != final_var or freq_list: + ode_var_str += ', ' + + #now do the freq + for idx, freq in enumerate(freq_list): + ode_var_str += "global_data['freqs'][%s]" % idx + if freq != final_freq: + ode_var_str += ', ' + + # Add register + ode_var_str += ", register" + op_system.global_data['string'] = ode_var_str + + #Convert inital state to flat array in global_data + op_system.global_data['initial_state'] = \ + op_system.initial_state.full().ravel() diff --git a/qiskit/providers/aer/openpulse/solver/monte_carlo.py b/qiskit/providers/aer/openpulse/solver/monte_carlo.py new file mode 100644 index 0000000000..34a9e27bdc --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/monte_carlo.py @@ -0,0 +1,177 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# pylint: disable=no-name-in-module, import-error, unused-variable, invalid-name + +"""Monte carlo wave function solver.""" + +from math import log +import numpy as np +from scipy.integrate import ode +from scipy.linalg.blas import get_blas_funcs + +from qiskit.providers.aer.openpulse.solver.zvode import qiskit_zvode +from qiskit.providers.aer.openpulse.cy.measure import (occ_probabilities, + write_shots_memory) +from ..qutip_lite.cy.spmatfuncs import cy_expect_psi_csr, spmv_csr + +dznrm2 = get_blas_funcs("znrm2", dtype=np.float64) + +def monte_carlo(seed, exp, global_data, ode_options): + """ + Monte Carlo algorithm returning state-vector or expectation values + at times tlist for a single trajectory. + """ + + cy_rhs_func = global_data['rhs_func'] + rng = np.random.RandomState(seed) + tlist = exp['tlist'] + snapshots = [] + # Init memory + memory = np.zeros((1, global_data['memory_slots']), dtype=np.uint8) + # Init register + register = np.zeros(global_data['n_registers'], dtype=np.uint8) + + # Get number of acquire, snapshots, and conditionals + num_acq = len(exp['acquire']) + acq_idx = 0 + num_snap = len(exp['snapshot']) + snap_idx = 0 + num_cond = len(exp['cond']) + cond_idx = 0 + + collapse_times = [] + collapse_operators = [] + + # first rand is collapse norm, second is which operator + rand_vals = rng.rand(2) + + ODE = ode(cy_rhs_func) + + _inst = 'ODE.set_f_params(%s)' % global_data['string'] + code = compile(_inst, '', 'exec') + # pylint: disable=exec-used + exec(code) + + # initialize ODE solver for RHS + ODE._integrator = qiskit_zvode(method=ode_options.method, + order=ode_options.order, + atol=ode_options.atol, + rtol=ode_options.rtol, + nsteps=ode_options.nsteps, + first_step=ode_options.first_step, + min_step=ode_options.min_step, + max_step=ode_options.max_step + ) + # Forces complex ODE solving + if not any(ODE._y): + ODE.t = 0.0 + ODE._y = np.array([0.0], complex) + ODE._integrator.reset(len(ODE._y), ODE.jac is not None) + + ODE.set_initial_value(global_data['initial_state'], 0) + + # make array for collapse operator inds + cinds = np.arange(global_data['c_num']) + n_dp = np.zeros(global_data['c_num'], dtype=float) + + # RUN ODE UNTIL EACH TIME IN TLIST + for stop_time in tlist: + # ODE WHILE LOOP FOR INTEGRATE UP TO TIME TLIST[k] + while ODE.t < stop_time: + t_prev = ODE.t + y_prev = ODE.y + norm2_prev = dznrm2(ODE._y) ** 2 + # integrate up to stop_time, one step at a time. + ODE.integrate(stop_time, step=1) + if not ODE.successful(): + raise Exception("ZVODE step failed!") + norm2_psi = dznrm2(ODE._y) ** 2 + if norm2_psi <= rand_vals[0]: + # collapse has occured: + # find collapse time to within specified tolerance + # ------------------------------------------------ + ii = 0 + t_final = ODE.t + while ii < ode_options.norm_steps: + ii += 1 + t_guess = t_prev + \ + log(norm2_prev / rand_vals[0]) / \ + log(norm2_prev / norm2_psi) * (t_final - t_prev) + ODE._y = y_prev + ODE.t = t_prev + ODE._integrator.call_args[3] = 1 + ODE.integrate(t_guess, step=0) + if not ODE.successful(): + raise Exception( + "ZVODE failed after adjusting step size!") + norm2_guess = dznrm2(ODE._y)**2 + if (abs(rand_vals[0] - norm2_guess) < + ode_options.norm_tol * rand_vals[0]): + break + elif norm2_guess < rand_vals[0]: + # t_guess is still > t_jump + t_final = t_guess + norm2_psi = norm2_guess + else: + # t_guess < t_jump + t_prev = t_guess + y_prev = ODE.y + norm2_prev = norm2_guess + if ii > ode_options.norm_steps: + raise Exception("Norm tolerance not reached. " + + "Increase accuracy of ODE solver or " + + "Options.norm_steps.") + + collapse_times.append(ODE.t) + # all constant collapse operators. + for i in range(n_dp.shape[0]): + n_dp[i] = cy_expect_psi_csr(global_data['n_ops_data'][i], + global_data['n_ops_ind'][i], + global_data['n_ops_ptr'][i], + ODE._y, 1) + + # determine which operator does collapse and store it + _p = np.cumsum(n_dp / np.sum(n_dp)) + j = cinds[_p >= rand_vals[1]][0] + collapse_operators.append(j) + + state = spmv_csr(global_data['c_ops_data'][j], + global_data['c_ops_ind'][j], + global_data['c_ops_ptr'][j], + ODE._y) + + state /= dznrm2(state) + ODE._y = state + ODE._integrator.call_args[3] = 1 + rand_vals = rng.rand(2) + + # after while loop (Do measurement or conditional) + # ------------------------------------------------ + out_psi = ODE._y / dznrm2(ODE._y) + for aind in range(acq_idx, num_acq): + if exp['acquire'][aind][0] == stop_time: + current_acq = exp['acquire'][aind] + qubits = current_acq[1] + memory_slots = current_acq[2] + probs = occ_probabilities(qubits, out_psi, global_data['measurement_ops']) + rand_vals = rng.rand(memory_slots.shape[0]) + write_shots_memory(memory, memory_slots, probs, rand_vals) + acq_idx += 1 + + return memory diff --git a/qiskit/providers/aer/openpulse/solver/opsolve.py b/qiskit/providers/aer/openpulse/solver/opsolve.py new file mode 100644 index 0000000000..afe410ffd5 --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/opsolve.py @@ -0,0 +1,276 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=no-name-in-module, import-error, invalid-name + +"""The main OpenPulse solver routine. +""" + +import time +import numpy as np +from scipy.linalg.blas import get_blas_funcs +from qiskit.tools.parallel import parallel_map, CPU_COUNT +from ..qutip_lite.cy.spmatfuncs import cy_expect_psi_csr +from ..qutip_lite.cy.utilities import _cython_build_cleanup +from ..qobj.operators import apply_projector +from .rhs_utils import _op_generate_rhs, _op_func_load +from .data_config import op_data_config +from .unitary import unitary_evolution +from .monte_carlo import monte_carlo + + +dznrm2 = get_blas_funcs("znrm2", dtype=np.float64) + +# +# Internal, global variables for storing references to dynamically loaded +# cython functions +# +_cy_rhs_func = None + +def opsolve(op_system): + """Opsolver + """ + + if not op_system.initial_state.isket: + raise Exception("Initial state must be a state vector.") + + # set num_cpus to the value given in settings if none in Options + if not op_system.ode_options.num_cpus: + op_system.ode_options.num_cpus = CPU_COUNT + + # build Hamiltonian data structures + op_data_config(op_system) + # compile Cython RHS + _op_generate_rhs(op_system) + # Load cython function + _op_func_load(op_system) + # load monte carlo class + montecarlo = OP_mcwf(op_system) + # Run the simulation + out = montecarlo.run() + # Results are stored in ophandler.result + return out + +# ----------------------------------------------------------------------------- +# MONTE CARLO CLASS +# ----------------------------------------------------------------------------- +class OP_mcwf(object): + """ + Private class for solving Monte Carlo evolution + """ + + def __init__(self, op_system): + + self.op_system = op_system + # set output variables, even if they are not used to simplify output + # code. + self.output = None + self.collapse_times = None + self.collapse_operator = None + + # FOR EVOLUTION WITH COLLAPSE OPERATORS + if not op_system.can_sample: + # preallocate ntraj arrays for state vectors, collapse times, and + # which operator + self.collapse_times = [[] for kk in + range(op_system.global_data['shots'])] + self.collapse_operators = [[] for kk in + range(op_system.global_data['shots'])] + # setup seeds array + if op_system.global_data['seed']: + prng = np.random.RandomState(op_system.global_data['seed']) + else: + prng = np.random.RandomState( + np.random.randint(np.iinfo(np.int32).max-1)) + for exp in op_system.experiments: + exp['seed'] = prng.randint(np.iinfo(np.int32).max-1) + + def run(self): + """Runs the solver. + """ + map_kwargs = {'num_processes': self.op_system.ode_options.num_cpus} + + + # exp_results from the solvers return the values of the measurement + # operators + + # If no collapse terms, and only measurements at end + # can do a single shot. + + # exp_results is a list of '0' and '1' + # where '0' occurs with probability 1- + # and '1' occurs with probability + # M is the measurement operator, which is a projector + # into one of the qubit states (usually |1>) + if self.op_system.can_sample: + start = time.time() + exp_results = parallel_map(unitary_evolution, + self.op_system.experiments, + task_args=(self.op_system.global_data, + self.op_system.ode_options + ), + **map_kwargs + ) + end = time.time() + exp_times = (np.ones(len(self.op_system.experiments))* + (end-start)/len(self.op_system.experiments)) + + + # need to simulate each trajectory, so shots*len(experiments) times + # Do a for-loop over experiments, and do shots in parallel_map + else: + exp_results = [] + exp_times = [] + for exp in self.op_system.experiments: + start = time.time() + rng = np.random.RandomState(exp['seed']) + seeds = rng.randint(np.iinfo(np.int32).max-1, + size=self.op_system.global_data['shots']) + exp_res = parallel_map(monte_carlo, + seeds, + task_args=(exp, self.op_system.global_data, + self.op_system.ode_options + ), + **map_kwargs + ) + + # exp_results is a list for each shot + # so transform back to an array of shots + exp_res2 = [] + for exp_shot in exp_res: + exp_res2.append(exp_shot[0].tolist()) + + + end = time.time() + exp_times.append(end-start) + exp_results.append(np.array(exp_res2)) + + + #format the data into the proper output + all_results = [] + for idx_exp, exp in enumerate(self.op_system.experiments): + + + m_lev = self.op_system.global_data['meas_level'] + m_ret = self.op_system.global_data['meas_return'] + + # populate the results dictionary + results = {'seed_simulator': exp['seed'], + 'shots': self.op_system.global_data['shots'], + 'status': 'DONE', + 'success': True, + 'time_taken': exp_times[idx_exp], + 'header': exp['header'], + 'meas_level': m_lev, + 'meas_return': m_ret, + 'data': {}} + + memory = exp_results[idx_exp] + + # meas_level 2 return the shots + if m_lev == 2: + + # convert the memory **array** into a n + # integer + # e.g. [1,0] -> 2 + int_mem = memory.dot(np.power(2.0, + np.arange(memory.shape[1]-1, -1, -1))).astype(int) + + # if the memory flag is set return each shot + if self.op_system.global_data['memory']: + hex_mem = [hex(val) for val in int_mem] + results['data']['memory'] = hex_mem + + # Get hex counts dict + unique = np.unique(int_mem, return_counts=True) + hex_dict = {} + for kk in range(unique[0].shape[0]): + key = hex(unique[0][kk]) + hex_dict[key] = unique[1][kk] + + results['data']['counts'] = hex_dict + + # meas_level 1 returns the + elif m_lev == 1: + + if m_ret == 'avg': + + memory = [np.mean(memory, 0)] + + # convert into the right [real, complex] pair form for json + # this should be cython? + results['data']['memory'] = [] + + for mem_shot in memory: + results['data']['memory'].append([]) + for mem_slot in mem_shot: + results['data']['memory'][-1].append( + [np.real(mem_slot), np.imag(mem_slot)]) + + if m_ret == 'avg': + results['data']['memory'] = results['data']['memory'][0] + + + all_results.append(results) + + _cython_build_cleanup(self.op_system.global_data['rhs_file_name']) + return all_results + + +# Measurement +def _proj_measurement(pid, ophandler, tt, state, memory, register=None): + """ + Projection measurement of quantum state + """ + prng = np.random.RandomState(np.random.randint(np.iinfo(np.int32).max-1)) + qubits = [] + results = [] + + for key, acq in ophandler._acqs.items(): + if pid < 0: + if any(acq.m_slot): + mem_slot_id = acq.m_slot[-1] + else: + continue + reg_slot_id = None + else: + if tt in acq.t1: + mem_slot_id = acq.m_slot[acq.t1.index(tt)] + reg_slot_id = acq.r_slot[acq.t1.index(tt)] + else: + continue + oper = ophandler._measure_ops[acq.name] + p_q = cy_expect_psi_csr(oper.data.data, + oper.data.indices, + oper.data.indptr, + state, + 1) + # level2 measurement + rnd = prng.rand() + if rnd <= p_q: + outcome = 1 + else: + outcome = 0 + memory[mem_slot_id][0] = outcome + if reg_slot_id is not None and register is not None: + register[reg_slot_id] = outcome + qubits.append(key) + results.append(outcome) + + # projection + if any(qubits): + psi_proj = apply_projector(qubits, results, ophandler.h_qub, ophandler.h_osc, state) + else: + psi_proj = state + + return psi_proj diff --git a/qiskit/providers/aer/openpulse/solver/options.py b/qiskit/providers/aer/openpulse/solver/options.py new file mode 100644 index 0000000000..deae400076 --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/options.py @@ -0,0 +1,107 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""OpenPulse options""" + +class OPoptions(object): + """ + Class of options for opsolver. Options can be specified either as + arguments to the constructor:: + + opts = Options(order=10, ...) + + or by changing the class attributes after creation:: + + opts = Options() + opts.order = 10 + + Returns options class to be used as options in evolution solvers. + + Attributes: + atol (float, 1e-8): Absolute tolerance. + rtol (float, 1e-/6): Relative tolerance. + method (str, 'adams'): Integration method, 'adams' or 'bdf'. + order (int, 12): Order of integrator (<=12 'adams', <=5 'bdf'). + nsteps (int, 50000): Max. number of internal steps per time interval. + first_step (float, 0): Size of initial step (0 = automatic). + min_step (float, 0): Minimum step size (0 = automatic). + max_step (float, 0): Maximum step size (0 = automatic) + num_cpus (int): Number of cpus used by mcsolver (default = # of cpus). + norm_tol (float, 1e-3): Tolerance used when finding wavefunction norm. + norm_steps (int, 5): Max. number of steps used to find wavefunction norm + to within norm_tol + shots (int, 1024): Number of shots to run. + rhs_reuse (bool, False): Reuse RHS compiled function. + rhs_filename (str): Name of compiled Cython module. + seeds (ndarray, None): Array containing random number seeds for + repeatible shots. + reuse_seeds (bool, False): Reuse seeds, if already generated. + store_final_state (bool, False): Whether or not to store the final state + of the evolution. + """ + + def __init__(self, atol=1e-8, rtol=1e-6, method='adams', order=12, + nsteps=50000, first_step=0, max_step=0, min_step=0, + num_cpus=0, norm_tol=1e-3, norm_steps=5, + progress_bar=True, rhs_reuse=False, + rhs_filename=None, shots=1024, + store_final_state=False, seeds=None, + reuse_seeds=False): + + # Absolute tolerance (default = 1e-8) + self.atol = atol + # Relative tolerance (default = 1e-6) + self.rtol = rtol + # Integration method (default = 'adams', for stiff 'bdf') + self.method = method + # Max. number of internal steps/call + self.nsteps = nsteps + # Size of initial step (0 = determined by solver) + self.first_step = first_step + # Minimal step size (0 = determined by solver) + self.min_step = min_step + # Max step size (0 = determined by solver) + self.max_step = max_step + # Maximum order used by integrator (<=12 for 'adams', <=5 for 'bdf') + self.order = order + # Number of shots to run (default=500) + self.shots = shots + # Holds seeds for rand num gen + self.seeds = seeds + # reuse seeds + self.reuse_seeds = reuse_seeds + # Use preexisting RHS function for time-dependent solvers + self.rhs_reuse = rhs_reuse + # Track progress + self.progress_bar = progress_bar + # Use filename for preexisting RHS function (will default to last + # compiled function if None & rhs_exists=True) + self.rhs_filename = rhs_filename + # Number of processors to use + if num_cpus: + self.num_cpus = num_cpus + else: + self.num_cpus = 0 + # Tolerance for wavefunction norm (mcsolve only) + self.norm_tol = norm_tol + # Max. number of steps taken to find wavefunction norm to within + # norm_tol (mcsolve only) + self.norm_steps = norm_steps + # store final state? + self.store_final_state = store_final_state + + def __str__(self): + return str(vars(self)) + def __repr__(self): + return self.__str__() diff --git a/qiskit/providers/aer/openpulse/solver/rhs_utils.py b/qiskit/providers/aer/openpulse/solver/rhs_utils.py new file mode 100644 index 0000000000..98c19a54f3 --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/rhs_utils.py @@ -0,0 +1,47 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Routines for generating and loading runtime RHS function""" + +import os +from .codegen import OPCodegen +from . import settings as op_set + + +def _op_generate_rhs(op_system): + """ Generates the RHS Cython file for solving the sytem + described in op_system + + Args: + op_system (OPSystem): An OpenPulse system object. + """ + name = "rhs" + str(os.getpid()) + str(op_set.CGEN_NUM)+'_op' + op_system.global_data['rhs_file_name'] = name + cgen = OPCodegen(op_system) + cgen.generate(name + ".pyx") + +def _op_func_load(op_system): + """Loads the Cython function defined in the file + `rhs_file_name.pyx` where `rhs_file_name` is + stored in the op_system. + + Args: + op_system (OPSystem): An OpenPulse system object. + """ + code = compile('from ' + op_system.global_data['rhs_file_name'] + + ' import cy_td_ode_rhs', '', 'exec') + # pylint: disable=exec-used + exec(code, globals()) + # pylint: disable=undefined-variable + op_system.global_data['rhs_func'] = cy_td_ode_rhs diff --git a/qiskit/providers/aer/openpulse/solver/settings.py b/qiskit/providers/aer/openpulse/solver/settings.py new file mode 100644 index 0000000000..b54af5ff6a --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/settings.py @@ -0,0 +1,18 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +"""Holds OpenPulse solver settings""" + +# Code generation counter +CGEN_NUM = 0 diff --git a/qiskit/providers/aer/openpulse/solver/unitary.py b/qiskit/providers/aer/openpulse/solver/unitary.py new file mode 100644 index 0000000000..f3084e11b2 --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/unitary.py @@ -0,0 +1,100 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=unused-variable, no-name-in-module, protected-access, +# pylint: disable=invalid-name, import-error, exec-used + +"""Module for unitary pulse evolution. +""" + +import numpy as np +from scipy.integrate import ode +from scipy.linalg.blas import get_blas_funcs +from ..cy.measure import occ_probabilities, write_shots_memory + +dznrm2 = get_blas_funcs("znrm2", dtype=np.float64) + +def unitary_evolution(exp, global_data, ode_options): + """ + Calculates evolution when there is no noise, + or any measurements that are not at the end + of the experiment. + + Args: + exp (dict): Dictionary of experimental pulse and fc + data. + global_data (dict): Data that applies to all experiments. + ode_options (OPoptions): Options for the underlying ODE solver. + + Returns: + array: Memory of shots. + + Raises: + Exception: Error in ODE solver. + """ + cy_rhs_func = global_data['rhs_func'] + rng = np.random.RandomState(exp['seed']) + tlist = exp['tlist'] + snapshots = [] + shots = global_data['shots'] + # Init memory + memory = np.zeros((shots, global_data['memory_slots']), + dtype=np.uint8) + # Init register + register = np.zeros(global_data['n_registers'], dtype=np.uint8) + + num_channels = len(exp['channels']) + + ODE = ode(cy_rhs_func) + ODE.set_integrator('zvode', + method=ode_options.method, + order=ode_options.order, + atol=ode_options.atol, + rtol=ode_options.rtol, + nsteps=ode_options.nsteps, + first_step=ode_options.first_step, + min_step=ode_options.min_step, + max_step=ode_options.max_step) + + _inst = 'ODE.set_f_params(%s)' % global_data['string'] + code = compile(_inst, '', 'exec') + exec(code) # pylint disable=exec-used + + if not ODE._y: + ODE.t = 0.0 + ODE._y = np.array([0.0], complex) + ODE._integrator.reset(len(ODE._y), ODE.jac is not None) + + # Since all experiments are defined to start at zero time. + ODE.set_initial_value(global_data['initial_state'], 0) + for time in tlist[1:]: + ODE.integrate(time, step=0) + if ODE.successful(): + psi = ODE.y / dznrm2(ODE.y) + else: + err_msg = 'ZVODE exited with status: %s' % ODE.get_return_code() + raise Exception(err_msg) + + # Do any snapshots here + + # set channel and frame change indexing arrays + + # Do final measurement at end + psi_rot = np.exp(-1j*global_data['h_diag_elems']*ODE.t) + psi *= psi_rot + qubits = exp['acquire'][0][1] + memory_slots = exp['acquire'][0][2] + probs = occ_probabilities(qubits, psi, global_data['measurement_ops']) + rand_vals = rng.rand(memory_slots.shape[0]*shots) + write_shots_memory(memory, memory_slots, probs, rand_vals) + return memory diff --git a/qiskit/providers/aer/openpulse/solver/zvode.py b/qiskit/providers/aer/openpulse/solver/zvode.py new file mode 100644 index 0000000000..f96cfceb79 --- /dev/null +++ b/qiskit/providers/aer/openpulse/solver/zvode.py @@ -0,0 +1,39 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +# This file is part of QuTiP: Quantum Toolbox in Python. +# +# Copyright (c) 2011 and later, Paul D. Nation and Robert J. Johansson. +# All rights reserved. +# pylint: disable=no-value-for-parameter, invalid-name + +"""Hack for the ZVODE solver to do the correct stepping without restart.""" + +from scipy.integrate._ode import zvode + + +class qiskit_zvode(zvode): + """Modifies the stepper for ZVODE so that + it always stops at a given time in tlist. + + By default, it over shoots the time, which + of course is just stupid. + """ + def step(self, *args): + itask = self.call_args[2] + self.rwork[0] = args[4] + self.call_args[2] = 5 + r = self.run(*args) + self.call_args[2] = itask + return r diff --git a/setup.py b/setup.py index cb54a662d3..ced13bffd9 100644 --- a/setup.py +++ b/setup.py @@ -1,3 +1,9 @@ +# pylint: disable=invalid-name + +""" +Main setup file for qiskit-aer +""" + import os import subprocess import sys @@ -26,6 +32,8 @@ def find_qiskit_aer_packages(): + """Finds qiskit aer packages. + """ location = 'qiskit/providers' prefix = 'qiskit.providers' aer_packages = find_packages(where=location) @@ -35,12 +43,71 @@ def find_qiskit_aer_packages(): ) return pkg_list +EXT_MODULES = [] +# OpenPulse setup +if "--with-openpulse" in sys.argv: + sys.argv.remove("--with-openpulse") + # pylint: disable=ungrouped-imports + import numpy as np + import distutils.sysconfig + from setuptools import Extension + from Cython.Build import cythonize + from Cython.Distutils import build_ext # pylint: disable=unused-import + + INCLUDE_DIRS = [np.get_include()] + # Add Cython OP extensions here + OP_EXTS = ['channel_value', 'measure', 'memory', 'utils'] + # Add qutip_lite extensions here + Q_EXTS = ['spmatfuncs', 'sparse_utils', 'spmath', 'math', 'spconvert'] + + # Extra link args + link_flags = [] + # If on Win and Python version >= 3.5 and not in MSYS2 (i.e. Visual studio compile) + if (sys.platform == 'win32' and int(str(sys.version_info[0])+str(sys.version_info[1])) >= 35 + and os.environ.get('MSYSTEM') is None): + compiler_flags = [] + # Everything else + else: + compiler_flags = ['-O2', '-funroll-loops'] + if sys.platform == 'darwin': + # These are needed for compiling on OSX 10.14+ + compiler_flags.append('-mmacosx-version-min=10.9') + link_flags.append('-mmacosx-version-min=10.9') + + # Remove -Wstrict-prototypes from cflags + CFG_VARS = distutils.sysconfig.get_config_vars() + if "CFLAGS" in CFG_VARS: + CFG_VARS["CFLAGS"] = CFG_VARS["CFLAGS"].replace("-Wstrict-prototypes", "") + + # Add Cython files from cy + for ext in OP_EXTS: + _mod = Extension("qiskit.providers.aer.openpulse.cy."+ext, + sources=['qiskit/providers/aer/openpulse/cy/'+ext+'.pyx'], + include_dirs=[np.get_include()], + extra_compile_args=compiler_flags, + extra_link_args=link_flags, + language='c++') + EXT_MODULES.append(_mod) + + for ext in Q_EXTS: + _mod = Extension('qiskit.providers.aer.openpulse.qutip_lite.cy.'+ext, + sources=['qiskit/providers/aer/openpulse/qutip_lite/cy/'+ext+'.pyx', + 'qiskit/providers/aer/openpulse/qutip_lite/cy/src/zspmv.cpp'], + include_dirs=[np.get_include()], + extra_compile_args=compiler_flags, + extra_link_args=link_flags, + language='c++') + EXT_MODULES.append(_mod) + + # Cythonize + EXT_MODULES = cythonize(EXT_MODULES) setup( name='qiskit-aer', version=VERSION, packages=find_qiskit_aer_packages(), cmake_source_dir='.', + ext_modules=EXT_MODULES, description="Qiskit Aer - High performance simulators for Qiskit", url="https://github.com/Qiskit/qiskit-aer", author="AER Development Team", From 43ff9c150693a7a954a91070fc80e7d92f53705f Mon Sep 17 00:00:00 2001 From: David McKay Date: Wed, 14 Aug 2019 16:26:59 -0400 Subject: [PATCH 02/24] Add identity qubit op, fix error in converting from Z to N * changed example to use fake backend, updated for pep8 * fix lint errors --- example/pulse_sim.ipynb | 39 ++-- qiskit/providers/aer/openpulse/__init__.py | 9 +- qiskit/providers/aer/openpulse/qobj/digest.py | 214 +++++++++--------- .../providers/aer/openpulse/qobj/op_qobj.py | 2 + .../providers/aer/openpulse/qobj/op_system.py | 1 + .../providers/aer/openpulse/qobj/operators.py | 19 +- .../providers/aer/openpulse/qobj/opparse.py | 17 +- .../aer/openpulse/qutip_lite/cy/pyxbuilder.py | 21 +- .../aer/openpulse/qutip_lite/cy/utilities.py | 21 +- .../aer/openpulse/qutip_lite/dimensions.py | 13 +- .../aer/openpulse/qutip_lite/expect.py | 1 + .../aer/openpulse/qutip_lite/fastsparse.py | 39 ++-- .../aer/openpulse/qutip_lite/operators.py | 38 ++-- .../aer/openpulse/qutip_lite/qobj.py | 147 ++++++------ .../aer/openpulse/qutip_lite/sparse.py | 12 +- .../aer/openpulse/qutip_lite/states.py | 18 +- .../aer/openpulse/qutip_lite/superoperator.py | 5 +- .../providers/aer/openpulse/solver/codegen.py | 44 ++-- .../aer/openpulse/solver/data_config.py | 12 +- .../aer/openpulse/solver/monte_carlo.py | 3 +- .../providers/aer/openpulse/solver/opsolve.py | 45 ++-- .../providers/aer/openpulse/solver/options.py | 4 +- .../aer/openpulse/solver/rhs_utils.py | 3 +- .../providers/aer/openpulse/solver/unitary.py | 7 +- 24 files changed, 388 insertions(+), 346 deletions(-) diff --git a/example/pulse_sim.ipynb b/example/pulse_sim.ipynb index bcab81db2d..e2e6a8751f 100644 --- a/example/pulse_sim.ipynb +++ b/example/pulse_sim.ipynb @@ -33,7 +33,8 @@ "import qiskit.pulse as pulse\n", "import qiskit.pulse.pulse_lib as pulse_lib\n", "from qiskit.compiler import assemble\n", - "import random" + "import random\n", + "from qiskit.test.mock import FakeOpenPulse2Q" ] }, { @@ -62,9 +63,8 @@ "metadata": {}, "outputs": [], "source": [ - "#Get a pulse configuration from pok\n", - "provider = qiskit.IBMQ.get_provider(hub='ibm-q-dev',group='qiskit', project='ignis')\n", - "backend_real = provider.get_backend('ibmq_poughkeepsie')\n", + "#Get a pulse configuration from the fake backend\n", + "backend_real = FakeOpenPulse2Q()\n", "back_config = backend_real.configuration().to_dict()\n", "system = pulse.PulseChannelSpec.from_backend(backend_real)" ] @@ -201,18 +201,19 @@ "hamiltonian = {}\n", "hamiltonian['h_str'] = []\n", "#Q0 terms\n", - "hamiltonian['h_str'].append('pi*(2*v0-alpha0)*O0')\n", - "hamiltonian['h_str'].append('pi*alpha0*O0*O0')\n", - "hamiltonian['h_str'].append('2*pi*r*X0||D0')\n", - "hamiltonian['h_str'].append('2*pi*r*X0||U0')\n", + "hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0')\n", + "hamiltonian['h_str'].append('np.pi*alpha0*O0*O0')\n", + "hamiltonian['h_str'].append('2*np.pi*r*X0||D0')\n", + "hamiltonian['h_str'].append('2*np.pi*r*X0||U1')\n", + "hamiltonian['h_str'].append('2*np.pi*r*X1||U0')\n", "\n", "#Q1 terms\n", - "hamiltonian['h_str'].append('pi*(2*v1-alpha1)*O1')\n", - "hamiltonian['h_str'].append('pi*alpha1*O1*O1')\n", - "hamiltonian['h_str'].append('X1||r*D1')\n", + "hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1')\n", + "hamiltonian['h_str'].append('np.pi*alpha1*O1*O1')\n", + "hamiltonian['h_str'].append('2*np.pi*r*X0||D1')\n", "\n", "#Exchange coupling betwene Q0 and Q1\n", - "hamiltonian['h_str'].append('2*pi*j*(Sp0*Sm1+Sm0*Sp1)')\n", + "hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)')\n", "hamiltonian['vars'] = {'v0': 5.00, 'v1': 5.1, 'j': 0.01, \n", " 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33}\n", "\n", @@ -399,12 +400,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pi Amplitude 0.314328\n" + "Pi Amplitude 0.315141\n" ] }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY4AAAEkCAYAAAA4g9b0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzs3Xl8zMfjx/HX5BYiSEgQxBF3HaWUUmfdqlQdv5ZqKaWotqrVopfelN6lrqLiLHVTJG7qLOIWV9yJI/c9vz828Y1IJJtsdvaY5+Oxj9jd+Xw+73ya7uxnZj4zQkqJpmmapuWWg+oAmqZpmnXRFYemaZpmFF1xaJqmaUbRFYemaZpmFF1xaJqmaUbRFYemaZpmFF1xaJqmaUbRFYdm94QQF4QQF4wo7y+EkEKIOQWXStMsl644NIuV9uGc8ZEihLgthAgWQgwQQgjVGa2JEKKsEOIbIcR/QohIIUScEOKcEGKWEKJ+Dtv6pZW7KoRISKtspwohipsrv2Y5hL5zXLNUQoj0P85P0n46A1WA7mn//llKOdwEx7kAIKX0z2V5Z6AycE9KeS2/xzcHIURP4A/AHdgH7AQSgVpAO8AJ+FRK+XEW21YGdgGlgL+Bk0AjoBVwCnhKShlR8L+FZil0xaFZrPSKQ0opMr3+FLANEEBlKeX5fB7nQtpx/POzH0slhGgNbASSgH5SyqWZ3q8FrAb8gXeklN9len8DhsplpJTyxwyvfwe8BUyTUr5eoL+EZlF0U5VmdaSUOzF86xVAg4zvCSFchBDDhRBrhRAX05pVbgshNgkhOj5qv0IITyHET0KIK0KIeCHEcSHEyMxNYnnp4xBCOAghXhdC7BNCRAshYtL+PVQI8dD/h2n7DxZCeAshpgshrqX9LiFCiFeMOS7wK+AIjMpcaQBIKUOAZzFULF8IIXwzbF8JQ6VxAfg506YfATFAPyFE4dxm0qyfrjg0a5X+YZ6U6fUSwPeAB/AP8B2wEqgPrBVCDMpmfy7AJqA9sBD4HSiWtq+fTJB3HoYPcB9gBjAdKAn8kvZeVophaFJqAiwF5gJlgFlCiJdzedwWQFXgKjAzu0JSyqPACsAVGJDhrdZpPzdKKVMzbROVls8deDKXeTRbIKXUD/2wyAcgDX+iD73+NJACJAClM73nCvhlsY0ncAy4DRTK9N6FtGPtAFwzvF4COJf23tMZXvdPe21OLn+PvmnlDwJFMrxeGNif9t7/ZfW7Y6hkHDO8XhNIBo7n8tjj0/bzZy7KvpZWdm2G175Ne+2dbLb5Ke39oar/XvTDfA99xaFZPCHEx2mPz4UQizBcGQhgtMzUOS2lTJBShmXeh5TyHjALKA48kc2hxkopEzJscxv4LO1prpuHsvBq2s/3pZTRGfYfA7yX9jSrK6FY4G0pZUqGbY5j+JZfQwjhkYtjl077eTkXZdPL+GV4zTPt571stkl/vVgu9q/ZCCfVATQtFz7K9FwCA6WUs7MqnNbZ+y6GK5PSgFumImWz2CwZw8ihzILTfj5yuGoOHgdSM+wro60Yrp6y2v8ZKWVkFq+nf8AXA6JyOHZ6k15uRsGkl818vky1f81G6IpDs3gybVRVWgdsEwxt9b8JIS5KKbdkLCuEeBLYguFvezOG/o1IDB/c9YBuGJqzMgvP+M0+g+tpPz2zeC+3PIHbUsrEzG9IKZOFEOEYhrpmdjeb/SWn/XTMxbHTr8jK56Js+pXGrQyvpV9RZPf7F81UTrMDuuLQrEZa084mIURXDP0FfwghqkkpYzMUGwcUAlpJKYMzbi+EGIuh4siKtxDCMYvKI32EUX4+GO8BJYQQzlLKBzrzhRBOgDeGyq0g7Ej72TKb3y+jtmk/D2R47VTaz6rZbBOQ9vN0HvNpVkj3cWhWR0p5BMOoJz8M9xFkVAXDt/vgLDZt8YjdOgFNs3i9ZdrPQ8alfMAhDP+vPZ3Fe09juHI4mI/9P0owhg/1Mvyvr+Uhac173dOeLsjwVlDaz3aZhw2n9bE8BcQBe0yUV7MCuuLQrNVEIB4YnWnaiwsYvt3XyVhYCDEQw1DbR/lSCHG/GUsIUQLDFQxAlv0puTQrw/7dM+zfHfgq7Wm2Q2XzQxqG0A7F0I/yvRCie+YyQogaGJr0nDGMvtqTYftzGG4e9AfeyLTpJxhGhs1NuxrU7IRuqtKskpTyihBiGvAmMAYYm/bWVAwVxA4hxGIMzUQNgWYY7oXomc0ur2Ho+zgmhEj/EO2JoXP9FynltnxkXSCE6Ab0AkKEECswdCY/B1QEFksp/8zr/nNx/C1CiL7AHOAvIcS/PDjlSHsMv+82sh7dNQzDwIEfhBBtgBNAYwxTjpwGPiyo7JqFUj0eWD/0I7sH2dzHkeF9Hwx3LscAPhle74Kh6SQKQwfzRgxNQgPS9jkg034upD08MdwdfQXDPSIngJGkTc2Tobw/RtzHkbaNA4YP4P0YhtnGYuhLeANwyOZ3D85mX3PS3vc38nz6Ybgv42jauUm/VyQZGJ5VjgzblsNw1XUNQ4VzEcPNkSVU/53oh/kfeq4qTbNjQohZGO5RmSSlfFd1Hs066KYqTbNvQ4AKGPqK4qSUE1QH0iyf7hzXNDsmDcODn8dwk2WKEKKc4kiaFdBNVZqmaZpRbLKpytvbW/r7++dp25iYGAoX1jNEp7PU83HqlOG+tGrVqpn1uJZ6PlTQ5+JBtnA+Dhw4EC6lLJlTOZusOPz9/dm/f3+etg0ODqZly5amDWTFLPV8pGcKDg4263Et9XyooM/Fg2zhfAghLuamnO7j0DRN04xik1ccmu0bN25czoU0TSsQuuLQrFLbtm1zLqRpWoGwm4ojKSmJsLAw4uPjH1nO09OTEydOmCmVcdzc3PDz88PZ2Vl1FOUOHz4MQL169RQn0TT7YzcVR1hYGB4eHvj7+yOEyLZcVFQUHh65WVjNvKSUREREEBYWRsWKFVXHUW7UqFGA+TvHNU2zo87x+Ph4vLy8HllpWDIhBF5eXjleMWmaphU0u6k4AKutNNJZe35N02yD0opDCDFLCHFTCHEsm/eFEOIHIcRZIcQRIcTj5s6oWaaIiAjCw8NJTHxoNVZN0wqY6iuOOUCHR7zfEcPSlAHAYOBXM2QqUGFhYXTr1o2AgAAqVarE8OHDSUhIAODLL7+kSpUqVKtWjQ0bNihOajliYmJYvXo1b7zxBnfv3r3/WkhICGXKlGH48OH8+++/6OlzNM08lFYc0rA4zu1HFOmGYXUxKQ2rkhUTQpQ2TzrTk1LSo0cPnnvuOc6cOcOZM2eIi4tjzJgxHD9+nIULFxISEsL69esZNmwYKSmPWh7att2+fZvvv/+e9u3b4+XlRdeuXfnjjz849N8RztyIYtiEybz/0UTatm3LjBkzaNy4Ma1bt1YdW9PsgqWPqioLXM7wPCzttWuZCwohBmO4KsHHx+eh0Taenp5ERUXleMCUlJRclcuL4OBgnJ2d6dmz5/1jfPrpp9SuXRsPDw+6d+9OYmIi3t7e+Pv7ExQUROPGjR/YR3x8vFlHEkVHRysZubT/4GHGvjcGz5K+BDTrTOFKDUnyqcmr66KQ67YBLkA9ajz+OGOf6UvkiR3I1BSCg4NJSUnh888/Z+jQoZQsmeO0O0ZRdT4skT4XD7Kn82HpFUdWvcFZtkdIKacD0wEaNmwoM88Zc+LEifvDbD9ZFcLxq5FZHjAlJQVHR0ejg9YsU5SPutZ6ZJnz58/TqFGjB4b7pg8RPnz4MH369Ln/nr+/P3fv3n1oaLCbmxv169c3Ol9emXv+nbt37/LvlXiWJ6biO3QOju6epLg44uVdmEoli1DRuzCVSxYmIvQoIVci2RvrzewzqXh5tqNnAz/8a5eH6Fvs37+fsWPHEhwcjJ+fn8ny2cJ8RKaiz8WD7Ol8WHrFEYZhycp0fsBVRVnyTUqZ5cio9OUYM7O3UVR//7OV3j2ew6P1YOq37MTMIa2p41cMn6KuD52LlqNeBGDbliC2nblF4L+XmLHjPNO2hfJUFS8++WUBH7/xIi1btjR55aFp9s7SK46VwHAhxEKgMXBPSvlQM5WxHnVlUJA3ANaqVYtly5Y98FpkZCQ3btygd+/eXL78v1a5sLAwypQpUyA5LE18UgpvfTePaeOH4lSkGG/17cC7LzTH2THnLjgHB0HLaqVoWa0UNyLjWbzvMgv3XWbnXUGrUVMJmjpKVx6aZmKqh+MGAruBakKIMCHEQCHE60KI19OKrAVCgbPA78AwRVFNok2bNsTGxjJ37lzA0Cz2zjvvMHz4cJ599lkWLlxIQkIC58+f58yZMzRq1Ehx4oK3+cQN6g+cyG8fvkYJXz/279nFB31a5arSyMynqBsj2gSwbUwrxnWuwbEkH/xf+pz4pGQiIiIKIL2m2SelVxxSyr45vC+BN8wUp8AJIVi+fDlvvPEGn332Gbdu3aJ37958+OGHAPTq1YuaNWvi5OTEzz//nKe+FmsRn5TCyMBDrN76L9fmf0rteg3YtnkDxYsXz/e+HR0Eg5pX4vEKxRmxwI2Yvj9wKLoodaQkKiqKokWLmuA30DT7pfo+DrtTrlw5Vq5cyZkzZ1i7di3r16/nwIEDAHz44YecO3eOU6dO0bFjR8VJC9YvwefYePwGH77UjlmzZrFne5BJKo2MHi9fnDUjm9Giemk+XnWcJn1GUK/+44SFhZn0OJpmbyy9j8OmNW3alIsXc7Xglk25EB7Dd3OW0rx2Rd5oVQWoYvQ+pk6dmqtyxdxd+L1/Q37fHsqns05x48p1mjZ7ml07tuk+D81mJCYmsnjxYlyrt6BDbV883Ap2Bm19xaGZlZSS9wN3cePvSZxcOjnPd3vXq1cv11OqOzgIhrSozMpPB1D9lS+5cv0GT7V6hqSkpDwdW9MszYSPPqZfv36MmLKAP/deKvDj6YpDM6sNITdYPe1LZHwUs2fOyPOQ402bNrFp0yajtmlQoQTbJg2hxeBPuHT2JJ0GjSElVU9Tolm3NZu38vXXX1O4dlveG9Cdwc0rFfgxdVOVZjaxicm89e1MYkKC+PDDcflahGnixImA8SsBlijswj9T36Hxqb0cuu3IkHn7+b5PfQq76v8VNOuz/UQYz/d+CScPL+b+/jM9nqxqluPqKw7NbL5deZAzf31H5ao1mDBhvLIcjg6C/RuWMOWD4Ww5eZMXftvNtXtxyvJomrGklMzbc5Gu/YeTEBHG7zNmmK3SAH3FoZnJ2ZvRzNt/jYbte/LT+6/h4uKiOhL/16gc+9YsYPm2KJ6LSWDmy09Qu6yn6lia9kgJySl89HcIC/ddpnGLNjToUJcBLzxr1gz6isPMsptWPSIiglatWlGkSBGGDx+uOqZJSSn56O9jFHJzY9XsH2jYsKHqSIDhvpoDQWuIDpqOjIvihd9288/xG6pjaVq2bkTG02f6HgL/vcTwVlVY+81wvvjsE7Pn0BWHGT1qWnU3Nzc+++wzJk2apDqmyS3Zc4Zlnwyki/dtSnq4qo5zn4ODA9OmTSM6KpKK55ZR1acIg+ftZ8b2UL22h2aRhi84yKnrUdQ6v5jInX/i6KBmPjtdcZjRli1bcHNz45VXXgHA0dGRKVOmMHfuXKSUNGvWDDc3N8UpTSs6IZkRo0aTcPUEnetXMNl+p02bxrRp0/K9n9q1azNmzBgWB/7JkCqxdKjly8Q1J1j5n9XOpanZqH0XbrPvwh3aF73KuiXzlK5+aZ99HOveh+tHs3yrUEoyOObhtPg+Bh2/emSRkJAQGjRo8MBrRYsWxd/fn7Nnz+ZrlJGlGvXdfG7+u4oXBw2j2VNNTbbfatWqmWxf48aNY/Hixbw54g1CQo4TcjWSpQfC6FavrMmOoWn5NW3rOTyIY+F346hduzaffGL+Jqp09llxKPKoadVt0eHQ6/zxzViK+ZZn+vffmnTfq1atAqBr16753lehQoWYPXs2SUlJuLg407VuaX7bGkp4dALeRSynaU2zX6dvRLHpxE18DgcSfusWa9eswdVV3d+mfVYcj7gyiFM0rbopv0Fbilff/4Lku9eZt34T7u7uJt335MmTAdNUHADNmjW7/++OtUrxc9A51h27Tr8nTde8pml5NW1rKM6JURwOWs2bb75p1sXcsqL7OMzoUdOqFypUSHE609p9LoKIiu2YMGs1Xdq3UR0n1yZOnMjQvt2o4u3OKt3PoVmAa/fi+PvwFV5s+RjHjh3j/fffVx1JVxzmlD6t+tKlSwkICMDLywsHB4f706r7+/vz9ttvM2fOHPz8/Dh+/LjixHkjpWTSumP4erox9qUOquMYpUKFCuzYsYNS1/ew78JtfWOgptzM7edJTUlmYLOKBAQE4O3trTqSrjjM7VHTql+4cIHbt28THR1NWFgYNWvWVJw2b1bsCmHFe8/R2OEcbs7WtabISy+9RIMGDdi5bAapKSmsOZLvBSc1Lc/uxSYR+O8lXHb+xnvDB1lMf6iuOBRKn1Y980grayal5N3xE0mNj+T17q1UxzGaEIIPPviASxdCKXHzAKt0xaEpNH/vRe5evcDpXespX758nicFNTX77BzXCsyynSGEbl/B0x17ULNawc2dM2/evALb93PPPUeNGjWI2LmE2z5PcCkilvJepu3c17ScxCelMHvneVyO/oW7uzujR49WHek+fcWhmYyUkvc+/gKZksQv335WoMcqV64c5cqVK5B9Ozg4MHPmTAIXL0EIwaojupNcM7+lB8K4euEsF/dtYsSIERbRt5FOVxyayazYd47z25bTrH03atWoXqDHWrRoEYsWLSqw/Tdp0oSn6teiQYXienSVZnYpqZLft4fidHQlhQsXtqirDdBNVZqJpKZKpu26SoNh3zPzjdYFfrxff/0VgN69exfYMa5du8a5+eO4Vq4NZ27UJ8CnYO7v0bTM1h+7zsWIWCZNnkzxuCt4eXmpjvQAXXFoJrH22DVOXo/i+wGdqRpgG1N1lChRguuhJ4gMi2DVkRd4+xldcWgFT0rJb1vP4e/lzvNNa+DoYHmjK3VTlRk5OjreXyu7Xr16XLhwgf379zNy5EgAgoOD2bVrl+KUxktJlYwcM47EzT/SsZaP6jgm4+rqyph33yX+0hH+/PsfixkKqdm23eciOHD4Py7NepOTJyzzXi59xWFGhQoV4vDhww+85u/vf399iuDgYIoUKULTpqabDNAcFu44wYWgRTR5uhUuzrb1JzV48GA++nQiJ9b/QcjVl1TH0ezAr1vPEbd3EdFXLlC6dGnVcbKkrzgUCw4OpkuXLly4cIHffvuNKVOmUK9ePbZv3646Wq4kp6Qy7vNvkYmx/Ph1wY6kUqFIkSKMGDGSuHP7mL5ii+o4mo07fjWSzbv2czdkO2+++SYlSpRQHSlLtvX10AgtW7Z86LVevXrRr18/YmNj6dSp00PvDxgwgAEDBhAeHk7Pnj0feC84ODjHY8bFxd2fOr1ixYosX778/nv+/v68/vrrFClSxOJGUDzK/O0nubR1CU1at+fxx8038drSpUvNdqx3336TdceuseeGoHtN3VylFZzAfy8RtSuQokWL8tZbb6mOky27rThUyKqpypolJqfy0VeTSU2I4YevJ5r12OYc0168eHHGjRvPO0v+49zdVKzvfnjNGsQnpbBo406iT+5k/PjxFnu1AXZccWR3hRAVFYW7u/sjryC8vb1zdYVh65YfCiOlUnPenFDN7OuIz5kzBzBcBZrDM7V8SPz6X6aduMSg7tYz269mPTaEXCe+kDfvfzGVUUP6qY7zSLqPw4J4eHgQFRWlOkaupKRKpm0NpV6Nykz5+F2zH3/OnDn3Kw9zKOrmTIm7p9i/eh7nL1w023E1+7FkfxjlShbn8/dGWvTVBuiKw6J07dqV5cuXW0Xn+MaQ6+z782uae9y2mInXCtrb77wDwLsTbG8QgKbW5duxbFi1jFKXNgOW34+mvOIQQnQQQpwSQpwVQjy0QokQorwQIkgIcUgIcUQI8XCvtZWIjo5+6LWWLVuyevVqAKpWrcqRI0c4fPgwzZs3N3e8XJNSMnHGUqIPr6ekvK06jtn0aVWfoo+15u9F87l9235+b63gLT1wmbs7Arn47z84OCj/WM6R0oRCCEfgZ6AjUBPoK4TIfJvkOGCxlLI+0Af4xbwptcz+PX+bwxsWU9jDk759+qiOYzbuLk482e45khMTmDX7D9VxNBuRmiqZuXg1ybfDGDVyuOo4uaK6amsEnJVShkopE4GFQLdMZSRQNO3fnoCecU6x71b+S+yZ3bz66gCbW/I2Jx0bVqVw7Tbclnqadc00dodGcH7bX3gUK06vXr1Ux8kV1aOqygKXMzwPAxpnKvMxsFEIMQIoDLTN68GklFbdHm8JU16cvB7Jxr8CITWF4cOGKcuxdu1aJcet7e1I9d7vcdvHsjsvNesxc8N+Ys/s4e2338bNzU11nFxRXXFk9Sme+dOxLzBHSjlZCNEEmCeEqC2lTH1gR0IMBgYD+Pj4PDRctkiRIoSFheHp6fnIyiMlJcUiRzZJKbl37x4xMTFmHQocHR39wPGmH0nApXBR2jzTnqtXr3L1qn1dAMbHxtDAy5kNh0L5/FowTzWyndUbjZX5b8Pe5eV8xCRJ/jl8jtIBj9Hg8fpWcz5VVxxhQMbVePx4uClqINABQEq5WwjhBngDNzMWklJOB6YDNGzYUGa+MzwpKYmwsDCuXLnyyEDx8fEWW+u7ublRt25dnJ2dzXbM4ODg+3fZX7kbx78bg3hj2DAmdFU7Y+cvvxi6uoaZ+aonODiYkd3qE9jtZT7+bx3Xr121uCmvzSXj34aWt/Mxb89FHL1iWbdlK7XLehZMsAKguuLYBwQIISoCVzB0fv9fpjKXgDbAHCFEDcANuGXsgZydnalYsWKO5YKDg6lf33xTZ1iTGdtDibt0lH6jnlIdhcWLFwPmrzgAapXx5LHWz7Fr/9/88ccfvP3222bPoNmGWau2UamwB7XKFM25sAVR2jkupUwGhgMbgBMYRk+FCCE+FUI8m1bsHeA1IcR/QCAwQFpCY7+duROTyNyN+7m6YCwLfv9JdRzlBnR+GteyNfj5198sou9Jsz4nrkWye/63HJ9uuXNSZUf1qCqklGullFWllJWllJ+nvTZBSrky7d/HpZRPSSnrSinrSSk3qk1sn+btuUj4/jU4CEH//v1Vx1GuW/0yeNTrQOjZM2zdulV1HM0K/fRXMAmXjvL64NesbtCOySoOIUQlIUSoEOKcqfapWYa4xBRmbTtD4vHNdOnShXLlyuW8kY0r5eFG+67P4ehWhH/++Ud1HM3KJCSnsHjuTBycnHnj9ddUxzGaKfs4nAF/rOF+ec0oSw9c5srhrcRH3mbo0KGq41iM3k9WYevAX+n8SgfVUTQrs/rAeSIO/0PbTt0oWbKk6jhGM2XFcQ7IufdZsyopqZLp20MpdOMoFStWpF27dqojAblb/6SgPVPTh2LeJVl6MIzGFYvj6OioOpJmJX5duAqZlMCEMdbXvwEmbKqSUiZLKS9KKfXUoTZk340ULt+OY/qMmWzfvt0q5tExFzdnR7rUKc38aT9Qt149UlNTc95Is3vX7sUR6laVD+du4ammTVTHyRP9KaBlS0rJuvNJVPQqRLuavpQtW1Z1pPsmTZrEpEmTVMegx+N+pLqXIOTYMYKCglTH0azA0n2XSJXwWseGVtcpnk5XHFq2Tt+I5nx4LMemvMyff85XHecBq1evvj+rsEoNKxSn+pPP4FK4KNOmTVMdR7NwUko+f28Ecsv3VPAqrDpOnuW6j0MIEZrLolJKWTmPeTQLsuboNWJPbCPiWhj+/v6q41gkIQQ9G1fkaM1WLF++nBs3buDj46M6lmah/jsbxo3/gnim+4uqo+SLMVccDhjmlsr8KIZhNJU/4GLkPjULtvboNZKOrqVWrVo0a9ZMdRyL1aO+H0XqdiA5OZnZs2erjqNZsKnT/4CUZEYOHaw6Sr7k+opDSumf3XtCiCrADxhmr22f/1iaaqdvRHE85BiRV84y5L0frLYt1hzKe7nzVIO6HA4fSffu3VXH0SzYuuWLcfepSKeWT6qOki8muTqQUp4FemCYJv0jU+xTU2vNkWvEhGzB0dGRvn37qo7zkEKFClnUWiA9Hi9LYrV2xLnrZiota8eOn+DmuaM0bt/d6kcnmnI4bjzwD4Zp0DUrt/boNRq17sKIESPw9vZWHech69atY926dapj3NepTmlcnRyYPOcvfvzxR9VxNAt0Ld6JYi0H8Gr/l1RHyTdTV3vJgK+J96mZ2ZkbUZy5GU2/rq3o1i3zgoxaVoq6OdOuli/rVv/Nu+++y71791RH0izM0QhJ8Sd70rVJbdVR8s2Uc1V5A915cEU/zQqtOXqN6KObKBVvuf8pP/vsMz777DPVMR7w/ONlca7WgoSEBJYuXao6jmZBDh06xII//6S2rzue7uZbT6egGDMcd8Ij9lEOw1rhnsBYE+TSFFq5/xx3N/3Gcr9Yi+zfANi8eTMA48ePV5zkf5pV8aZs1ceI8y3PvHnzGDhwoOpImoWY9N1UDi5eQs/ne6iOYhLGzFX1cQ7vRwITpZTf5D2OptrZm1Ec2fEPKYnx9O/fn6SkJNWRrIaTowNd65bhh6pPs3XrfC5evEiFChVUx9IUi4mJYflfyyhcvTltH7ONmaWNqThaZfN6KnAHOJm2MJNmxdYcuU7MsS1U8K9I06ZN9VoTRupatwzTa7TE69RmQkNDdcWhsWLFCuJiY/Cv/wx1yxVTHcckjLmPQ3+C2IG/tv9H/KUjDJgwQd+7kQf1yxXD378iAZ//RatW1j1WXzONP/74A9fivrRp+TTOjtY9DDedbfwWmkmcvRnNyRPHKezhSb9+/VTHeSQvLy+8vLxUx3iIEIIudUuz49xtbt2LJTIyUnUkTaGEhATCrl7HrUYrWlQrpTqOyeiKQ7tv7dFruFduwMnQS1SubNnTjS1btoxly5apjpGlrnXKkJSURK0a1ZgwIbsxJZo9cHV15b3pf+PZtDfNA6xvwabs6KVjtftWHThPg/LF8PPyUB3FqtUqU5TKPp64lQ4gMDCQ5GTd9WePpJTExsay/UwE5Ut6UMHLXXUkkzHlFUf60rH+Jtxx7SvkAAAgAElEQVSnZibnbkWzd/HP7Pn2Vav4oBs7dixjx1rmyG9Dc1UZEvyf4ubNm2zcuFF1JE2BgwcP4uPjw+bNW2geUNKm+gxNWXGkLx1byYT71Mxk1cFLxJzYSr3HauLkZMoVhQvG7t272b17t+oY2epapzRulRpQuGgx5s2bpzqOpsDcuXNJTEwiuUQFng6wvGl78kMvHasBMG/pKlJj7zF44Cuqo9iEAB8PapQtQam6rVixYoXuJLcziYmJLFiwgBqNW+FcqAhNKuuKQ7MxobeiObljDUU8i9OhQwfVcWxG17plSKjWnlkLllC4sPWu9qYZb/369YSHh+NWsxV1yxXDs5D1TzOSka44NJbuPkXsmT280Ks3Li4uquPYjK51yuDs5UdkiRo4OjqqjqOZ0dy5cylZshQ3ilazqdFU6YxqzBZCFAaGYVisqSzgmkUxvXSsldl85h6NX/2Yd9+ynkWI/Pz8VEfIUXkvd+qWK8birYc5s+pXRo0aZRW5tfwbN24cS4MPMv+6k831b4BxkxwWA3YANTHMS1UUuIdhudj0FXWuAnpyIytyPjyGU7fiGN+/LzVqVFQdJ9fmz5+vOkKudK1Tmo/mH2fL9MmUKlWKMWPGqI6kmUG9evVYFOqAx51rNjPNSEbGNFWNw1BpDASKp702BSgCNAUOYhhZVcOUAbWCNe+ffdzdGUjj0roppSB0qVMGlxJl8K9Zn3nz5iGlVB1JK2BfffUVu3fvZtvpcJpU9rKZaUYyMuY3ehbYJqWcLTP89UuDPUAnoDrwoYkzagVo/vz53NvxJ0WtrO9u1KhRjBo1SnWMHPl6uvGEfwncarTg2LFjHDlyRHUkrQBdunSJsWPHsnTVeq7cjaN5Vdvr3wDjKo5yGK4q0qWSoY9DSnkTWAf0MU00raBdDI/h/J4NVK3XmPLly6uOY5TDhw9z+PBh1TFypWvdMkSXbYSzs7O+p8PGLVq0CADf+q0BbLJ/A4yrOGKBlAzP7/HwMrE3MHSa55oQooMQ4pQQ4qwQ4v1syvQSQhwXQoQIIRYYs38tezP+DiL5dhgD+r2oOopN61jbF5fCntRu1kE3Vdm4wMBAGjVqxKnYwpQrUYgKXrY5DNuYUVWXMVx1pDsOPC2EcJRSplcozYDrud2hEMIR+Bl4BggD9gkhVkopj2coE4BhVcGnpJR3hBC2M8WkYgsXLUQ4OPJaf8tc5c9WeBdxpWllLy4Vf4tJo1uqjqMVkEuXLnHo0CEmTf6OWefC6VbfqO/QVsWYK46tQAvxvwlXFgGVgTVCiDeEEEuAJ4G1RuyzEXBWShkqpUwEFmJYgjaj14CfpZR34H6TmJZPV+7GcT38Do81aYW3t21eTluSrnXKcDEilqNX7nH9eq6/W2lW5OrVq5QuXZrqTdsRk5his81UYFzF8QewAkgfiP5b2vN2wI/A88AuDKOvcqsshiuZdGE83NRVFagqhNgphNgjhNC3NpvA+mPX8Wo3jL/++kt1lDypWrUqVatWVR0j19rX8sXZUTDirXepXr06CQkJqiNpJvbkk08SFhbG/lvgILC5aUYyEvltcxVCNACqABeAfVLKVCO2fQFoL6UclPa8H9BISjkiQ5nVGO4N6YWh0toO1JZS3s20r8HAYAAfH58GCxcuzNPvEx0dTZEiRfK0rTX5ZGsEyU7ufPZUoUeWs5fzkVv5OR9TD8Rz9OC/hC74iIkTJ/LUU0+ZOJ156b+N/4mLiyMpKYkEpyKM3R5H49JOvFYnq/ujLVurVq0OSCkb5lhQSqnsATQBNmR4PhYYm6nMb8CADM83A088ar8NGjSQeRUUFJTnba1FWESUdCxcXLb7v6E5lrWH82GM/JyPFYfCZPnRK6Rn8RKyT58+pguliP7b+J/Ro0fLMmXKyGFz98pq49bKq3djVUfKE2C/zMVnt+o7U/YBAUKIikIIFwxDeVdmKrMCaAUghPDG0HQVataUNuaH+StIiblD19ZNVUfJs8GDBzN48GDVMYzSpoYPbq4uVGnUhpUrVxITE6M6kmYCqampLFy4EO8y5VgTcotBzSpR2vPRV/LWTmnFIaVMBoYDG4ATwGIpZYgQ4lMhxLNpxTYAEUKI40AQ8K6UMkJNYtuwZPFiHF3dGfh/z6uOkmenT5/m9OnTqmMYpYirE62qlSLarzGxsbGsWrVKdSTNBHbu3ElYWBiy8tN4F3Hh9Za2P1Wf8hV7pJRryTQSS0o5IcO/JfB22kPLpysRkVzcv4X6zZ6hUCHb/lZkibrULc26owF8MmUanTt3Vh1HM4HAwEBc3dy4W6YRX7StShFX5R+rBU51U5VmZt/NWkJqQgyvDeinOopdal29FO6uLiT6N8HDQ6/tbu2SkpJYsmQJntWepGxxd/o8US7njWyA7VeN2gMuOfsR0H0Ur/TqqjqKXXJ3caJ1jVKsPXwZzzMbqFmzhr7ysGJCCPq99xWBRyPpVc0FJxuc0DAruuKwI3diEjl4M4XXXhti9Qs21atXT3WEPOvyWGlW/3eVqbN+pnaNqrrisGJxyZKtceVp8VQR6pWMVx3HbOyjetQAmDJvOXcPreeZaiVUR8m3qVOnMnXqVNUx8qRV9VIUdnWiwhNt2bx5Mzdv6skQrFFcXBw9Bo3ixtXLfNipJv+bVMP26YrDjsyZ9jPRuxZQr4KX6ih2zc3ZkbY1fLjt25CUlBSWLl2qOpKWB/OXrGDTn7/wRPEEHvPzVB3HrExWcQghUoQQCUKIP4QQ1U21X800Ll67yeUju2nYqrNNrH/90ksv8dJLL6mOkWdd6pQm3sOPigHVyessB5pa3/4yC8fCxZjylv3NLm3KKw4BOAP9gGNCiGUm3LeWT9/+NhdSkxnyan/VUUwiLCyMsLAw1THy7OmqJfFwdcLviWdwc3MjMTFRdSTNCHtPXebM/q00at0Z/5JFVccxO5NVHFJKBymlA1APwz0XeuEBC7J82RJcS5Thxc6tVEfRMDRXPVPTh7sBnVm9dr3VD1awJ1JK3vpmBqQk8clb1jV7gamYvI9DSnlESvmDlLKnqfet5c2d6Dhu342kUduuONrJcEFr0LlOaSLjk9l5NpyICD0ZgrU4dPkuJ85dpHSFyrRt2Vx1HCX0p4gd2HHuDj4vTeKriZ+qjqJl0DygJB5uTkyeNodSpUpx5swZ1ZG0XFh6IAzf5n04cTzErkZSZaQrDjuw8sB5vIu40LhySdVRTKZJkyY0adJEdYx8cXFyoH0tX86KMkgpdSe5FYhPSuHv/efp+Jgvnu7WN226qWR7A6AQYkse9ymllG3yuK1mYqfOhDJzSBu6v/UFjg7PqI5jMl9++aXqCCbRpU5plh4Io3aDxgQGBjJu3Di7/RZrDTaEXOfcvA85eiQAelnnImim8Kg7x1vmcZ+6U9yCfPPrLGRyAr3a22dbrKV7qoo3xdydKVGnFUGzvuTo0aPUqVNHdSwtG3M3HSQhLIRmA+27Czfbpqr0UVJ5eFj/TQI2ZPXypRQqW50eLRuojmJSzz//PM8/b73TwqdzdnSgQy1frhSrg6Ojo26usmDX7sURtG4lSEmfPn1Ux1FK93HYsJDjJ7h54RQNW3fB2cZGU0VERNjMSKTOdUqT4OzBmK9+YejQoarjaNn46+AVYk5so9ZjdalWrZrqOErZ1qeJ9oDvp88BBK/066s6ivYITSp5UaKwC1Fln6BcOfuYltvaSCmZt2EviddO83I/+7tTPLM8zY4rhPADygJZDiuQUm7LTyjNNIrUakHJjvH0aPaY6ijaIzg5OtChti8rDl3hz8BFxMdGM3DgQNWxtAwOXrrD1QQXXh/3DX376i9iRlUcQoh2wBQgp7modD+HBTgc6U67Hv+HZyFn1VG0HHR5rDQL9l7i55l/cD7kEAMGDLCJOcVsxdIDYRTx8GDSh29R2A5W+MtJrpuqhBCNgdVAMeAnDHNTbQN+B06mPV8F6LvMLMD30+cQsmcrbWuUUh2lQLRp04Y2bWxn1HfjSl54F3GhULWnuX79Olu3blUdSUsTl5jCsqADlL6ylZSEWNVxLIIxfRwfAPHAE1LKN9NeC5JSvg7UBj4D2gJ6jmjFUlNT+XTCh0QdXE3bmj6q4xSI8ePHM378eNUxTMbRQfB/jStwxi0A10KFCQwMVB1JS7Mh5Do3D2wgeM43xMbqigOMqziaACullFczby8NPgJOAJ+YMJ+WB7t37+b2jasENO2AX3F31XG0XBrVJoDnG1XGqeITLFi0RM+YayGW7L9MwukdtGrVCl9fX9VxLIIxFYcncCnD80SgcKYyO4Gn8xtKy5858/5EOLnQu2d31VEKTMeOHenYsaPqGCbl4CD4tmcdmnfoRpKLJ7+t3qs6kt27cjeOoF17iY+4ojvFMzCml+cmUDzT88qZyjgDhfIbSsu75ORklixZQqHKT9C1Qeb/PLYjLi5OdYQC4eTowPKvhjO4VlOm7rtFpSpX6VKnjOpYdmv5wTBiQrbi7OxMjx49VMexGMZccZzmwYpiD/CMEKIqgBDCF3ge0FN8KnTx4kWScaTs422oXdb+FpixBW7OTkx7qQH1SxfmzT/3sfnEDdWR7JKUkqUHwvBMjaRjx44UL148543shDEVx3qghRCiRNrz7zFcXRwSQuzDMLKqJDDVtBE1Y5Qt74/f0Fn0fL67nizPil06f5Z/xj1LsZuHGfrnQXadDVcdye7sv3iHCxGxTJk2R68Ln4kxFcc0DP0XSQBSyp3AC8B5DKOqrgFDpZRzTR1Sy53k5GS2n7pOfLKk/WNlVcfR8qFKlSp4eHjgG34Afy93Bs3dz4GLd1THsitL94fh7phKx8d8cXbW90JllOuKQ0oZKaXcK6WMyvDacillbSllISllDSnl9IKJqeXG2rVrea5ZHZwjr/JkpRI5b2DFunTpQpcuXVTHKDCOjo707t2bTRs38PPz1Sjl4cqA2f9y9mZUzhtr+RabmMzq/8K4/Nsgfv5+iuo4FkfPVWVDFiwIJDEpmTaN6+DqZNt3HY8ePZrRo0erjlGg+vbtS2JiIjs2r2P+oMYkp0jm7r6oOpZdWH/sOuGnDxB9+yYBAQGq41gcXXHYiJiYGP5euRK3qk1pX0c3U9mChg0bUrlyZQIDA/Er7k6zAG82n7iJlHrJm4K2/NAVROguihYtSocOHVTHsTjGzlXVAngXaIRhaG5WFY+UUurJXMxs1apVxMfFUrpWS1pVs81pRjJq2bIlAMHBwUpzFCQhBD/99BMlSxqW/G1boxT/HL/BqRtRVPfVI+YKyr3YJHadus69Ezvp3bMHbm5uqiNZnFx/wAshOgMrMExgeAk4BSQXUC7NSIGBgbgW9aZ5s2YUc3dRHUczkYzfdtO/EGw+cVNXHAUo6NRNos7tJz4myu4XbMqOMU1VH2MYUdVBSukvpWwupWyV1cOYAEKIDkKIU0KIs0KI9x9RrqcQQgohGhqzf3vR99XX8Wg5kHa19c1itmbv3r18+eWXlCrqRh0/T7acvKk6kk3bePw6pSvV4IsvvrCpiTRNyZiKozawSEq50VQHF0I4Aj8DHYGaQF8hRM0synkAIwE9B0M2YryqU7hGc56pYZuTGtqzLVu28MEHH3Dx4kVaVy/FwUt3uB2j57EqCPFJKWw9dYvOTR9j7NixehhuNoypOKKB2yY+fiPgrJQyVEqZCCwEumVR7jPgGwyz82qZTJs2jSUbd1DNx4PyXnpSQ1uT3lyycOFC2lT3QUoIPqWvOgrC7nMRRJw5hFvYflJSUlTHsVjGdGJvxjBDrimVBS5neB4GNM5YQAhRHygnpVwthMh2/KUQYjAwGMDHxyfPnabR0dFW1eEaERHBsGHDKPrkC7z48qsmz26p56NevXqA+TvHVZ2PmjVrMmPGDJ5o1IhiroKF245RIvKs2XNkZKl/G/kx51gCUXsWMW3bLZrX9jdq9gVbPB/ZklLm6gFUAG4A4wCR2+1y2OcLwIwMz/sBP2Z47gAEA/5pz4OBhjntt0GDBjKvgoKC8rytCpMmTZKALPPaNHno0h2T79/azkdBU3U+pk6dKgF54sQJ+d7S/2TtCetlQlKKkizpbO1vIyUlVT42eoFECPnRRx8Zvb0tnA9gv8zFZ7cxTVUfASEY1ts4J4T4SwgxK4vHTCP2GQaUy/DcD8i43ocHhr6VYCHEBeBJYKXuIP+fuXPnUqpyLcpWqESdsp6q45hNbGysXS2q06tXL0qXLk1oaChtavgQlZDM/gumbjm2b4cu3+Xy/n9ASl566SXVcSyaMU1VAzL82z/tkRUJDMzlPvcBAUKIisAVoA/wf/d3JOU9wDv9uRAiGBgtpdyfy/3btCNHjnDkyBFKthtKx9q+ODjYz6SGnTp1Amz7Po6MSpcuTVhYGA4ODsQmJuPi5MDmkzdpWsU75421XNl4/DqxIUE80agxVapUUR3HohlTcVQ09cGllMlCiOHABgz3h8ySUoYIIT7FcMm00tTHtCUnTpzA3cMT12rN6NfEX3UcrYA5ODiQmppKcnwsTSt7seXkTcZ3eWgQopZHa/89jQvJDHi5v+ooFi/XFYeUskAmyZFSrgXWZnptQjZlWxZEBmv1fM8X+O5MMQJ8i1GlVBHVcbQClpqaSt26dWnUqBFtBo1n/N8hhN6KplJJ/d8+v87ejOZynBM/r9hG3yf8VMexeHquKisVFxfHxpDr3IhO5uWm/qrjaGbg4OBAw4YNWbJkCU+WN1QW+mZA01h/7CoyOYlnaukp1HMj1xWHEKJ8Lh5+Qgg9F4IZDBkyhJef70TZYm60rm77c1NpBv379ycqKor92/6huq8Hm/TqgCYRuGId137tz9Wzx1VHsQrG9HFcwNDxnSMhxA1gGfCJlFIvXWZiMTExLFv2Fw4BzejfxB9HO+oUTzdgwADVEZRo0aIF5cqVY968ebQe+R3TtoVyLy4Jz0L6W3Je3YyM57+gVTgKSc2aus8oN4xpqpoLbAMEcA/YCixO+3kv7fWtGPorEoE3gH1CiJKmDKzB8uXLiY2NoVidNvRqWC7nDWzQgAED7LLycHBwoF+/fmzYsIG6XpKUVMm207dUx7Jqqw9dIPb0Lrp060GhQoVUx7EKxlQcXwJ1ga8w3MndWkrZV0rZGsO9GN+kvf8OUAnD/R4VgLGmjazNnjMXZ08f+nZ5huKF7XMm3PDwcMLD7fNidvDgwfz999+0qFOZEoVddD9HPs1ZsASZGMewQQNUR7EaxlQcXwH/SSk/kFLGZHxDShkjpXwfOAJ8JaVMlVJ+AhwGupournbt2jWCgjbjXrMlLzcz+Qhpq9GzZ0969uypOoYSFSpUoEuXLri5utCyWkmCTt0kJVUv7pQXUfFJHNi8Cs+SvrRo0UJ1HKthTMXxNLArhzK7gIxnfw+Gu8E1Eyla1JOqvcbStFNPapWxnzvFtQeFh4czbtw4qjjd5W5sEocu3VEdySptPX2Lok16MW7itzg46EGmuWXMmXIFfHMoUzqtXLpo9GJPJrX3chTxFZow7NmmqqNoin3zzTec2LYSJwfBZt1clScbQ25Qpmpd3hr0ouooVsWYiuM/oLcQonZWbwoh6gC9MDRPpfMHdM+diZw8eZJ3J0zEyzmJ9rVyqsM1W+bt7U3nzp1ZuiiQhuWLslkPyzVaYnIqi2f8QG2323Y5MjE/jKk4PgXcMIyU+l0IMUAI0THt5wwMiyy5YVg7AyFEIaAdsNPUoe3Vdz/9xsFlv/J8/dI4O+rLanvXv39/rl+/jm/0GU7fiObybfuZ9NEUFm/aw40tc3APP6U6itUxZsqRDUKIF4HfMExi+GqGt9OH6L4qpdyQ9poL0BvD2uRaPqWkpLAwMBD3yg0Y9Exd1XGUGzp0qOoIynXq1IkSJUoQunsdBLzMlpM39SwCRvht5hwQDox549Ucy2oPMuYGQKSUi4QQazCs0lcf8AQigUPA31LKqAxl72GYvFAzgTXr/yHq9k069XuHUh5uquMo17t3b9URlHN1dWXAgAGEh4dT0cudzbriyLWUlBT2b16FX+1GVCyvx+8Yy6iKA0BKGQ38mfbQzOSbn6YjXAszblg/1VEswuXLhoUjy5Wzzxsg002ePBmAz9cc549dF4lOSKaIq9H/W9uducs3kHDnOj3e0reZ5YVuKLcCqampnL4SQfkn2vJkgO4UB+jXrx/9+ulKNN1jnskkpqTqtchzafmO/3AqWpJ3h+gFm/Ii268mQoj0SemXSymjMjzPkZRybr6TafftCb2Ne6cxfPP8Y0atgazZh5kzZ/Laa69Rc9QfbAi5QZc6ZVRHsmgR0QmcLFKPd2ZuxK9UCdVxrNKjrmnnYJjUcA8QleH5o4i0MrriMKHfNx6iuLszz9YrqzqKZoHatm2LlJLi1/YSdLIUCckpuDo5qo5lsX5df5CEpBQGPa1X+curR1Ucr2KoBK6lPX+l4ONomW3be5A5wzvQ573JuDm3Ux1Hs0AVKlSgRYsWnN29DsfyHdh9LoKW1fRU+1mJT0rm8zf+D1//KlT5uovqOFYr24pDSjkn0/M/CjyN9pCPvp4KDg681f851VE0CzZgwABeeeUVKlw/zoaQCrriyMakuauIv3mBXiNHqo5i1XTnuAWLiopm+7q/KN+gNY1q+KuOY1Heeecd3nnnHdUxLEavXr0oVqwYLueC+ef4DT3pYRaklPz62zQcXd0ZN3KQ6jhWLV/j9oQQzwKtMfRtbJNSLjNJKg2AL3+aSUp8DEMGD1EdxeJ07aonXc7I3d2dlStXEiZKMnb1OQ5dukNDf93xm9H6g+e4djiItt164eHhoTqOVXvkFYcQoqsQYpsQ4qH5hoUQs4HlwEhgBLBYCKErDhOaPXs2riXL81a/Z1VHsTinTp3i1Ck9KUFGzZs3p0vDyjg7CjaEXFcdx+J8+v3vyOREPh3zpuooVi+npqpngccxzEN1nxCiC/AyEAtMBN4DQoHnhBB9CyCn3YmITsCt42hefv8bCrnoG7oyGzJkCEOG6CuxzHYGbyZ+zZesP3oVKXVzVbpzt6K5WqoJgz+fzpONGqqOY/VyqjgaAbullPGZXk8fcfWKlHKClPJboDkQD+j5iU1g2cEwZKHijH6xk+oomhWJjY0l7L8dnNq3jZPXo3LewE7M2nEeVzdXPh+Z69vRtEfIqeLwBc5l8frTwF3gftOUlPI6sAbDHFZaPkRGRjJ2yItUklcJ8NFtsVruPfvss/iWLkP04bW6uSrNnZhEfpv8OeWuBOFdxDXnDbQc5VRxFAduZ3xBCFEeKAHskA9fC58HvEwXzz5N/H46t0/upV1NPb2IZhwnJydeHzKYuNADLN96UHUcizBj81Hu7F1OyZQI1VFsRk4VRxQPL/3aIO3noWy2ydyspRlBSsnsmb/j5lOJN/t2VB1Hs0KDBg3CwdGRwxuX2P0aHYnJqfw0fTYyOZH33hquOo7NyKnX9SjQWQhRJG1WXIDuGPo3dmRRviL/u9Ncy4N/tu4k/OJpOr8+XneKP8K4ceNUR7BYZcuWZdib77DwrGF01aDmlVRHUmb1kStc27uaarXrUb++bkU3lZyuOP7E0Fy1VQgxUgjxE4bO7+tAUMaCwjD7XjPgeEEEtReffvs9wqUQn7zzuuooFq1t27a0bdtWdQyL9ePkr2nQqpNd93NIKZk0bzVJ4Rd5e4Re+MuUcqo4ZmJYjKk+MAUYBiQDb0opUzKVbYOhM32TqUPaCyklt9zKUaN9PxpU0TOcPsrhw4c5fPhwzgXtWPPyhQhe+xe3ohJUR1Fi7/nbnL+TSKNWHenbV98lYEqPbAuRUqYKIToDfYGmQATwl5Qyq/9jvYHvgZUmT2kn/j1/m4SANnz+gl4aNiejRo0CIDg4WG0QCxZ1dDPhqyYz4+82jH3J/vrLZmw/T+nKNdn6+3DcnPVswaaU41xVUspUKeWfUso30u7ZyPJrnpRyoZTyLSnlFWMCCCE6CCFOCSHOCiHez+L9t4UQx4UQR4QQm4UQFYzZv7WQUvLJ9zMo7JhM58dKq46j2YAxIwbj4OzKnBnTVUcxu8u3Y1mzeSsdyjvoSqMAKJ3kUAjhCPwMdARqAn2FEDUzFTsENJRS1gGWAt+YN6V5rN8UzLof3qdy5BEKueg/dC3/SpQoQb2WnTmzax1hN8JVxzGr+XsuErH+R9b98J7qKDZJ9ey4jYCzUspQKWUisBDolrGAlDJISpk+pnAPDw8PtgmffPs9wrUwH7+lZ+3UTGfk8GHIpAQ+mzpNdRSziU9KYUbgXyTdusjI4W+ojmOTVI/3LAtczvA8DGj8iPIDgXVZvSGEGAwMBvDx8clz23d0dLTZ281vhYfz75Y1lH2iI5GXThF8yXIm71NxPnLj7t27gPn7OCz1fGSnnIcDhcoEsGnrTpPnttRzsfNKEle2LqSYV0n8/PzMltFSz0eBkFIqewAvADMyPO8H/JhN2ZcwXHG45rTfBg0ayLwKCgrK87Z59Wy/wRLhIH/5e4fZj50TFecjN3bu3Cl37txp9uNa6vl4lHcW7JE1x6+TcYnJJt2vpZ6L5m//IgE5ZcoUsx7XUs+HMYD9Mhef3aqbqsKAchme+wFXMxcSQrQFPgSelVLa1NjCmIQkgnfuo2yDtgzp0lR1HKvRtGlTmjbV5ys3Oj9ekZjEFNbuO6k6SoE7duUex478RzFvH1577TXVcWyW6opjHxAghKgohHAB+pBpOK8Qoj4wDUOlcVNBxgL1+/bzFOv5KYFzZ+LgIFTHsRq7du1i165dqmNYhaaVvUg9v5cXnq7H0aNHVccpUPP3XMTnyec4ceo0hQsXVh3HZimtOKSUycBwDDcZngAWSylDhBCfpq0uCPAtUARYIoQ4LISwmftEzoTd5Ke1B+lSpwzNa9hkn3+B+eCDD/jggw9Ux7AKrk6OvPZCZ6SjMyPG2O5ULfdik1gcdIDn6pfBt0RR1XFsmurOccaOq9sAABhTSURBVKSUa4G1mV6bkOHfNjuvxMvvfELo8lkMPKJnadEK1pjnGjL76efZuuFP9hw4zJMN6qmOZHI/r9zB+V8G4Vr+O6CO6jg2TXVTld3adTKMvavmU61+Yx6vXlF1HM3GuTo5Mue7TxDObrwy8qH7bK1eaqrkp6mTcXB04vX+vVXHsXm64lBASsmQD74iNS6Sn775THUczU48/VglWnbvx8m9W1i+K0R1HJP6e+cxru3fQLvuffD11evYFDRdcSiwbN95TmxcQO0nnqJNi+aq42h2ZMGPn9Ns7Hy+2XqdyPgk1XFM5qMvvgKZypTPx6uOYhd0xWFm8UkpTPhlESkxd5jy5aeq41itqVOnMnXqVNUxrI5vSW9+HNyOG5HxfLriP9VxTOLirUiO79xA/ZadqR5QRXUcu6C8c9zezNgeSqxvHRZt2kub1k+ojmO16tWzvc5dc6nr54n7tqn8+ncSzz6+hKerllQdKV+WHrpG2YG/8PvgBjkX1kxCX3GY0Y3IeH765zgdavnSq00jDGtfaXmxadMmNm3SS7/khRCC9k3qEXtyG2/+upooK26yiolLYMHeSzxTryINalRWHcdu6IrDjL5ZG0Lo9OG4HlmqOorVmzhxIhMnTlQdw2q9/94Y3NwKceafuXyx1nrvKB85/guO/jiY52oVVx3FruiKw0yOht1j7oKFJN0Oo2XTRqrjaHauZMmSjBj+BrEntjF33S52nLG+adcTEhJYMOMX3IsWo9Pj+mrDnHTFYSZfrg0hes8SatSsSbdu3XLeQNMK2OjRoynk5oY8uor3lh0hOiFZdSSjfPX9r8TfC+eVYW/r6XrMTFccZrAnNIJN69YQf+si4z78EAcHfdo19UqVKsXKlSsJnPETV+7GMX/PRdWRci0iIoKvJ36Km18Nxg/upTqO3dGfYAVMSsnkDaeI3beUgICq9Oql/8g1y9GmTRta1PanaeUSzN55nsTkVNWRcuWjLycTF32PQe99Tokirqrj2B09HLeA7Tgbzr6Ld/j8l7k093PGyUmfclOYNs1+VrQraAcPHmTv5EHENxvBqv+q83wDy59w807VzlQe4MXEV7uojmKX9KdYAZJS8sWyvZT2cOX1Tg1xddJriZtKtWrVVEewGWXLluXOzWukbv6J6TWr0ePxshY7VDwxMZGN/11kZ+hdxr/aA093Z9WR7JJuqipAm0KusmXqKAj+UVcaJrZq1SpWrVqlOoZN8PHx4ccff+TehRD+XTWfHWctd4TVN99+y/OtG+HrHE+/JyuojmO3dMVRQKSUjBz3/+2deXhU1fnHPy8hgBEMaEQWEVARRagLi4giQZBFCxQVBZQfVGtFxKWxuFAXZGnVinWpUK1LKFYFwSW2tlSBiIqoVMuPRUBAUASVhk1lTXj7xznBYZghMyEzN8y8n+eZZ2bOPfec733v8t6zj2PXNyu56Zorg5aTcowfP57x48cHLSNlGDhwIL1692bLu5P5/ZRZQcuJyMqVKxk9ZgxVG7Tgrn4dqFbVHl9BYZZPEPn//IBlf3+GNp26cXm/fkHLMYwDIiI8+cQTZGUdTuErk/l0/dagJe2DqjL0umGUkEHHwSO4sJXNgBsk5jgSQEnJHn590/VUqVqVaX95qtLWFxtGKPXq1WN24Rwa9ryOP7+zKmg5+zB16lTeevNfZJ97JeOuOM/uqYAxx5EAnpv1CVu+Wcs1eXfS+LhGQcsxjJhpe0YrLm/XhJffW8y8BZVnZcrX/zGDGvWb0e//rqZ14yODlpP2WK+qCqZkjzJ54fecd/skHh1xQdByDCNuft6hMb+9qgf9/lmHzxd/XCm6kB/b62bqHdmTOy48NWgpBlbiqHBuvX8Cn63byC0XnUam9aRKGJMnT2by5MlBy0hJGufUJHfA9axdvpBxv7s/UC0LFy7kzXn/Yer8Lxmc24ImOYcHqsdwmOOoQF599TUeGjmcrFWz6dnSGu8SSaNGjWjUyKoBE8UDI64lq/k5jB0zmkWLFgWiYdeuXQwaNIhL+vQiK1O4sUuzQHQY+2OOo4IoKiri6muHkpnTmAfv/rVNupZgpkyZwpQpU4KWkbKcflwduv5iJFTLYvCQIezendw1O4qLixk4cCALFiygxjmDuaFLc448vFpSNRjRMcdRAWzYsIHOnc9nU1ERZw0eyYWn2Ztwopk4cSITJ04MWkZKc8OFranddSg16tRj+/btScu3pKSEQYMGMX36dE7+2XCatTufwR2aJC1/o2yCb/VKAQYMvIIlS5dx9CV3MfaXfa2roJESnH9yXVp17E5WtQupVasWW7dupVatWgm/vidOnMiLL77IKb2Hsq15D27veTI1Mq29sDJhJY6DZOMPu9jTfghHX3oPj9wymE6H+PrNhlFKlSrCNR2PZ9FXW3lzwee0b9+evLw89uxJ3Ay6qsoRp/egwSUjyTyzL48PPJNepzVIWH5G+bASRzlZs2YNE/6cz4fZ57FO6zDpN+fT7VRrEDdSi75nNGT8v5bx5Nx1dDq/Kw8//DDr169n0qRJFZqPqnLvuPv4LPtM3vuqmM49evNgv9Ool12jQvMxKgZzHOVg1apVnHteLt8WbeTEa5vy3M0/pW0TG5RkpB41MjMY0b05I19ZxJH1evGLvNo89dAYNmzYQF5eXoXkoapcdtV1TMt/gpwuv+C+USP5eYcm1sGkEmOOI06WL1/OuZ1y2bjle0656kGm39GXk46pFbSstGPatGlBS0gbLm97HC3qZzNi2gLe/P4sug4dTeFTo8nIyOCiiy46qLS37SzmgiuGMnf60xzX8WJmTB7PyfWPqCDlRqIwxxEHS5cupUPHTmzdtpPWwx7m5TsH0LD2YUHLSktycnKClpBWtDo2m4Lh5/Knt1fy2Cyh8RVjadOuKaparsbyXcV7eGHuCm6/bQRfzyugbY9+zCl4nhqZ9kg6FLCzVAYbNmxg586dHFb7aJ6auYit23eTm/dHXrr9MupYv/LAyM/PB2DIkCGB6kgnqlWtwo1dmtGjZT1GTMvm+S82s/6ZeWybOYH2bc+kW7dutGjR4oCO5IftO/jjy2/z+tpMvtz4A9+t/JiLr7yKlyb9mSpVrK/OoULgZ0pEeojIMhFZISK3R9heXUSm+O0fiEiTRGsqKiriqaeeokvXC6hXvz5dBt1Iu9/O5KUvanDZ2Od4/a4B5jQCJj8/f6/zMJLLScfU4uXrOtC/eTXeWbiSgllzycvLo2XLluTUPYbL+vfn3Xff3WefRUs+pdega6lzdH1GXnMZtasL+VedxYY1y5k++WlzGocYgZY4RCQDeBy4AFgLfCQiBaoaOi3n1cAmVT1RRPoD9wOXJ0rT2HHjmD17NntKSsis04Ca7S7hsNMuYMB5x9Pn9AacXM/qXw0jo4rQo2kmQ3v15b7WpzDn48V8u+xjdqxZwMt/f5MVWafS/dsjyN7xNU+MvoXVyxZBlQzqtTyHm64fyq+v6lgpJk80yoeoanCZi5wNjFLV7v7/HQCq+ruQODN8nPdFpCrwNXC0HkB4mzZtdP78+XHrWZ5/PeMnFbB9VwndW+Zw9gl1OLpWdWrWqIqQnj08Nm/eTO3atYOWsR+5988DoPC29knNt7LaIwhCbaEoO4v38MPOYr7fUcx3O4vZvruE2Z8W8ew76+jeMoehnY+jeb2aKXsvVZpro14r6HlfuXYVkX+rapuy4gXt8hsCX4b8XwucFS2OqhaLyBbgKGCfhZFF5JfAL8GtoVxYWBi3mNrfbeLG8xuSXb0Kh2eCUEzJjmK27Ig7qZShpKSEzZs3By1jP4qLiwGSrq2y2iMIItkiA8jOgOwsUITG7XIY1DaHGhkglLBl85ZgxCaBynJtfF+8lhXleP7FQ9COI9KrR3hJIpY4qOqTwJPgShy5ubnxq8nNpbCwkFPLs2+KUlhYSLlsmWCqvpYLQO1fFSY138pqjyAwW+xLZbFHbeDYBOcRtONYC4TOCHgssC5KnLW+qiob2JgceUZl5Y033ghagmGkLUF3ZfgIaCYiTUWkGtAfKAiLUwAM9r8vBWYdqH3DSA+ysrLIysoKWoZhpCWBljh8m8VwYAauevQZVV0sIqOB+apaADwNTBaRFbiSRv/gFBuVhQkTJgAwbNiwgJUYRvoRdFUVqvoG8EZY2N0hv3cA/ZKty6jcTJ06FTDHYRhBEHRVlWEYhnGIYY7DMAzDiAtzHIZhGEZcmOMwDMMw4iLQKUcShYhsANaUc/ccwkalpzlmj30xe/yI2WJfUsEejVW1zPWvU9JxHAwiMj+WuVrSBbPHvpg9fsRssS/pZA+rqjIMwzDiwhyHYRiGERfmOPbnyaAFVDLMHvti9vgRs8W+pI09rI3DMAzDiAsrcRiGYRhxYY7DMAzDiIu0dRwi0kNElonIChG5PcL26iIyxW//QESaJF9l8ojBHnkiskRE/l9EZopI4yB0JoOybBES71IRURFJ6S6YsdhDRC7z18diEXk+2RqTSQz3ynEiMltEPvH3y4VB6Ewoqpp2H9wU7iuB44FqwAKgRVicYcCf/O/+wJSgdQdsj85Alv99XaraIxZb+Hi1gDnAPKBN0LoDvjaaAZ8Adfz/ukHrDtgeTwLX+d8tgNVB667oT7qWONoBK1R1laruAl4E+oTF6QNM8r+nAV1EJNIytqlAmfZQ1dmqus3/nUfiV6cMiliuDYAxwANAqq9IH4s9rgEeV9VNAKr6bZI1JpNY7KHAEf53NvuvanrIk66OoyHwZcj/tT4sYhxVLQa2AEclRV3yicUeoVwN/COhioKjTFuIyBlAI1X9WzKFBUQs18ZJwEki8p6IzBORHklTl3xiscco4EoRWYtba+iG5EhLHoEv5BQQkUoO4f2SY4mTKsR8rCJyJdAG6JRQRcFxQFuISBXgD8CQZAkKmFiujaq46qpcXEn0HRFpqaqbE6wtCGKxxwAgX1XHi8jZuBVMW6rqnsTLSw7pWuJYCzQK+X8s+xcn98YRkaq4IufGpKhLPrHYAxHpCvwG6K2qO5OkLdmUZYtaQEugUERWA+2BghRuII/1XnlNVXer6ufAMpwjSUViscfVwFQAVX0fqIGbADFlSFfH8RHQTESaikg1XON3QVicAmCw/30pMEt9a1cKUqY9fPXMEzinkcp12Ae0hapuUdUcVW2iqk1w7T29VXV+MHITTiz3yqu4zhOISA6u6mpVUlUmj1js8QXQBUBETsE5jg1JVZlg0tJx+DaL4cAM4FNgqqouFpHRItLbR3saOEpEVgB5QNRumYc6Mdrj90BN4CUR+Y+IhN8sKUGMtkgbYrTHDKBIRJYAs4ERqloUjOLEEqM9bgGuEZEFwAvAkFR76bQpRwzDMIy4SMsSh2EYhlF+zHEYhmEYcWGOwzAMw4gLcxyGYRhGXJjjMAzDMOLCHIcRNyIyxM8KOyRoLYci3naFYWGjfHhuMKpARJp4DflBaTAODcxxpCD+5g/9lIjIf0VklohcEbQ+I3YiORnDCJp0nasqXbjXf2cCzYGfAZ1FpLWq5gUny4jAH3EzrX4RtBDDKAtzHCmMqo4K/S8iXYA3gZtF5FFVXR2ELmN/VPW/wH+D1mEYsWBVVWmEqs4EluJm+GwLICK5vjpkVKR9RGS1n8yvTETkJyLygt9np4hsEJGPReRhEckMi1tVRIb5abi3isg2v2LacD8DbUyISGsReUREFojIRhHZISKfich4EakTIf7e9hkRuUBE3hGR773WZ0Wkto93hoj8TUQ2+e0FEmEVSBEp9OlVF5GxIvK5P/aVInKPn88oluPYp42jVKff3Cms6nGUj1OucycitUTkIRFZ6+21VETyOMDzQESyROQOP93MD94m74vIgFiOryxEpIGI3C1uavavRWSXiKwTkef9fE/xpBW1ek9E8v32JhUgO22xEkf6UTotdIXONSMiPwE+8OkWAJ/jFrM5Ebea4p3Abh83E3gd6I6bSfV53IJInYHHgLOAQTFmfQ3QF3gbeAu3QtuZuPnFeorIWar6XYT9egM/Bf4G/AnogJsqvam45UBnAu/g5ixrBfQCThCRVlGmx56Kc8bT/HH2wa3L0EZEepdjrqL/4Koa7wHWAPkh2wrjTGsvIlIdd2xtcavX/RWoDdxFlKnyvTOdBZwBfAw8g3My3YHnReRUVb2zvJo85+Hmg5sNTAe+x82weynQW0TOUdUFB5mHUVEEvQShfSr+g3t4a4TwrsAe/2nsw3J9/FFR0lpN2NKXuAes4iZvKw0b78P6REijDlAl5P8oH/cxICMkPAP3oI6YThR9jUPTCAm/2qdzWxTtxUCnkPAquGo8xU2ff0XYfhF14R7iCizHL53qw2sA7/ttgyKcn8KwsFKb5JYVN2Rbec7dSL/P9LBz0tQft+LWkgjdJ9+H3xoWXgP4p7+eTj/Ia7YuUCtC+Gk4J/KPOK//aDYrPZYmB6M33T9WVZXC+OqPUSIyTkSm4W5yAR5W1TUJynZ7eICqblL/lu6roYYDXwO/UtWSkHgluJlFFYip95eqrglNI4RngK24t+JIvKCqb4eksweY7P8uUtW/hsX/i/8+PUp6Y9QvnerT2wHc4f9edYBDSDY/xz3ob9WQkpO6dTQeDY8sIkcBVwLzVfWB0G3+GG/DXVMDD0aUqn6rEUqG6koZs3CdOjL339MIAquqSm3u8d8KbMZXvajqcwnIawpwE/Cqd1JvAe+p6sqweCfhluD9DLhTIi/jvh2IqV7bP0yuxa2L0AK34FboC1G0JXAjrZ9RuiDPvyNs+8p/R1tr/e0IYe/gSjZnRNknqYhILVzV4ZcRzgu40tM9YWFtcSXBaG0ppQ/zuNohoui7CBiKW2Eyh/2fTznA+oPNxzh4zHGkMKoa8amcoLw+FJGOuBUCL8W3UYjIMuBeVX3BRy1dt70Z+z+kQqkZY9ZTcG0cq4DXcCWZ0tUJbwaqR9lvS4Sw4hi2RXvr/SY8QFVLRKQIVw1TGcj23/tp9XwdIaz0fLX1n2jEer4iIiI3Ao8Am3BVhl8A23AvPT/DVVlFO5dGkjHHYZRWV0S7FrKJ/CDdD3XLZP7UN8C2BnoAN+AaUDeo6lshab2iqheXXzaIW661L650c6Gq7g7ZVgW49WDSj5NjCBuDISIZuAfv1gTlGe+5K/19TJT49SKEle7zB03Q2B9xSzPfi3NcZ6rq+rDtZ8eZpBLdJrXjV2iEY20cRmm9fKPwDSJyIuW40VR1p6rOVdW7gRt9cB//vRRXbda+AuqsT/TfBaFOw9MOOOwg04+HSD2SOuIeYJ8cRLp7cFVFkYjr3Pk2hBVAQxE5IUJ6uRHCPvQaOsaotzzk4LTOjeA0auJ6ycXDJiLbJIPobVRGHJjjMJbi3oj7iMjeKhUROYwIjaXREJGOIpIdYVPp2+022Lv05mNAfeBRn094WvVFpEUM2a7237lh+9cFHo9NeYVxV+i4ERGpAfzO/332INItIsJD0FOec/cs7r6/P3S8jIg05Ucnvxd168v/Fdet+C5fOtgHETnB7x8aVjq+JfdAB+f5Fnd9tPaOojSNTFz1VU6knXy+J0d4AfkQOE5EuoWF34nrhRdPWkYErKoqzVHV3SLyCK4f/yci8gruurgA11i87kD7h3AL0M0PvFqF60J5KtAT9wb4ZEjcMbg666FALxGZhWt8rotr+zgH11aypIw8PwLeAy4WkbnAuzhH1RM3PiRW7RXBp8Bi3zGgdBzHCcDf+bG3VnmYCfQXkddxjfbFwBxVnVPOczce12ZwCfCxiMzAVWldDszBjW8JZzjuvIwGBonIu7h2kga4RvG2wADc2J1SSp1SMWWgqntE5FHcOI6FIvIaUA03rudI3NiOzlFs0xjXlXh1SPiDuN50r4nIFFw34w4+XiGRS1bR0jIiEXR/YPtU/Ico4zgOEF9wN+1KYBeurv4BIIvYx3F0w73NLsHVi/+Ae3g/ih8zEiHPQbgbdqPP9yvcw38k0ChG7UcCE7zOHf4YfhuP9pBtuUQZFwE0IfIYh0IfXh0Yi3t47sQ5z3uA6lHOT2FY2Cgij+Ooixsg+Q1QEq4v3nPn9zkCeMjbeweu5HILcHykY/T7VMM5kLn+/O70ec3EdUI4KkxTkbdF1RjPY1XcoM0luF51X+McbmOijL3wxxdxTAbOAc73x1eEmwesXGnZZ/+PeKMZhlEOfAmrkyaxB1tlx88isAC4XlUnBK3HqHisjcMwjIqmE66E9EzQQozEYCUOwzgIrMRhpCNW4jAMwzDiwkochmEYRlxYicMwDMOIC3MchmEYRlyY4zAMwzDiwhyHYRiGERfmOAzDMIy4+B/fZbMfbjoIqQAAAABJRU5ErkJggg==\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -571,7 +572,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -676,7 +677,7 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -691,12 +692,12 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 27, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -809,7 +810,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/qiskit/providers/aer/openpulse/__init__.py b/qiskit/providers/aer/openpulse/__init__.py index 7c63cf6d57..ad3da6e242 100644 --- a/qiskit/providers/aer/openpulse/__init__.py +++ b/qiskit/providers/aer/openpulse/__init__.py @@ -11,17 +11,18 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. - +"""Init for openpulse""" import distutils.sysconfig import numpy as np from .qutip_lite.cy import pyxbuilder as pbldr # Remove -Wstrict-prototypes from cflags -cfg_vars = distutils.sysconfig.get_config_vars() -if "CFLAGS" in cfg_vars: - cfg_vars["CFLAGS"] = cfg_vars["CFLAGS"].replace("-Wstrict-prototypes", "") +CFG_VARS = distutils.sysconfig.get_config_vars() +if "CFLAGS" in CFG_VARS: + CFG_VARS["CFLAGS"] = CFG_VARS["CFLAGS"].replace("-Wstrict-prototypes", "") # Setup pyximport +# pylint: disable=no-member pbldr.install(setup_args={'include_dirs': [np.get_include()]}) del pbldr diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 92fea7be83..ae1ee1a8fe 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -29,7 +29,6 @@ from . import op_qobj as op - def digest_pulse_obj(qobj): """Takes an input PULSE obj an disgests it into things we can actually make use of. @@ -47,7 +46,7 @@ def digest_pulse_obj(qobj): # Output data object out = OPSystem() - #get the config settings from the qobj + # get the config settings from the qobj config_dict_sim = qobj['config']['sim_config'] config_dict = qobj['config'] @@ -92,8 +91,7 @@ def digest_pulse_obj(qobj): if 'n_registers' in config_keys: out.global_data['n_registers'] = config_dict['n_registers'] - - #which level to measure + # which level to measure out.global_data['q_level_meas'] = 1 if 'q_level_meas' in config_keys_sim: out.global_data['q_level_meas'] = int(config_dict_sim['q_level_meas']) @@ -107,61 +105,58 @@ def digest_pulse_obj(qobj): for key, val in config_dict_sim['ode_options'].items(): if key not in allowed_ode_options: raise Exception('Invalid ode_option: {}'.format(key)) - else: - user_set_ode_options[key] = val + user_set_ode_options[key] = val out.ode_options = OPoptions(**user_set_ode_options) - # Step #1: Parse hamiltonian representation if 'hamiltonian' not in config_keys_sim: raise ValueError('Qobj must have hamiltonian in config to simulate.') - else: - ham = config_dict_sim['hamiltonian'] - - out.vars = OrderedDict(ham['vars']) - out.global_data['vars'] = list(out.vars.values()) - - # Get qubit subspace dimensions - if 'qub' in ham.keys(): - dim_qub = ham['qub'] - _dim_qub = {} - # Convert str keys to int keys - for key, val in ham['qub'].items(): - _dim_qub[int(key)] = val - dim_qub = _dim_qub - else: - dim_qub = {}.fromkeys(range(config_dict_sim['n_qubits']), 2) - - # Get oscillator subspace dimensions - if 'osc' in ham.keys(): - dim_osc = ham['osc'] - _dim_osc = {} - # Convert str keys to int keys - for key, val in dim_osc.items(): - _dim_osc[int(key)] = val - dim_osc = _dim_osc - else: - dim_osc = {} - - # Parse the Hamiltonian - system = HamiltonianParser(h_str=ham['h_str'], - dim_osc=dim_osc, - dim_qub=dim_qub) - system.parse(qubit_list) - out.system = system.compiled - - if 'noise' in config_dict_sim.keys(): - noise = NoiseParser(noise_dict=config_dict_sim['noise'], - dim_osc=dim_osc, dim_qub=dim_qub) - noise.parse() - - out.noise = noise.compiled - if any(out.noise): - out.can_sample = False - out.global_data['c_num'] = len(out.noise) - else: - out.noise = None + ham = config_dict_sim['hamiltonian'] + + out.vars = OrderedDict(ham['vars']) + out.global_data['vars'] = list(out.vars.values()) + + # Get qubit subspace dimensions + if 'qub' in ham.keys(): + dim_qub = ham['qub'] + _dim_qub = {} + # Convert str keys to int keys + for key, val in ham['qub'].items(): + _dim_qub[int(key)] = val + dim_qub = _dim_qub + else: + dim_qub = {}.fromkeys(range(config_dict_sim['n_qubits']), 2) + + # Get oscillator subspace dimensions + if 'osc' in ham.keys(): + dim_osc = ham['osc'] + _dim_osc = {} + # Convert str keys to int keys + for key, val in dim_osc.items(): + _dim_osc[int(key)] = val + dim_osc = _dim_osc + else: + dim_osc = {} + + # Parse the Hamiltonian + system = HamiltonianParser(h_str=ham['h_str'], + dim_osc=dim_osc, + dim_qub=dim_qub) + system.parse(qubit_list) + out.system = system.compiled + + if 'noise' in config_dict_sim.keys(): + noise = NoiseParser(noise_dict=config_dict_sim['noise'], + dim_osc=dim_osc, dim_qub=dim_qub) + noise.parse() + + out.noise = noise.compiled + if any(out.noise): + out.can_sample = False + out.global_data['c_num'] = len(out.noise) + else: + out.noise = None # Step #2: Get Hamiltonian channels out.channels = get_hamiltonian_channels(out.system) @@ -169,22 +164,21 @@ def digest_pulse_obj(qobj): h_diag, evals, estates = get_diag_hamiltonian(out.system, out.vars, out.channels) - #convert estates into a qobj + # convert estates into a qobj estates_qobj = [] - for kk in range(len(estates[:,])): + for kk in range(len(estates[:, ])): estates_qobj.append(op.state(estates[:, kk])) out.h_diag = np.ascontiguousarray(h_diag.real) out.evals = evals - # Set initial state - out.initial_state = 0*op.basis(len(evals), 1) + out.initial_state = 0 * op.basis(len(evals), 1) for idx, estate_coef in enumerate(estates[:, 0]): - out.initial_state += estate_coef*op.basis(len(evals), idx) - #init_fock_state(dim_osc, dim_qub) + out.initial_state += estate_coef * op.basis(len(evals), idx) + # init_fock_state(dim_osc, dim_qub) - #Setup freqs for the channels + # Setup freqs for the channels out.freqs = OrderedDict() for key in out.channels.keys(): chidx = int(key[1:]) @@ -196,7 +190,7 @@ def digest_pulse_obj(qobj): if u_lo_idx['q'] < len(config_dict['qubit_lo_freq']): qfreq = config_dict['qubit_lo_freq'][u_lo_idx['q']] qscale = u_lo_idx['scale'][0] - out.freqs[key] += qfreq*qscale + out.freqs[key] += qfreq * qscale else: raise ValueError("Channel is not D or U") @@ -212,22 +206,21 @@ def digest_pulse_obj(qobj): # Step #4: Get dt if 'dt' not in config_dict_sim.keys(): raise ValueError('Qobj must have a dt value to simulate.') - else: - out.dt = config_dict_sim['dt'] - + out.dt = config_dict_sim['dt'] - # Set the ODE solver max step to be the half the width of the smallest pulse + # Set the ODE solver max step to be the half the + # width of the smallest pulse min_width = np.iinfo(np.int32).max for key, val in out.pulse_to_int.items(): if key != 'pv': - stop = out.global_data['pulse_indices'][val+1] + stop = out.global_data['pulse_indices'][val + 1] start = out.global_data['pulse_indices'][val] - min_width = min(min_width, stop-start) - out.ode_options.max_step = min_width/2 * out.dt + min_width = min(min_width, stop - start) + out.ode_options.max_step = min_width / 2 * out.dt # Step #6: Convert experiments to data structures. - out.global_data['measurement_ops'] = [None]*config_dict_sim['n_qubits'] + out.global_data['measurement_ops'] = [None] * config_dict_sim['n_qubits'] for exp in qobj['experiments']: exp_struct = experiment_to_structs(exp, @@ -250,14 +243,14 @@ def digest_pulse_obj(qobj): h_osc=dim_osc, h_qub=dim_qub, level=out.global_data['q_level_meas'] - ) - + ) out.experiments.append(exp_struct) if not exp_struct['can_sample']: out.can_sample = False return out + def get_diag_hamiltonian(parsed_ham, ham_vars, channels): """ Get the diagonal elements of the hamiltonian and get the @@ -279,20 +272,20 @@ def get_diag_hamiltonian(parsed_ham, ham_vars, channels): Raises: Exception: Missing index on channel. """ - #Get the diagonal elements of the hamiltonian with all the - #drive terms set to zero + # Get the diagonal elements of the hamiltonian with all the + # drive terms set to zero for chan in channels: - exec('%s=0'%chan) + exec('%s=0' % chan) - #might be a better solution to replace the 'var' in the hamiltonian - #string with 'op_system.vars[var]' + # might be a better solution to replace the 'var' in the hamiltonian + # string with 'op_system.vars[var]' for var in ham_vars: - exec('%s=%f'%(var, ham_vars[var])) + exec('%s=%f' % (var, ham_vars[var])) H_full = np.zeros(np.shape(parsed_ham[0][0].full()), dtype=complex) for hpart in parsed_ham: - H_full += hpart[0].full()*eval(hpart[1]) + H_full += hpart[0].full() * eval(hpart[1]) h_diag = np.diag(H_full) @@ -312,7 +305,6 @@ def get_diag_hamiltonian(parsed_ham, ham_vars, channels): return h_diag, evals2, estates2 - def get_hamiltonian_channels(parsed_ham): """ Get all the qubit channels D_i and U_i in the string representation of a system Hamiltonian. @@ -329,22 +321,24 @@ def get_hamiltonian_channels(parsed_ham): """ out_channels = [] for _, ham_str in parsed_ham: - chan_idx = [i for i, letter in enumerate(ham_str) if letter in ['D', 'U']] + chan_idx = [i for i, letter in enumerate(ham_str) if + letter in ['D', 'U']] for ch in chan_idx: - if (ch+1) == len(ham_str) or not ham_str[ch+1].isdigit(): - raise Exception('Channel name must include an integer labeling the qubit.') + if (ch + 1) == len(ham_str) or not ham_str[ch + 1].isdigit(): + raise Exception('Channel name must include' + + 'an integer labeling the qubit.') for kk in chan_idx: done = False offset = 0 while not done: offset += 1 - if not ham_str[kk+offset].isdigit(): + if not ham_str[kk + offset].isdigit(): done = True # In case we hit the end of the string - elif (kk+offset+1) == len(ham_str): + elif (kk + offset + 1) == len(ham_str): done = True offset += 1 - temp_chan = ham_str[kk:kk+offset] + temp_chan = ham_str[kk:kk + offset] if temp_chan not in out_channels: out_channels.append(temp_chan) out_channels.sort(key=lambda x: (int(x[1:]), x[0])) @@ -379,8 +373,8 @@ def build_pulse_arrays(qobj): total_pulse_length += len(pulse['samples']) num_pulse += 1 - idx = num_pulse+1 - #now go through experiments looking for PV gates + idx = num_pulse + 1 + # now go through experiments looking for PV gates pv_pulses = [] for exp in qobj['experiments']: for pulse in exp['instructions']: @@ -393,24 +387,25 @@ def build_pulse_arrays(qobj): pulse_dict['pv'] = pv_pulses pulses = np.empty(total_pulse_length, dtype=complex) - pulses_idx = np.zeros(idx+1, dtype=np.uint32) + pulses_idx = np.zeros(idx + 1, dtype=np.uint32) stop = 0 ind = 1 for _, pulse in enumerate(qobj_pulses): - stop = pulses_idx[ind-1] + len(pulse['samples']) + stop = pulses_idx[ind - 1] + len(pulse['samples']) pulses_idx[ind] = stop - oplist_to_array(pulse['samples'], pulses, pulses_idx[ind-1]) + oplist_to_array(pulse['samples'], pulses, pulses_idx[ind - 1]) ind += 1 for pv in pv_pulses: - stop = pulses_idx[ind-1] + 1 + stop = pulses_idx[ind - 1] + 1 pulses_idx[ind] = stop - oplist_to_array([pv[0]], pulses, pulses_idx[ind-1]) + oplist_to_array([pv[0]], pulses, pulses_idx[ind - 1]) ind += 1 return pulses, pulses_idx, pulse_dict + def experiment_to_structs(experiment, ham_chans, pulse_inds, pulse_to_int, dt, qubit_list=None): """Converts an experiment to a better formatted structure @@ -430,7 +425,7 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, ValueError: Channel not in Hamiltonian. TypeError: Incorrect snapshot type. """ - #TO DO: Error check that operations are restricted to qubit list + # TO DO: Error check that operations are restricted to qubit list max_time = 0 structs = {} structs['header'] = experiment['header'] @@ -442,9 +437,10 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, structs['snapshot'] = [] structs['tlist'] = [] structs['can_sample'] = True - # This is a list that tells us whether the last PV pulse on a channel needs to + # This is a list that tells us whether + # the last PV pulse on a channel needs to # be assigned a final time based on the next pulse on that channel - pv_needs_tf = [0]*len(ham_chans) + pv_needs_tf = [0] * len(ham_chans) # The instructions are time-ordered so just loop through them. for inst in experiment['instructions']: @@ -483,7 +479,7 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, else: start = inst['t0'] pulse_int = pulse_to_int[inst['name']] - pulse_width = (pulse_inds[pulse_int+1]-pulse_inds[pulse_int])*dt + pulse_width = (pulse_inds[pulse_int + 1] - pulse_inds[pulse_int]) * dt stop = start + pulse_width structs['channels'][chan_name][0].extend([start, stop, pulse_int, cond]) @@ -494,7 +490,7 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, # measurements if inst['name'] == 'acquire': - #Better way?? + # Better way?? qlist2 = [] mlist2 = [] if qubit_list is None: @@ -506,21 +502,19 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, qlist2.append(qb) mlist2.append(inst['memory_slot'][qind]) - - - acq_vals = [inst['t0'], np.asarray(qlist2, dtype=np.uint32), np.asarray(mlist2, dtype=np.uint32) - ] + ] if 'register_slot' in inst.keys(): - acq_vals.append(np.asarray(inst['register_slot'], dtype=np.uint32)) + acq_vals.append(np.asarray(inst['register_slot'], + dtype=np.uint32)) else: acq_vals.append(None) structs['acquire'].append(acq_vals) - #update max_time - max_time = max(max_time, inst['t0']+dt*inst['duration']) + # update max_time + max_time = max(max_time, inst['t0'] + dt * inst['duration']) # Add time to tlist if inst['t0'] not in structs['tlist']: @@ -537,7 +531,7 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, structs['cond'].append(acq_vals) - #update max_time + # update max_time max_time = max(max_time, inst['t0']) # Add time to tlist @@ -554,7 +548,7 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, if inst['t0'] not in structs['tlist']: structs['tlist'].append(inst['t0']) - #update max_time + # update max_time max_time = max(max_time, inst['t0']) # If any PVs still need time then they are at the end @@ -567,10 +561,12 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, # Convert lists to numpy arrays for key in structs['channels'].keys(): - structs['channels'][key][0] = np.asarray(structs['channels'][key][0], dtype=float) - structs['channels'][key][1] = np.asarray(structs['channels'][key][1], dtype=float) + structs['channels'][key][0] = np.asarray(structs['channels'][key][0], + dtype=float) + structs['channels'][key][1] = np.asarray(structs['channels'][key][1], + dtype=float) - structs['tlist'] = np.asarray([0]+structs['tlist'], dtype=float) + structs['tlist'] = np.asarray([0] + structs['tlist'], dtype=float) if len(structs['acquire']) > 1 or structs['tlist'][-1] > structs['acquire'][-1][0]: structs['can_sample'] = False diff --git a/qiskit/providers/aer/openpulse/qobj/op_qobj.py b/qiskit/providers/aer/openpulse/qobj/op_qobj.py index 3c092981a2..e879d7fdea 100644 --- a/qiskit/providers/aer/openpulse/qobj/op_qobj.py +++ b/qiskit/providers/aer/openpulse/qobj/op_qobj.py @@ -22,6 +22,7 @@ from ..qutip_lite.qobj import Qobj from ..qutip_lite.cy.spmatfuncs import (spmv_csr, cy_expect_psi_csr) + def sigmax(dim=2): """Qiskit wrapper of sigma-X operator. """ @@ -163,6 +164,7 @@ def basis(level, pos): """ return st.basis(level, pos) + def state(state_vec): """ Qiskit wrapper of qobj """ diff --git a/qiskit/providers/aer/openpulse/qobj/op_system.py b/qiskit/providers/aer/openpulse/qobj/op_system.py index 504dccb119..f21b537810 100644 --- a/qiskit/providers/aer/openpulse/qobj/op_system.py +++ b/qiskit/providers/aer/openpulse/qobj/op_system.py @@ -15,6 +15,7 @@ "The OpenPulse simulator system class" + class OPSystem(): """ A Class that holds all the information needed to simulate a given PULSE qobj diff --git a/qiskit/providers/aer/openpulse/qobj/operators.py b/qiskit/providers/aer/openpulse/qobj/operators.py index 3b2adb8607..c3c5f38054 100644 --- a/qiskit/providers/aer/openpulse/qobj/operators.py +++ b/qiskit/providers/aer/openpulse/qobj/operators.py @@ -19,6 +19,7 @@ import scipy.linalg as la from ..qobj import op_qobj as op + def gen_oper(opname, index, h_osc, h_qub, states=None): """Generate quantum operators. @@ -42,11 +43,12 @@ def gen_oper(opname, index, h_osc, h_qub, states=None): if opname in ['X', 'Y', 'Z'] and dim > 2: if opname == 'X': - opr_tmp = op.get_oper('A', dim)+op.get_oper('C', dim) + opr_tmp = op.get_oper('A', dim) + op.get_oper('C', dim) elif opname == 'Y': - opr_tmp = -1j*op.get_oper('A', dim)+1j*op.get_oper('C', dim) + opr_tmp = (-1j * op.get_oper('A', dim) + + 1j * op.get_oper('C', dim)) else: - opr_tmp = op.get_oper('I', dim) - op.get_oper('N', dim) + opr_tmp = op.get_oper('I', dim) - 2 * op.get_oper('N', dim) else: is_qubit = False @@ -109,6 +111,7 @@ def qubit_occ_oper(target_qubit, h_osc, h_qub, level=0): return op.tensor(opers) + def qubit_occ_oper_dressed(target_qubit, estates, h_osc, h_qub, level=0): """Builds the occupation number operator for a target qubit in a qubit oscillator system, where the oscillator are the first @@ -131,7 +134,7 @@ def qubit_occ_oper_dressed(target_qubit, estates, h_osc, h_qub, level=0): # osc_n * … * osc_0 * qubit_n * … * qubit_0 states = [] - proj_op = 0*op.fock_dm(len(estates), 0) + proj_op = 0 * op.fock_dm(len(estates), 0) for ii, dd in rev_h_osc: states.append(op.basis(dd, 0)) for ii, dd in rev_h_qub: @@ -140,7 +143,6 @@ def qubit_occ_oper_dressed(target_qubit, estates, h_osc, h_qub, level=0): else: states.append(op.state(np.ones(dd))) - state = op.tensor(states) for ii, estate in enumerate(estates): @@ -163,7 +165,7 @@ def measure_outcomes(measured_qubits, state_vector, measure_ops, Returns: str: String of binaries representing measured qubit values. """ - outcome_len = max(measured_qubits)+1 + outcome_len = max(measured_qubits) + 1 # Create random generator with given seed (if any). rng_gen = np.random.RandomState(seed) rnds = rng_gen.rand(outcome_len) @@ -218,7 +220,8 @@ def apply_projector(measured_qubits, results, h_qub, h_osc, state_vector): return psi -# pylint: disable=dangerous-default-value + +# pylint: disable=dangerous-default-value,comparison-with-callable def init_fock_state(h_osc, h_qub, noise_dict={}): """ Generate initial Fock state, in the number state basis, for an oscillator in a thermal state defined @@ -246,7 +249,7 @@ def init_fock_state(h_osc, h_qub, noise_dict={}): # consider finite thermal excitation levels = np.arange(dd) beta = np.log(1.0 / n_thermal + 1.0) - diags = np.exp(-beta * levels) + diags = np.exp(-1.0 * beta * levels) diags /= np.sum(diags) cum_sum = np.cumsum(diags) idx = np.where(np.random.random() < cum_sum)[0][0] diff --git a/qiskit/providers/aer/openpulse/qobj/opparse.py b/qiskit/providers/aer/openpulse/qobj/opparse.py index 13903ec940..53bee5c34e 100644 --- a/qiskit/providers/aer/openpulse/qobj/opparse.py +++ b/qiskit/providers/aer/openpulse/qobj/opparse.py @@ -26,7 +26,7 @@ Token = namedtuple('Token', ('type', 'name')) ham_elements = OrderedDict( - QubOpr=re.compile(r"(?PO|Sp|Sm|X|Y|Z)(?P[0-9]+)"), + QubOpr=re.compile(r"(?PO|Sp|Sm|X|Y|Z|I)(?P[0-9]+)"), PrjOpr=re.compile(r"P(?P[0-9]+),(?P[0-9]+),(?P[0-9]+)"), CavOpr=re.compile(r"(?PA|C|N)(?P[0-9]+)"), Func=re.compile(r"(?P[a-z]+)\("), @@ -133,7 +133,7 @@ def _expand_sum(self): # substitute iterator value _temp = [] - for kk in range(_l, _u+1): + for kk in range(_l, _u + 1): trg_s = ham[p_sums[0].end():p_brks[ii].start()] # generate replacement pattern pattern = {} @@ -211,9 +211,9 @@ def _tokenizer(self, op_str, qubit_list=None): if any([k.type == 'Var' for k in token_list]): for ii, _ in enumerate(token_list): if token_list[ii].name == '*': - if all([k.type != 'Var' for k in token_list[ii+1:]]): + if all([k.type != 'Var' for k in token_list[ii + 1:]]): coef = ''.join([k.name for k in token_list[:ii]]) - token_list = token_list[ii+1:] + token_list = token_list[ii + 1:] break else: raise Exception('Invalid order of operators and coefficients in %s' % op_str) @@ -366,6 +366,7 @@ def math_priority(o1, o2): else: return True + # pylint: disable=dangerous-default-value def parse_binop(op_str, operands={}, cast_str=True): """ Calculate binary operation in string format @@ -392,22 +393,22 @@ def parse_binop(op_str, operands={}, cast_str=True): if val0.isdecimal() and val1.isdecimal(): retv = int(val0) + int(val1) else: - retv = '+'.join(str(val0), str(val1)) + retv = '+'.join([str(val0), str(val1)]) elif key == 'sub': if val0.isdecimal() and val1.isdecimal(): retv = int(val0) - int(val1) else: - retv = '-'.join(str(val0), str(val1)) + retv = '-'.join([str(val0), str(val1)]) elif key == 'mul': if val0.isdecimal() and val1.isdecimal(): retv = int(val0) * int(val1) else: - retv = '*'.join(str(val0), str(val1)) + retv = '*'.join([str(val0), str(val1)]) elif key == 'div': if val0.isdecimal() and val1.isdecimal(): retv = int(val0) / int(val1) else: - retv = '/'.join(str(val0), str(val1)) + retv = '/'.join([str(val0), str(val1)]) else: retv = 0 break diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py b/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py index acd1e9fbe0..2d1ca0b4be 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py @@ -44,23 +44,30 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ############################################################################### -import sys, os +"""Utility for making the build options for compiling the Hamiltonian""" +import sys +import os import pyximport -from pyximport import install -old_get_distutils_extension = pyximport.pyximport.get_distutils_extension +OLD_EXT = pyximport.pyximport.get_distutils_extension + def new_get_distutils_extension(modname, pyxfilename, language_level=None): - extension_mod, setup_args = old_get_distutils_extension(modname, pyxfilename, language_level) - extension_mod.language='c++' + """Get the distutils extension""" + extension_mod, setup_args = OLD_EXT(modname, pyxfilename, language_level) + extension_mod.language = 'c++' # If on Win and Python version >= 3.5 and not in MSYS2 (i.e. Visual studio compile) - if sys.platform == 'win32' and int(str(sys.version_info[0])+str(sys.version_info[1])) >= 35 and os.environ.get('MSYSTEM') is None: + if sys.platform == 'win32' and \ + (int(str(sys.version_info[0]) + str(sys.version_info[1])) >= 35) \ + and os.environ.get('MSYSTEM') is None: + extension_mod.extra_compile_args = ['/w', '/O1'] else: extension_mod.extra_compile_args = ['-w', '-O1'] if sys.platform == 'darwin': extension_mod.extra_compile_args.append('-mmacosx-version-min=10.9') extension_mod.extra_link_args = ['-mmacosx-version-min=10.9'] - return extension_mod,setup_args + return extension_mod, setup_args + pyximport.pyximport.get_distutils_extension = new_get_distutils_extension diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/utilities.py b/qiskit/providers/aer/openpulse/qutip_lite/cy/utilities.py index f79772eaa5..1c9cd5ffdf 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/cy/utilities.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/utilities.py @@ -44,24 +44,29 @@ # (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE # OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ############################################################################### +# pylint: disable=invalid-name, no-name-in-module, import-error +"""Cython utilities""" import os + def _cython_build_cleanup(tdname, build_dir=None): + """Cleanup cython build files + """ if build_dir is None: build_dir = os.path.join(os.path.expanduser('~'), '.pyxbld') - + # Remove tdname.pyx pyx_file = tdname + ".pyx" try: os.remove(pyx_file) - except: + except OSError: pass - + # Remove temp build files - for dirpath, subdirs, files in os.walk(build_dir): - for f in files: - if f.startswith(tdname): + for dirpath, _, files in os.walk(build_dir): + for file in files: + if file.startswith(tdname): try: - os.remove(os.path.join(dirpath,f)) - except: + os.remove(os.path.join(dirpath, file)) + except OSError: pass diff --git a/qiskit/providers/aer/openpulse/qutip_lite/dimensions.py b/qiskit/providers/aer/openpulse/qutip_lite/dimensions.py index 394ee124a3..c65b481838 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/dimensions.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/dimensions.py @@ -49,11 +49,13 @@ Internal use module for manipulating dims specifications. """ -__all__ = [] # Everything should be explicitly imported, not made available - # by default. +__all__ = [] +# Everything should be explicitly imported, not made available +# by default. import numpy as np + def flatten(l): """Flattens a list of lists to the first level. @@ -73,6 +75,7 @@ def flatten(l): else: return sum(map(flatten, l), []) + def is_scalar(dims): """ Returns True if a dims specification is effectively @@ -80,6 +83,7 @@ def is_scalar(dims): """ return np.prod(flatten(dims)) == 1 + def is_vector(dims): """Is a vector""" return ( @@ -87,6 +91,7 @@ def is_vector(dims): isinstance(dims[0], (int, np.integer)) ) + def is_vectorized_oper(dims): """Is a vectorized operator.""" return ( @@ -95,6 +100,7 @@ def is_vectorized_oper(dims): ) +# pylint: disable=too-many-return-statements def type_from_dims(dims, enforce_square=True): """Get the type of operator from dims structure""" bra_like, ket_like = map(is_scalar, dims) @@ -142,6 +148,7 @@ def _enumerate_flat(l, idx=0): acc.append(labels) return acc, idx + def _collapse_composite_index(dims): """ Given the dimensions specification for a composite index @@ -152,6 +159,7 @@ def _collapse_composite_index(dims): """ return [np.prod(dims)] + def _collapse_dims_to_level(dims, level=1): """ Recursively collapses all indices in a dimensions specification @@ -163,6 +171,7 @@ def _collapse_dims_to_level(dims, level=1): else: return [_collapse_dims_to_level(index, level=level - 1) for index in dims] + def collapse_dims_super(dims): """ Given the dimensions specifications for an operator-ket-, operator-bra- or diff --git a/qiskit/providers/aer/openpulse/qutip_lite/expect.py b/qiskit/providers/aer/openpulse/qutip_lite/expect.py index edaeba7be1..6843391ca9 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/expect.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/expect.py @@ -105,6 +105,7 @@ def expect(oper, state): else: raise TypeError('Arguments must be quantum objects') + # pylint: disable=inconsistent-return-statements def _single_qobj_expect(oper, state): """ diff --git a/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py b/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py index 353111401f..e77c68eefc 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py @@ -57,6 +57,7 @@ from scipy.sparse.sputils import (upcast, isdense, isscalarlike, get_index_dtype) from scipy.sparse.base import SparseEfficiencyWarning + class fast_csr_matrix(csr_matrix): """ A subclass of scipy.sparse.csr_matrix that skips the data format @@ -64,12 +65,12 @@ class fast_csr_matrix(csr_matrix): """ # pylint: disable=super-init-not-called def __init__(self, args=None, shape=None, dtype=None, copy=False): - if args is None: #Build zero matrix + if args is None: # Build zero matrix if shape is None: raise Exception('Shape must be given when building zero matrix.') self.data = np.array([], dtype=complex) self.indices = np.array([], dtype=np.int32) - self.indptr = np.zeros(shape[0]+1, dtype=np.int32) + self.indptr = np.zeros(shape[0] + 1, dtype=np.int32) self._shape = tuple(int(s) for s in shape) else: @@ -83,7 +84,7 @@ def __init__(self, args=None, shape=None, dtype=None, copy=False): self.indices = np.array(args[1], dtype=np.int32, copy=copy) self.indptr = np.array(args[2], dtype=np.int32, copy=copy) if shape is None: - self._shape = tuple([len(self.indptr)-1]*2) + self._shape = tuple([len(self.indptr) - 1] * 2) else: self._shape = tuple(int(s) for s in shape) self.dtype = complex @@ -130,12 +131,13 @@ def _binopt(self, other, op): # too much waste, trim arrays indices = indices.copy() data = data.copy() - if isinstance(other, fast_csr_matrix) and (not op in bool_ops): + if isinstance(other, fast_csr_matrix) and (op not in bool_ops): A = fast_csr_matrix((data, indices, indptr), dtype=data.dtype, shape=self.shape) else: A = csr_matrix((data, indices, indptr), dtype=data.dtype, shape=self.shape) return A + # pylint: disable=too-many-return-statements def multiply(self, other): """Point-wise multiplication by another matrix, vector, or scalar. @@ -210,7 +212,7 @@ def _mul_sparse_matrix(self, other): other = csr_matrix(other) # convert to this format idx_dtype = get_index_dtype((self.indptr, self.indices, other.indptr, other.indices), - maxval=M*N) + maxval=M * N) indptr = np.empty(major_axis + 1, dtype=idx_dtype) fn = getattr(_sparsetools, self.format + '_matmat_pass1') @@ -249,6 +251,7 @@ def _scalar_binopt(self, other, op): res.eliminate_zeros() return res + # pylint: disable=too-many-return-statements def __eq__(self, other): # Scalar other. if isscalarlike(other): @@ -270,7 +273,7 @@ def __eq__(self, other): elif isspmatrix(other): warn("Comparing sparse matrices using == is inefficient, try using" " != instead.", SparseEfficiencyWarning) - #TODO sparse broadcasting + # TODO sparse broadcasting if self.shape != other.shape: return False elif self.format != other.format: @@ -281,6 +284,7 @@ def __eq__(self, other): else: return False + # pylint: disable=too-many-return-statements def __ne__(self, other): # Scalar other. if isscalarlike(other): @@ -302,7 +306,7 @@ def __ne__(self, other): return self.todense() != other # Sparse other. elif isspmatrix(other): - #TODO sparse broadcasting + # TODO sparse broadcasting if self.shape != other.shape: return True elif self.format != other.format: @@ -316,7 +320,8 @@ def _inequality(self, other, op, op_name, bad_scalar_msg): if isscalarlike(other): if other == 0 and op_name in ('_le_', '_ge_'): raise NotImplementedError(" >= and <= don't work with 0.") - elif op(0, other): + + if op(0, other): warn(bad_scalar_msg, SparseEfficiencyWarning) other_arr = np.empty(self.shape, dtype=np.result_type(other)) other_arr.fill(other) @@ -329,10 +334,10 @@ def _inequality(self, other, op, op_name, bad_scalar_msg): return op(self.todense(), other) # Sparse other. elif isspmatrix(other): - #TODO sparse broadcasting + # TODO sparse broadcasting if self.shape != other.shape: raise ValueError("inconsistent shapes") - elif self.format != other.format: + if self.format != other.format: other = other.asformat(self.format) if op_name not in ('_ge_', '_le_'): return self._binopt(other, op_name) @@ -359,6 +364,7 @@ def _with_data(self, data, copy=True): else: return fast_csr_matrix((data, self.indices, self.indptr), shape=self.shape, dtype=data.dtype) + # pylint: disable=arguments-differ def transpose(self): """ @@ -413,23 +419,22 @@ def fast_identity(N): """ data = np.ones(N, dtype=complex) ind = np.arange(N, dtype=np.int32) - ptr = np.arange(N+1, dtype=np.int32) + ptr = np.arange(N + 1, dtype=np.int32) ptr[-1] = N return fast_csr_matrix((data, ind, ptr), shape=(N, N)) -#Convenience functions -#-------------------- +# Convenience functions +# -------------------- def _all_true(shape): A = csr_matrix((np.ones(np.prod(shape), dtype=np.bool_), np.tile(np.arange(shape[1], dtype=np.int32), shape[0]), - np.arange(0, np.prod(shape)+1, shape[1], dtype=np.int32)), + np.arange(0, np.prod(shape) + 1, shape[1], dtype=np.int32)), shape=shape) return A - -#Need to do some trailing imports here -#------------------------------------- +# Need to do some trailing imports here +# ------------------------------------- # pylint: disable=no-name-in-module, wrong-import-position from .cy.spmath import (zcsr_transpose, zcsr_adjoint, zcsr_mult) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/operators.py b/qiskit/providers/aer/openpulse/qutip_lite/operators.py index b26e643220..4812b050c1 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/operators.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/operators.py @@ -57,9 +57,8 @@ import scipy.sparse as sp from .fastsparse import fast_csr_matrix, fast_identity -# + # Spin operators -# def jmat(j, *args): """Higher-order spin operators: @@ -106,8 +105,8 @@ def _jplus(j): data = (np.sqrt(j * (j + 1.0) - (m + 1.0) * m))[1:] N = m.shape[0] ind = np.arange(1, N, dtype=np.int32) - ptr = np.array(list(range(N-1))+[N-1]*2, dtype=np.int32) - ptr[-1] = N-1 + ptr = np.array(list(range(N - 1)) + [N - 1] * 2, dtype=np.int32) + ptr[-1] = N - 1 return fast_csr_matrix((data, ind, ptr), shape=(N, N)) @@ -115,19 +114,19 @@ def _jz(j): """ Internal functions for generating the data representing the J-z operator. """ - N = int(2*j+1) - data = np.array([j-k for k in range(N) if (j-k) != 0], dtype=complex) + N = int(2 * j + 1) + data = np.array([j - k for k in range(N) if (j - k) != 0], dtype=complex) # Even shaped matrix if N % 2 == 0: ind = np.arange(N, dtype=np.int32) - ptr = np.arange(N+1, dtype=np.int32) + ptr = np.arange(N + 1, dtype=np.int32) ptr[-1] = N # Odd shaped matrix else: j = int(j) - ind = np.array(list(range(j))+list(range(j+1, N)), dtype=np.int32) - ptr = np.array(list(range(j+1))+list(range(j, N)), dtype=np.int32) - ptr[-1] = N-1 + ind = np.array(list(range(j)) + list(range(j + 1, N)), dtype=np.int32) + ptr = np.array(list(range(j + 1)) + list(range(j, N)), dtype=np.int32) + ptr[-1] = N - 1 return fast_csr_matrix((data, ind, ptr), shape=(N, N)) @@ -321,10 +320,10 @@ def destroy(N, offset=0): """ if not isinstance(N, (int, np.integer)): # raise error if N not integer raise ValueError("Hilbert space dimension must be integer value") - data = np.sqrt(np.arange(offset+1, N+offset, dtype=complex)) + data = np.sqrt(np.arange(offset + 1, N + offset, dtype=complex)) ind = np.arange(1, N, dtype=np.int32) - ptr = np.arange(N+1, dtype=np.int32) - ptr[-1] = N-1 + ptr = np.arange(N + 1, dtype=np.int32) + ptr[-1] = N - 1 return Qobj(fast_csr_matrix((data, ind, ptr), shape=(N, N)), isherm=False) @@ -446,12 +445,12 @@ def num(N, offset=0): if offset == 0: data = np.arange(1, N, dtype=complex) ind = np.arange(1, N, dtype=np.int32) - ptr = np.array([0]+list(range(0, N)), dtype=np.int32) - ptr[-1] = N-1 + ptr = np.array([0] + list(range(0, N)), dtype=np.int32) + ptr[-1] = N - 1 else: data = np.arange(offset, offset + N, dtype=complex) ind = np.arange(N, dtype=np.int32) - ptr = np.arange(N+1, dtype=np.int32) + ptr = np.arange(N + 1, dtype=np.int32) ptr[-1] = N return Qobj(fast_csr_matrix((data, ind, ptr), @@ -582,14 +581,13 @@ def charge(Nmax, Nmin=None, frac=1): """ if Nmin is None: Nmin = -Nmax - diag = np.arange(Nmin, Nmax+1, dtype=float) + diag = np.arange(Nmin, Nmax + 1, dtype=float) if frac != 1: diag *= frac C = sp.diags(diag, 0, format='csr', dtype=complex) return Qobj(C, isherm=True) - def tunneling(N, m=1): """ Tunneling operator with elements of the form @@ -603,9 +601,11 @@ def tunneling(N, m=1): Returns: Qobj: Tunneling operator. """ - diags = [np.ones(N-m, dtype=int), np.ones(N-m, dtype=int)] + + diags = [np.ones(N - m, dtype=int), np.ones(N - m, dtype=int)] T = sp.diags(diags, [m, -m], format='csr', dtype=complex) return Qobj(T, isherm=True) + # pylint: disable=wrong-import-position from .qobj import Qobj diff --git a/qiskit/providers/aer/openpulse/qutip_lite/qobj.py b/qiskit/providers/aer/openpulse/qutip_lite/qobj.py index 57c05cf702..b67f953a58 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/qobj.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/qobj.py @@ -64,9 +64,9 @@ ceil, copysign, cos, cosh, degrees, e, exp, expm1, fabs, floor, fmod, frexp, hypot, isinf, isnan, ldexp, log, log10, log1p, modf, pi, radians, sin, sinh, sqrt, tan, tanh, trunc) -from qiskit.providers.aer.version import __version__ import scipy.sparse as sp import scipy.linalg as la +from qiskit.providers.aer.version import __version__ from .settings import (auto_tidyup, auto_tidyup_dims, atol, auto_tidyup_atol) from .fastsparse import fast_csr_matrix, fast_identity from .sparse import (sp_eigs, sp_expm, sp_fro_norm, sp_max_norm, @@ -78,7 +78,7 @@ from .cy.sparse_utils import cy_tidyup -class Qobj(object): +class Qobj(): """A class for representing quantum objects, such as quantum operators and states. @@ -184,6 +184,7 @@ class Qobj(object): """ __array_priority__ = 100 # sets Qobj priority above numpy arrays + # pylint: disable=dangerous-default-value, redefined-builtin def __init__(self, inpt=None, dims=[[], []], shape=[], type=None, isherm=None, copy=True, @@ -205,6 +206,7 @@ def __init__(self, inpt=None, dims=[[], []], shape=[], Raises: Exception: Something bad happened. """ + self._isherm = isherm self._type = type self.superrep = superrep @@ -258,7 +260,7 @@ def __init__(self, inpt=None, dims=[[], []], shape=[], self._data = fast_csr_matrix(shape=(N, M)) - elif isinstance(inpt, list) or isinstance(inpt, tuple): + elif isinstance(inpt, (list, tuple)): # case where input is a list data = np.array(inpt) if len(data.shape) == 1: @@ -281,7 +283,7 @@ def __init__(self, inpt=None, dims=[[], []], shape=[], do_copy = copy if not isinstance(inpt, fast_csr_matrix): _tmp = sp.csr_matrix(inpt, dtype=complex, copy=do_copy) - _tmp.sort_indices() #Make sure indices are sorted. + _tmp.sort_indices() # Make sure indices are sorted. do_copy = 0 else: _tmp = inpt @@ -320,10 +322,9 @@ def __init__(self, inpt=None, dims=[[], []], shape=[], # check if root of shape is int if (sub_shape % 1) != 0: raise Exception('Invalid shape for a super operator.') - else: - sub_shape = int(sub_shape) - self.dims = [[[sub_shape], [sub_shape]]]*2 + sub_shape = int(sub_shape) + self.dims = [[[sub_shape], [sub_shape]]] * 2 if superrep: self.superrep = superrep @@ -342,14 +343,14 @@ def get_data(self): """Gets underlying data.""" return self._data - #Here we perfrom a check of the csr matrix type during setting of Q.data + # Here we perfrom a check of the csr matrix type during setting of Q.data def set_data(self, data): """Data setter """ if not isinstance(data, fast_csr_matrix): raise TypeError('Qobj data must be in fast_csr format.') - else: - self._data = data + + self._data = data data = property(get_data, set_data) def __add__(self, other): @@ -359,9 +360,9 @@ def __add__(self, other): self._isunitary = None if not isinstance(other, Qobj): - if isinstance(other, (int, float, complex, np.integer, np.floating, - np.complexfloating, np.ndarray, list, tuple)) \ - or sp.issparse(other): + if isinstance(other, (int, float, complex, np.integer, + np.floating, np.complexfloating, np.ndarray, + list, tuple)) or sp.issparse(other): other = Qobj(other) else: return NotImplemented @@ -474,6 +475,7 @@ def __rsub__(self, other): """ return (-self) + other + # pylint: disable=too-many-return-statements def __mul__(self, other): """ MULTIPLICATION with Qobj on LEFT [ ex. Qobj*4 ] @@ -488,9 +490,9 @@ def __mul__(self, other): out.dims = dims if auto_tidyup: out.tidyup() - if (auto_tidyup_dims - and not isinstance(dims[0][0], list) - and not isinstance(dims[1][0], list)): + if (auto_tidyup_dims and not + isinstance(dims[0][0], list) and not + isinstance(dims[1][0], list)): # If neither left or right is a superoperator, # we should implicitly partial trace over # matching dimensions of 1. @@ -498,8 +500,8 @@ def __mul__(self, other): # to have uneven length (non-square Qobjs). # We use None as padding so that it doesn't match anything, # and will never cause a partial trace on the other side. - mask = [l == r == 1 for l, r in zip_longest(dims[0], dims[1], - fillvalue=None)] + mask = [ll == r == 1 for ll, r in + zip_longest(dims[0], dims[1], fillvalue=None)] # To ensure that there are still any dimensions left, we # use max() to add a dimensions list of [1] if all matching dims # are traced out of that side. @@ -547,7 +549,6 @@ def __mul__(self, other): else: return self.data * other - elif isinstance(other, list): # if other is a list, do element-wise multiplication return np.array([self * item for item in other], @@ -664,12 +665,9 @@ def __eq__(self, other): """ EQUALITY operator. """ - if (isinstance(other, Qobj) and - self.dims == other.dims and - not np.any(np.abs((self.data - other.data).data) > atol)): - return True - else: - return False + return bool(isinstance(other, Qobj) and + self.dims == other.dims and + not np.any(np.abs((self.data - other.data).data) > atol)) def __ne__(self, other): """ @@ -694,7 +692,7 @@ def __pow__(self, n, m=None): # calculates powers of Qobj out.superrep = self.superrep return out.tidyup() if auto_tidyup else out - except: + except ValueError: raise ValueError('Invalid choice of exponent.') def __abs__(self): @@ -752,11 +750,13 @@ def __call__(self, other): if not isinstance(other, Qobj): raise TypeError("Only defined for quantum objects.") - elif self.type == "oper": + if self.type == "oper": if other.type == "ket": return self * other else: raise TypeError("Can only act oper on ket.") + else: + return None def __getstate__(self): # defines what happens when Qobj object gets pickled @@ -850,7 +850,7 @@ def _format_element(_, n, d): s += _format_element(m, n, self.data[m, n]) s += r'\\' - elif M > 10 and N <= 10: + elif N <= 10 < M: # truncated vertically elongated matrix output for m in range(5): for n in range(N): @@ -866,7 +866,7 @@ def _format_element(_, n, d): s += _format_element(m, n, self.data[m, n]) s += r'\\' - elif M <= 10 and N > 10: + elif M <= 10 < N: # truncated horizontally elongated matrix output for m in range(M): for n in range(5): @@ -934,7 +934,7 @@ def norm(self, norm=None, sparse=False, tol=0, maxiter=100000): """ if self.type in ['oper', 'super']: if norm is None or norm == 'tr': - _op = self*self.dag() + _op = self * self.dag() vals = sp_eigs(_op.data, _op.isherm, vecs=False, sparse=sparse, tol=tol, maxiter=maxiter) return np.sum(np.sqrt(np.abs(vals))) @@ -1109,7 +1109,6 @@ def sqrtm(self, sparse=False, tol=0, maxiter=100000): else: raise TypeError('Invalid operand for matrix square root') - def cosm(self): """Cosine of a quantum operator. @@ -1135,7 +1134,6 @@ def cosm(self): else: raise TypeError('Invalid operand for matrix square root') - def sinm(self): """Sine of a quantum operator. @@ -1158,8 +1156,8 @@ def sinm(self): """ if self.dims[0][0] == self.dims[1][0]: return -0.5j * ((1j * self).expm() - (-1j * self).expm()) - else: - raise TypeError('Invalid operand for matrix square root') + + raise TypeError('Invalid operand for matrix square root') def unit(self, inplace=False, norm=None, sparse=False, @@ -1171,9 +1169,11 @@ def unit(self, inplace=False, Args: inplace (bool): Do an in-place normalization norm (str): Requested norm for states / operators. - sparse (bool): Use sparse eigensolver for trace norm. Does not affect other norms. + sparse (bool): Use sparse eigensolver for trace norm. + Does not affect other norms. tol (float): Tolerance used by sparse eigensolver. - maxiter (int): Number of maximum iterations performed by sparse eigensolver. + maxiter (int): Number of maximum iterations performed by + sparse eigensolver. Returns: qobj.Qobj: Normalized quantum object if not in-place, else None. @@ -1186,6 +1186,8 @@ def unit(self, inplace=False, tol=tol, maxiter=maxiter) self.data /= nrm + + return None elif not inplace: out = self / self.norm(norm=norm, sparse=sparse, tol=tol, maxiter=maxiter) @@ -1212,8 +1214,8 @@ def tidyup(self, atol=auto_tidyup_atol): """ if self.data.nnz: - #This does the tidyup and returns True if - #The sparse data needs to be shortened + # This does the tidyup and returns True if + # The sparse data needs to be shortened if cy_tidyup(self.data.data, atol, self.data.nnz): self.data.eliminate_zeros() return self @@ -1259,7 +1261,6 @@ def transform(self, inpt, inverse=False, sparse=True): else: raise TypeError('Invalid operand for basis transformation') - # transform data if inverse: if self.isket: @@ -1291,7 +1292,6 @@ def transform(self, inpt, inverse=False, sparse=True): else: return out - def matrix_element(self, bra, ket): """Calculates a matrix element. @@ -1313,14 +1313,14 @@ def matrix_element(self, bra, ket): if not self.isoper: raise TypeError("Can only get matrix elements for an operator.") - else: - if bra.isbra and ket.isket: - return zcsr_mat_elem(self.data, bra.data, ket.data, 1) + if bra.isbra and ket.isket: + return zcsr_mat_elem(self.data, bra.data, ket.data, 1) - elif bra.isket and ket.isket: - return zcsr_mat_elem(self.data, bra.data, ket.data, 0) - else: - raise TypeError("Can only calculate matrix elements for bra and ket vectors.") + elif bra.isket and ket.isket: + return zcsr_mat_elem(self.data, bra.data, ket.data, 0) + else: + raise TypeError("Can only calculate matrix elements " + + "for bra and ket vectors.") def overlap(self, other): """Overlap between two state vectors or two operators. @@ -1355,39 +1355,44 @@ def overlap(self, other): if isinstance(other, Qobj): + returnval = 0 + if self.isbra: if other.isket: - return zcsr_inner(self.data, other.data, 1) + returnval = zcsr_inner(self.data, other.data, 1) elif other.isbra: - #Since we deal mainly with ket vectors, the bra-bra combo - #is not common, and not optimized. - return zcsr_inner(self.data, other.dag().data, 1) + # Since we deal mainly with ket vectors, the bra-bra combo + # is not common, and not optimized. + returnval = zcsr_inner(self.data, other.dag().data, 1) elif other.isoper: - return (states.ket2dm(self).dag() * other).tr() + returnval = (states.ket2dm(self).dag() * other).tr() else: - raise TypeError("Can only calculate overlap for state vector Qobjs") + raise TypeError("Can only calculate overlap for " + + "state vector Qobjs") elif self.isket: if other.isbra: - return zcsr_inner(other.data, self.data, 1) + returnval = zcsr_inner(other.data, self.data, 1) elif other.isket: - return zcsr_inner(self.data, other.data, 0) + returnval = zcsr_inner(self.data, other.data, 0) elif other.isoper: - return (states.ket2dm(self).dag() * other).tr() + returnval = (states.ket2dm(self).dag() * other).tr() else: - raise TypeError("Can only calculate overlap for state vector Qobjs") + raise TypeError("Can only calculate overlap for " + + "state vector Qobjs") elif self.isoper: if other.isket or other.isbra: - return (self.dag() * states.ket2dm(other)).tr() + returnval = (self.dag() * states.ket2dm(other)).tr() elif other.isoper: - return (self.dag() * other).tr() + returnval = (self.dag() * other).tr() else: - raise TypeError("Can only calculate overlap for state vector Qobjs") - - - raise TypeError("Can only calculate overlap for state vector Qobjs") + raise TypeError("Can only calculate overlap " + + "for state vector Qobjs") + else: + raise TypeError("Can only calculate overlap for state vector Qobjs") + return returnval def eigenstates(self, sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000): @@ -1438,11 +1443,9 @@ def eigenstates(self, sparse=False, sort='low', norms = np.array([ket.norm() for ket in ekets]) return evals, ekets / norms - def eigenenergies(self, sparse=False, sort='low', eigvals=0, tol=0, maxiter=100000): """Eigenenergies of a quantum object. - Eigenenergies (eigenvalues) are defined for operators or superoperators only. @@ -1504,7 +1507,7 @@ def groundstate(self, sparse=False, tol=0, maxiter=100000, safe=True): if safe: if tol == 0: tol = 1e-15 - if (grndval[1]-grndval[0]) <= 10*tol: + if (grndval[1] - grndval[0]) <= 10 * tol: print("WARNING: Ground state may be degenerate. " "Use Q.eigenstates()") new_dims = [self.dims[0], [1] * len(self.dims[0])] @@ -1550,14 +1553,10 @@ def check_isunitary(self): """ if self.isoper: eye_data = fast_identity(self.shape[0]) - return not (np.any(np.abs((self.data*self.dag().data - - eye_data).data) - > atol) - or - np.any(np.abs((self.dag().data*self.data - - eye_data).data) > - atol) - ) + return not (np.any(np.abs((self.data * self.dag().data - + eye_data).data) > atol) or + np.any(np.abs((self.dag().data * self.data - + eye_data).data) > atol)) else: return False diff --git a/qiskit/providers/aer/openpulse/qutip_lite/sparse.py b/qiskit/providers/aer/openpulse/qutip_lite/sparse.py index 4c44e6671d..22c1971380 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/sparse.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/sparse.py @@ -71,6 +71,7 @@ _dznrm2 = get_blas_funcs("znrm2") + def sp_fro_norm(data): """ Frobius norm for sparse matrix @@ -116,6 +117,7 @@ def sp_one_norm(A): A.indptr, A.shape[0], A.shape[1]) + # pylint: disable=redefined-builtin def sp_reshape(A, shape, format='csr'): """ @@ -448,8 +450,8 @@ def sp_permute(A, rperm=(), cperm=(), safe=True): nrows, ncols, rperm, cperm, flag) if kind == 'csr': return fast_csr_matrix((data, ind, ptr), shape=shp) - elif kind == 'csc': - return sp.csc_matrix((data, ind, ptr), shape=shp, dtype=data.dtype) + + return sp.csc_matrix((data, ind, ptr), shape=shp, dtype=data.dtype) def sp_reverse_permute(A, rperm=(), cperm=(), safe=True): @@ -503,8 +505,8 @@ def sp_reverse_permute(A, rperm=(), cperm=(), safe=True): if kind == 'csr': return fast_csr_matrix((data, ind, ptr), shape=shp) - elif kind == 'csc': - return sp.csc_matrix((data, ind, ptr), shape=shp, dtype=data.dtype) + + return sp.csc_matrix((data, ind, ptr), shape=shp, dtype=data.dtype) def sp_bandwidth(A): @@ -567,7 +569,7 @@ def sp_profile(A): else: raise TypeError('Input sparse matrix must be in CSR or CSC format.') - return up+lp, lp, up + return up + lp, lp, up def sp_isdiag(A): diff --git a/qiskit/providers/aer/openpulse/qutip_lite/states.py b/qiskit/providers/aer/openpulse/qutip_lite/states.py index bce56a0272..3bfd4f4a2d 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/states.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/states.py @@ -89,7 +89,8 @@ def basis(N, n=0, offset=0): data = np.array([1], dtype=complex) ind = np.array([0], dtype=np.int32) - ptr = np.array([0]*((n - offset)+1)+[1]*(N-(n-offset)), dtype=np.int32) + ptr = np.array([0] * ((n - offset) + 1) + [1] * (N - (n - offset)), + dtype=np.int32) return Qobj(fast_csr_matrix((data, ind, ptr), shape=(N, 1)), isherm=False) @@ -136,15 +137,15 @@ def coherent(N, alpha, offset=0, method='operator'): elif method == "analytic" or offset > 0: - sqrtn = np.sqrt(np.arange(offset, offset+N, dtype=complex)) - sqrtn[0] = 1 # Get rid of divide by zero warning - data = alpha/sqrtn + sqrtn = np.sqrt(np.arange(offset, offset + N, dtype=complex)) + sqrtn[0] = 1 # Get rid of divide by zero warning + data = alpha / sqrtn if offset == 0: data[0] = np.exp(-abs(alpha)**2 / 2.0) else: - s = np.prod(np.sqrt(np.arange(1, offset + 1))) # sqrt factorial + s = np.prod(np.sqrt(np.arange(1, offset + 1))) # sqrt factorial data[0] = np.exp(-abs(alpha)**2 / 2.0) * alpha**(offset) / s - np.cumprod(data, out=sqrtn) # Reuse sqrtn array + np.cumprod(data, out=sqrtn) # Reuse sqrtn array return Qobj(sqrtn) else: @@ -252,7 +253,7 @@ def thermal_dm(N, n, method='operator'): i = arange(N) if method == 'operator': beta = np.log(1.0 / n + 1.0) - diags = np.exp(-beta * i) + diags = np.exp(-1 * beta * i) diags = diags / np.sum(diags) # populates diagonal terms using truncated operator expression rm = sp.spdiags(diags, 0, N, N, format='csr') @@ -283,7 +284,8 @@ def maximally_mixed_dm(N): if (not isinstance(N, (int, np.int64))) or N <= 0: raise ValueError("N must be integer N > 0") - dm = sp.spdiags(np.ones(N, dtype=complex)/float(N), 0, N, N, format='csr') + dm = sp.spdiags(np.ones(N, dtype=complex) / float(N), + 0, N, N, format='csr') return Qobj(dm, isherm=True) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py b/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py index 8d701db624..aaf148f624 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py @@ -56,6 +56,7 @@ from .sparse import sp_reshape from .cy.spmath import zcsr_kron # pylint: disable=no-name-in-module + # pylint: disable=dangerous-default-value def liouvillian(H, c_ops=[], data_only=False, chi=None): """Assembles the Liouvillian superoperator from a Hamiltonian @@ -134,8 +135,8 @@ def liouvillian(H, c_ops=[], data_only=False, chi=None): cd = c_.data.H c = c_.data if chi: - data = data + np.exp(1j * chi[idx]) * \ - zcsr_kron(c.conj(), c) + data = data + (np.exp(1j * chi[idx]) * + zcsr_kron(c.conj(), c)) else: data = data + zcsr_kron(c.conj(), c) cdc = cd * c diff --git a/qiskit/providers/aer/openpulse/solver/codegen.py b/qiskit/providers/aer/openpulse/solver/codegen.py index c6dbfe3f85..a044066071 100644 --- a/qiskit/providers/aer/openpulse/solver/codegen.py +++ b/qiskit/providers/aer/openpulse/solver/codegen.py @@ -27,10 +27,10 @@ _cython_path = os.path.abspath(cy.__file__).replace('__init__.py', '') _cython_path = _cython_path.replace("\\", "/") -_include_string = "'"+_cython_path+"complex_math.pxi'" +_include_string = "'" + _cython_path + "complex_math.pxi'" -class OPCodegen(object): +class OPCodegen(): """ Class for generating cython code files at runtime. """ @@ -110,11 +110,11 @@ def ODE_func_header(self): "int[::1] idx%d, " % k + "int[::1] ptr%d" % k) - #Add global vaiables + # Add global vaiables input_vars += (",\n " + "complex[::1] pulse_array") input_vars += (",\n " + "unsigned int[::1] pulse_indices") - #Add per experiment variables + # Add per experiment variables for key in self.op_system.channels.keys(): input_vars += (",\n " + "double[::1] %s_pulses" % key) input_vars += (",\n " + "double[::1] %s_fc" % key) @@ -133,7 +133,6 @@ def ODE_func_header(self): func_end = "):" return [func_name + input_vars + func_end] - def channels(self): """Write out the channels """ @@ -141,26 +140,25 @@ def channels(self): channel_lines.append("# Compute complex channel values at time `t`") for chan, idx in self.op_system.channels.items(): - chan_str = "%s = chan_value(t, %s, %s_freq, " %(chan, idx, chan) + \ + chan_str = "%s = chan_value(t, %s, %s_freq, " % (chan, idx, chan) + \ "%s_pulses, pulse_array, pulse_indices, " % chan + \ "%s_fc, register)" % (chan) channel_lines.append(chan_str) channel_lines.append('') return channel_lines - def func_vars(self): """Writes the variables and spmv parts""" func_vars = [] sp1 = " " - sp2 = sp1+sp1 + sp2 = sp1 + sp1 func_vars.append("# Eval the time-dependent terms and do SPMV.") - for idx in range(len(self.op_system.system)+1): + for idx in range(len(self.op_system.system) + 1): if (idx == len(self.op_system.system) and (len(self.op_system.system) < self.num_ham_terms)): - #this is the noise term + # this is the noise term term = [1.0, 1.0] elif idx < len(self.op_system.system): term = self.op_system.system[idx] @@ -176,21 +174,21 @@ def func_vars(self): func_vars.append(sp1 + "for row in range(num_rows):") func_vars.append(sp2 + "dot = 0;") - func_vars.append(sp2 + "row_start = ptr%d[row];"%idx) - func_vars.append(sp2 + "row_end = ptr%d[row+1];"%idx) + func_vars.append(sp2 + "row_start = ptr%d[row];" % idx) + func_vars.append(sp2 + "row_end = ptr%d[row+1];" % idx) func_vars.append(sp2 + "for jj in range(row_start,row_end):") func_vars.append(sp1 + sp2 + - "osc_term = exp(1j*(energ[row]-energ[idx%d[jj]])*t)"%idx) - func_vars.append(sp1 + sp2 + "if rowPyDataMem_NEW_ZEROED(num_rows,sizeof(complex))' - ] + ] func_vars.append("") for val in op_system.channels: func_vars.append("cdef double complex %s" % val) - for kk in range(len(op_system.system)+1): + for kk in range(len(op_system.system) + 1): func_vars.append("cdef double complex td%s" % kk) return func_vars + def cython_preamble(): """ Returns list of code segments for Cython preamble. @@ -268,7 +268,7 @@ def cython_preamble(): from qiskit.providers.aer.openpulse.cy.channel_value cimport chan_value -include """+_include_string+""" +include """ + _include_string + """ """] return preamble diff --git a/qiskit/providers/aer/openpulse/solver/data_config.py b/qiskit/providers/aer/openpulse/solver/data_config.py index 01deec2ae3..7be174dd64 100644 --- a/qiskit/providers/aer/openpulse/solver/data_config.py +++ b/qiskit/providers/aer/openpulse/solver/data_config.py @@ -18,6 +18,7 @@ import numpy as np pi = np.pi + def op_data_config(op_system): """ Preps the data for the opsolver. @@ -67,14 +68,15 @@ def op_data_config(op_system): H = H + [H_noise] # construct data sets - op_system.global_data['h_ops_data'] = [-1.0j* hpart.data.data for hpart in H] + op_system.global_data['h_ops_data'] = [-1.0j * hpart.data.data + for hpart in H] op_system.global_data['h_ops_ind'] = [hpart.data.indices for hpart in H] op_system.global_data['h_ops_ptr'] = [hpart.data.indptr for hpart in H] # setup ode args string ode_var_str = "" - #diagonal elements + # diagonal elements ode_var_str += "global_data['h_diag_elems'], " # Hamiltonian data @@ -103,13 +105,13 @@ def op_data_config(op_system): if chan != final_chan or var_list: ode_var_str += ', ' - #now do the variables + # now do the variables for idx, var in enumerate(var_list): ode_var_str += "global_data['vars'][%s]" % idx if var != final_var or freq_list: ode_var_str += ', ' - #now do the freq + # now do the freq for idx, freq in enumerate(freq_list): ode_var_str += "global_data['freqs'][%s]" % idx if freq != final_freq: @@ -119,6 +121,6 @@ def op_data_config(op_system): ode_var_str += ", register" op_system.global_data['string'] = ode_var_str - #Convert inital state to flat array in global_data + # Convert inital state to flat array in global_data op_system.global_data['initial_state'] = \ op_system.initial_state.full().ravel() diff --git a/qiskit/providers/aer/openpulse/solver/monte_carlo.py b/qiskit/providers/aer/openpulse/solver/monte_carlo.py index 34a9e27bdc..679fef050b 100644 --- a/qiskit/providers/aer/openpulse/solver/monte_carlo.py +++ b/qiskit/providers/aer/openpulse/solver/monte_carlo.py @@ -32,6 +32,7 @@ dznrm2 = get_blas_funcs("znrm2", dtype=np.float64) + def monte_carlo(seed, exp, global_data, ode_options): """ Monte Carlo algorithm returning state-vector or expectation values @@ -77,7 +78,7 @@ def monte_carlo(seed, exp, global_data, ode_options): first_step=ode_options.first_step, min_step=ode_options.min_step, max_step=ode_options.max_step - ) + ) # Forces complex ODE solving if not any(ODE._y): ODE.t = 0.0 diff --git a/qiskit/providers/aer/openpulse/solver/opsolve.py b/qiskit/providers/aer/openpulse/solver/opsolve.py index afe410ffd5..6f2526040f 100644 --- a/qiskit/providers/aer/openpulse/solver/opsolve.py +++ b/qiskit/providers/aer/openpulse/solver/opsolve.py @@ -37,6 +37,7 @@ # _cy_rhs_func = None + def opsolve(op_system): """Opsolver """ @@ -50,7 +51,7 @@ def opsolve(op_system): # build Hamiltonian data structures op_data_config(op_system) - # compile Cython RHS + # compile Cython RHS _op_generate_rhs(op_system) # Load cython function _op_func_load(op_system) @@ -61,10 +62,11 @@ def opsolve(op_system): # Results are stored in ophandler.result return out + # ----------------------------------------------------------------------------- # MONTE CARLO CLASS # ----------------------------------------------------------------------------- -class OP_mcwf(object): +class OP_mcwf(): """ Private class for solving Monte Carlo evolution """ @@ -91,16 +93,15 @@ def __init__(self, op_system): prng = np.random.RandomState(op_system.global_data['seed']) else: prng = np.random.RandomState( - np.random.randint(np.iinfo(np.int32).max-1)) + np.random.randint(np.iinfo(np.int32).max - 1)) for exp in op_system.experiments: - exp['seed'] = prng.randint(np.iinfo(np.int32).max-1) + exp['seed'] = prng.randint(np.iinfo(np.int32).max - 1) def run(self): """Runs the solver. """ map_kwargs = {'num_processes': self.op_system.ode_options.num_cpus} - # exp_results from the solvers return the values of the measurement # operators @@ -118,13 +119,12 @@ def run(self): self.op_system.experiments, task_args=(self.op_system.global_data, self.op_system.ode_options - ), + ), **map_kwargs - ) + ) end = time.time() - exp_times = (np.ones(len(self.op_system.experiments))* - (end-start)/len(self.op_system.experiments)) - + exp_times = (np.ones(len(self.op_system.experiments)) * + (end - start) / len(self.op_system.experiments)) # need to simulate each trajectory, so shots*len(experiments) times # Do a for-loop over experiments, and do shots in parallel_map @@ -134,15 +134,16 @@ def run(self): for exp in self.op_system.experiments: start = time.time() rng = np.random.RandomState(exp['seed']) - seeds = rng.randint(np.iinfo(np.int32).max-1, + seeds = rng.randint(np.iinfo(np.int32).max - 1, size=self.op_system.global_data['shots']) exp_res = parallel_map(monte_carlo, seeds, - task_args=(exp, self.op_system.global_data, + task_args=(exp, + self.op_system.global_data, self.op_system.ode_options - ), + ), **map_kwargs - ) + ) # exp_results is a list for each shot # so transform back to an array of shots @@ -150,17 +151,14 @@ def run(self): for exp_shot in exp_res: exp_res2.append(exp_shot[0].tolist()) - end = time.time() - exp_times.append(end-start) + exp_times.append(end - start) exp_results.append(np.array(exp_res2)) - - #format the data into the proper output + # format the data into the proper output all_results = [] for idx_exp, exp in enumerate(self.op_system.experiments): - m_lev = self.op_system.global_data['meas_level'] m_ret = self.op_system.global_data['meas_return'] @@ -184,7 +182,8 @@ def run(self): # integer # e.g. [1,0] -> 2 int_mem = memory.dot(np.power(2.0, - np.arange(memory.shape[1]-1, -1, -1))).astype(int) + np.arange(memory.shape[1] - 1, + -1, -1))).astype(int) # if the memory flag is set return each shot if self.op_system.global_data['memory']: @@ -220,7 +219,6 @@ def run(self): if m_ret == 'avg': results['data']['memory'] = results['data']['memory'][0] - all_results.append(results) _cython_build_cleanup(self.op_system.global_data['rhs_file_name']) @@ -232,7 +230,7 @@ def _proj_measurement(pid, ophandler, tt, state, memory, register=None): """ Projection measurement of quantum state """ - prng = np.random.RandomState(np.random.randint(np.iinfo(np.int32).max-1)) + prng = np.random.RandomState(np.random.randint(np.iinfo(np.int32).max - 1)) qubits = [] results = [] @@ -269,7 +267,8 @@ def _proj_measurement(pid, ophandler, tt, state, memory, register=None): # projection if any(qubits): - psi_proj = apply_projector(qubits, results, ophandler.h_qub, ophandler.h_osc, state) + psi_proj = apply_projector(qubits, results, ophandler.h_qub, + ophandler.h_osc, state) else: psi_proj = state diff --git a/qiskit/providers/aer/openpulse/solver/options.py b/qiskit/providers/aer/openpulse/solver/options.py index deae400076..4323f98eaf 100644 --- a/qiskit/providers/aer/openpulse/solver/options.py +++ b/qiskit/providers/aer/openpulse/solver/options.py @@ -14,7 +14,8 @@ """OpenPulse options""" -class OPoptions(object): + +class OPoptions(): """ Class of options for opsolver. Options can be specified either as arguments to the constructor:: @@ -103,5 +104,6 @@ def __init__(self, atol=1e-8, rtol=1e-6, method='adams', order=12, def __str__(self): return str(vars(self)) + def __repr__(self): return self.__str__() diff --git a/qiskit/providers/aer/openpulse/solver/rhs_utils.py b/qiskit/providers/aer/openpulse/solver/rhs_utils.py index 98c19a54f3..7071c914ea 100644 --- a/qiskit/providers/aer/openpulse/solver/rhs_utils.py +++ b/qiskit/providers/aer/openpulse/solver/rhs_utils.py @@ -26,11 +26,12 @@ def _op_generate_rhs(op_system): Args: op_system (OPSystem): An OpenPulse system object. """ - name = "rhs" + str(os.getpid()) + str(op_set.CGEN_NUM)+'_op' + name = "rhs" + str(os.getpid()) + str(op_set.CGEN_NUM) + '_op' op_system.global_data['rhs_file_name'] = name cgen = OPCodegen(op_system) cgen.generate(name + ".pyx") + def _op_func_load(op_system): """Loads the Cython function defined in the file `rhs_file_name.pyx` where `rhs_file_name` is diff --git a/qiskit/providers/aer/openpulse/solver/unitary.py b/qiskit/providers/aer/openpulse/solver/unitary.py index f3084e11b2..6139cb1a46 100644 --- a/qiskit/providers/aer/openpulse/solver/unitary.py +++ b/qiskit/providers/aer/openpulse/solver/unitary.py @@ -24,6 +24,7 @@ dznrm2 = get_blas_funcs("znrm2", dtype=np.float64) + def unitary_evolution(exp, global_data, ode_options): """ Calculates evolution when there is no noise, @@ -68,7 +69,7 @@ def unitary_evolution(exp, global_data, ode_options): _inst = 'ODE.set_f_params(%s)' % global_data['string'] code = compile(_inst, '', 'exec') - exec(code) # pylint disable=exec-used + exec(code) # pylint disable=exec-used if not ODE._y: ODE.t = 0.0 @@ -90,11 +91,11 @@ def unitary_evolution(exp, global_data, ode_options): # set channel and frame change indexing arrays # Do final measurement at end - psi_rot = np.exp(-1j*global_data['h_diag_elems']*ODE.t) + psi_rot = np.exp(-1j * global_data['h_diag_elems'] * ODE.t) psi *= psi_rot qubits = exp['acquire'][0][1] memory_slots = exp['acquire'][0][2] probs = occ_probabilities(qubits, psi, global_data['measurement_ops']) - rand_vals = rng.rand(memory_slots.shape[0]*shots) + rand_vals = rng.rand(memory_slots.shape[0] * shots) write_shots_memory(memory, memory_slots, probs, rand_vals) return memory From 571a5aaf2d55579ff8910604de6b1cfb128ea27f Mon Sep 17 00:00:00 2001 From: Juan Gomez Date: Fri, 20 Sep 2019 23:21:50 +0200 Subject: [PATCH 03/24] Integrate open pulse cython into the build system (#350) * Adding CMakeLists.txt to new cython files from OpenPulse * Simplified CMakeLists to build all the Cython related stuff * Removing unnecessary init python files * Adding CMake helper files * Add init files for Cython imports * Adding pulse_sim.py example, extracted from the already existing Notebook code --- CMakeLists.txt | 4 +- cmake/cython_utils.cmake | 60 ++ example/pulse_sim.py | 526 ++++++++++++++++++ qiskit/__init__.pxd | 0 qiskit/__init__.py | 13 - qiskit/providers/__init__.pxd | 0 qiskit/providers/__init__.py | 13 - .../providers/aer/backends/pulse_simulator.py | 2 +- qiskit/providers/aer/openpulse/__init__.py | 3 +- .../providers/aer/openpulse/cy/CMakeLists.txt | 32 ++ .../openpulse/qutip_lite/cy/CMakeLists.txt | 30 + .../aer/openpulse/qutip_lite/cy/pyxbuilder.py | 3 + .../qutip_lite/cy/sparse_routines.pxi | 2 +- .../aer/openpulse/qutip_lite/fastsparse.py | 2 +- .../aer/openpulse/qutip_lite/qobj.py | 6 +- .../aer/openpulse/qutip_lite/superoperator.py | 3 +- .../aer/openpulse/qutip_lite/tensor.py | 3 +- 17 files changed, 665 insertions(+), 37 deletions(-) create mode 100644 cmake/cython_utils.cmake create mode 100644 example/pulse_sim.py create mode 100644 qiskit/__init__.pxd delete mode 100644 qiskit/__init__.py create mode 100644 qiskit/providers/__init__.pxd delete mode 100644 qiskit/providers/__init__.py create mode 100644 qiskit/providers/aer/openpulse/cy/CMakeLists.txt create mode 100644 qiskit/providers/aer/openpulse/qutip_lite/cy/CMakeLists.txt diff --git a/CMakeLists.txt b/CMakeLists.txt index 5d51016251..2bd2bc8e57 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -188,6 +188,8 @@ set(AER_LIBRARIES # Cython build is only enabled if building through scikit-build. if(SKBUILD) # Terra Addon build + add_subdirectory(qiskit/providers/aer/openpulse/cy) + add_subdirectory(qiskit/providers/aer/openpulse/qutip_lite/cy) add_subdirectory(qiskit/providers/aer/backends/wrappers) else() # Standalone build add_executable(qasm_simulator ${AER_SIMULATOR_CPP_MAIN}) @@ -202,7 +204,7 @@ else() # Standalone build target_link_libraries(qasm_simulator PRIVATE ${AER_LIBRARIES}) # Linter # This will add the linter as part of the compiling build target - add_linter(qasm_simulator) + #add_linter(qasm_simulator) endif() # Tests diff --git a/cmake/cython_utils.cmake b/cmake/cython_utils.cmake new file mode 100644 index 0000000000..d176210632 --- /dev/null +++ b/cmake/cython_utils.cmake @@ -0,0 +1,60 @@ +find_package(PythonExtensions REQUIRED) +find_package(Cython REQUIRED) +find_package(PythonLibs REQUIRED) +find_package(NumPy REQUIRED) + +# Variables for input user data: +# +# CYTHON_USER_INCLUDE_DIRS: +# - For Cython modules that need to import some header file not in the paths, example: +# set(CYTHON_USER_INCLUDE_DIRS "/opt/my/include") +# CYTHON_USER_LIB_DIRS: +# - For Cython modules that need to link with external libs, example: +# set(CYTHON_USER_LIB_DIRS "/opt/my/lib") +# CYTHON_INSTALL_DIR: +# - Where to install the resulting shared libraries +# set(CYTHON_INSTALL_DIR "/opt/my/lib") + + +# Set default values +set(CYTHON_USER_INCLUDE_DIRS ${CMAKE_CURRENT_SOURCE_DIR}) +unset(CYTHON_USER_LIB_DIRS) +set(CYTHON_INSTALL_DIR "qiskit/providers/aer/backends") + +function(add_cython_module module) + add_cython_target(${module} ${module}.pyx CXX) + add_library(${module} MODULE ${module} ${ARGV1}) + set_target_properties(${module} PROPERTIES + LINKER_LANGUAGE CXX + CXX_STANDARD 14) + + if(APPLE) + set_target_properties(${module} PROPERTIES + LINK_FLAGS ${AER_LINKER_FLAGS}) + endif() + + # We only need to pass the linter once, as the codebase is the same for + # all controllers + # add_linter(target) + target_include_directories(${module} + PRIVATE ${AER_SIMULATOR_CPP_SRC_DIR} + PRIVATE ${AER_SIMULATOR_CPP_EXTERNAL_LIBS} + PRIVATE ${PYTHON_INCLUDE_DIRS} + PRIVATE ${NumPy_INCLUDE_DIRS} + PRIVATE ${CYTHON_USER_INCLUDE_DIRS}) + + target_link_libraries(${module} + ${AER_LIBRARIES} + ${PYTHON_LIBRARIES} + ${CYTHON_USER_LIB_DIRS}) + + python_extension_module(${module} + FORWARD_DECL_MODULES_VAR fdecl_module_list) + + python_modules_header(modules + FORWARD_DECL_MODULES_LIST ${fdecl_module_list}) + + include_directories(${modules_INCLUDE_DIRS}) + # TODO Where to put the target files + install(TARGETS ${module} LIBRARY DESTINATION ${CYTHON_INSTALL_DIR}) +endfunction() diff --git a/example/pulse_sim.py b/example/pulse_sim.py new file mode 100644 index 0000000000..0a27b2b2f5 --- /dev/null +++ b/example/pulse_sim.py @@ -0,0 +1,526 @@ +#!/usr/bin/env pythonw +# coding: utf-8 + +# ## Open Pulse Simulator - Rabi Example + +# If running the openpulse branch from source, may need to add a symbolic link in site-packages. Also run `python setup.py build_ext --inplace` in openpulse first. + +# In[1]: + + +#Import general libraries (needed for functions) +import numpy as np +import matplotlib.pyplot as plt +from scipy.optimize import curve_fit + +#Import Qiskit classes classes +import qiskit +#from qiskit.providers.aer.noise import NoiseModel +#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error + +import qiskit.pulse as pulse +import qiskit.pulse.pulse_lib as pulse_lib +from qiskit.compiler import assemble +import random +from qiskit.test.mock import FakeOpenPulse2Q + + +# In[2]: + + +qiskit.IBMQ.load_account() + + +# In[3]: + + +#Get a pulse configuration from the fake backend +backend_real = FakeOpenPulse2Q() +back_config = backend_real.configuration().to_dict() +system = pulse.PulseChannelSpec.from_backend(backend_real) + + +# In[4]: + + +#Get pulse simulator backend +backend_sim = qiskit.Aer.get_backend('pulse_simulator') + + +# ## Simulations +# +# ### These need to be run in sequential order +# +# [Rabi Oscillation](#rabi) +# Apply a pulse to Q0 and measure the population evoluation versus pulse amplitude +# +# [Measurement Level 1 for the Readout Test](#readout_test) +#
Prepare the |0> and |1> states and look at the measurement level 1 output +# +# [CR Oscillation](#cr) +#
Look at the Q1 State when we drive Q0 at the frequency of Q1 +# +# [T1](#t1) +#
Demonstrating noise with pulse + +# +# # Simulate a Rabi Oscillation + +# First, we are going to simulate a rabi oscillation, i.e., meausure the qubit state population versus the amplitude of a drive pulse. This is the same example that is in the tutorials. + +# ### Build Pulse Schedule + +# Build on qubit 0 + +# In[5]: + + +#qubit to use for exeperiment +qubit = 0 +# exp configuration +exps = 41 +shots = 512 + +# Rabi pulse +drive_amps = np.linspace(0, 0.9, exps) +drive_samples = 128 +drive_sigma = 16 + +# Measurement pulse +meas_amp = 0.025 +meas_samples = 1200 +meas_sigma = 4 +meas_risefall = 25 + +# Measurement pulse (common for all experiment) +meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp, + sigma=meas_sigma, risefall=meas_risefall, + name='meas_pulse') +acq_cmd=pulse.Acquire(duration=meas_samples) + +# create measurement schedule +measure_and_acquire = meas_pulse(system.qubits[qubit].measure) | acq_cmd(system.acquires, system.memoryslots) + +# Create schedule +schedules = [] +for ii, drive_amp in enumerate(drive_amps): + # drive pulse + rabi_pulse = pulse_lib.gaussian(duration=drive_samples, + amp=drive_amp, + sigma=drive_sigma, name='rabi_pulse_%d' % ii) + + # add commands to schedule + schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp) + + schedule += rabi_pulse(system.qubits[qubit].drive) + schedule += measure_and_acquire << schedule.duration + + schedules.append(schedule) + + +# ### Design the Hamiltonian + +# Let's build a transmon Hamiltonian with anharmonicity to test the Rabi oscillation and CR + +# In[6]: + + +hamiltonian = {} +hamiltonian['h_str'] = [] +#Q0 terms +hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0') +hamiltonian['h_str'].append('np.pi*alpha0*O0*O0') +hamiltonian['h_str'].append('2*np.pi*r*X0||D0') +hamiltonian['h_str'].append('2*np.pi*r*X0||U1') +hamiltonian['h_str'].append('2*np.pi*r*X1||U0') + +#Q1 terms +hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1') +hamiltonian['h_str'].append('np.pi*alpha1*O1*O1') +hamiltonian['h_str'].append('2*np.pi*r*X0||D1') + +#Exchange coupling betwene Q0 and Q1 +hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)') +hamiltonian['vars'] = {'v0': 5.00, 'v1': 5.1, 'j': 0.01, + 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33} + +#set the qubit dimensions to 3 +hamiltonian['qub'] = {'0': 3, '1': 3} + +#update the back_end +back_config['hamiltonian'] = hamiltonian +back_config['noise'] = {} +back_config['dt'] = 1.0 + + +# ### Add Solver Settings + +# Any solver settings also does into the back_config + +# In[7]: + + +back_config['ode_options'] = {} + + +# ### Restrict the Qubits Used in the Simulation + +# We can use a qubit whitelist (`qubit_list`) to restrict the set of qubits used in the solution. The pulse simulator will appropriately alter the Hamiltonian. To start let's assume the list contains the first 2 qubits. + +# In[8]: + + +back_config['qubit_list'] = [0,1] +#back_config['qubit_list'] = None + + +# ### Assemble the qobj with the backend config file and the qubit_list + +# We have to do this step twice to get the dressed frequencies for setting the LO's. Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state. + +# In[9]: + + +rabi_qobj = assemble(schedules, backend_real, + meas_level=1, meas_return='avg', + memory_slots=2, + shots=shots, sim_config = back_config) + + +# In[10]: + + +evals = backend_sim.get_dressed_energies(rabi_qobj) + + +# In[11]: + + +evals/2/np.pi + + +# In[12]: + + +rabi_qobj = assemble(schedules, backend_real, + meas_level=1, meas_return='avg', + memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi, + evals[3]/2/np.pi], + shots=shots, sim_config = back_config) + + +# ### Simulate + +# In[13]: + + +#Note: this is how to run bypassing the backend +#opsys = qiskit.providers.aer.openpulse.qobj.digest.digest_pulse_obj(rabi_qobj.to_dict()) +#simdata = qiskit.providers.aer.openpulse.solver.opsolve.opsolve(opsys) + + +# In[14]: + + +sim_result = backend_sim.run(rabi_qobj).result() + + +# Extract the qubit populations + +# In[15]: + + +amp_data_Q0 = [] +amp_data_Q1 = [] + +for exp_idx in range(len(drive_amps)): + exp_mem = sim_result.get_memory(exp_idx) + amp_data_Q0.append(np.abs(exp_mem[0])) + amp_data_Q1.append(np.abs(exp_mem[1])) + + +# In[16]: + + +#Fit the data +fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B) +fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5]) + +#get the pi amplitude +pi_amp = (fitparams[3])*fitparams[2]/2/np.pi + +plt.plot(drive_amps, amp_data_Q0, label='Q0') +plt.plot(drive_amps, amp_data_Q1, label='Q1') +plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit') +plt.axvline(pi_amp, color='black', linestyle='dashed') +plt.legend() +plt.xlabel('Pulse amplitude, a.u.', fontsize=20) +plt.ylabel('Signal, a.u.', fontsize=20) +plt.title('Rabi on Q0', fontsize=20) +plt.grid(True) + +print('Pi Amplitude %f'%(pi_amp)) + + +# +# # Look at the Shots Distribution + +# Using the pulse amplitude calibrated above, do an experiment with no pulse and an experiment with a pi pulse and look at the measurement outcomes. + +# In[17]: + + +# Create schedule +pi_pulse = pulse_lib.gaussian(duration=drive_samples, + amp=pi_amp, + sigma=drive_sigma, + name='pi_pulse') + +pi_2_pulse = pulse_lib.gaussian(duration=drive_samples, + amp=pi_amp/2, + sigma=drive_sigma, + name='pi_2_pulse') + +# excited +excited_exp = pulse.Schedule(name='pi_exp') +excited_exp += pi_pulse(system.qubits[qubit].drive) +measure_time = excited_exp.duration +excited_exp |= measure_and_acquire << measure_time + +# superposition +sup_exp = pulse.Schedule(name='pi_2_exp') +sup_exp += pi_2_pulse(system.qubits[qubit].drive) +measure_time = sup_exp.duration +sup_exp |= measure_and_acquire << measure_time + +# ground +ground_exp = pulse.Schedule(name='no_pi_exp') +ground_exp |= pulse.Schedule(name='ground_exp') +ground_exp |= measure_and_acquire << measure_time + +excited_exp_schedules = [ground_exp, sup_exp, excited_exp] + + +# Change the `meas_return=single` which will return each individual measurement + +# In[18]: + + +readout_qobj = assemble(excited_exp_schedules, backend_real, + meas_level=1, meas_return='single', + memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi, + evals[3]/2/np.pi], + shots=shots, sim_config = back_config) + + +# In[19]: + + +sim_result = backend_sim.run(readout_qobj).result() + + +# Plot the data, there is no measurement error in the simulator data so the histographs will be all centered at the average point. + +# In[20]: + + +ground_data = sim_result.get_memory(0)[:, qubit] +excited_data = sim_result.get_memory(2)[:, qubit] +sup_data = sim_result.get_memory(1)[:, qubit] + + +# Add some random noise to the data to better approximate the experiment + +# In[21]: + + +for idx in range(len(ground_data)): + ground_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1) + excited_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1) + sup_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1) + + +# In[22]: + + + +plt.scatter(np.real(ground_data), np.imag(ground_data), s=5, cmap='viridis',c='blue',alpha=0.5, label='|0>') +plt.scatter(np.real(excited_data), np.imag(excited_data), s=5, cmap='viridis',c='green',alpha=0.5, label='|1>') +plt.scatter(np.real(sup_data), np.imag(sup_data), s=5, cmap='viridis',c='red',alpha=0.5, label='|0>+|1>') +ground_center = np.mean(ground_data) +excited_center = np.mean(excited_data) +sup_center = np.mean(sup_data) + +plt.scatter(np.real(ground_center), np.imag(ground_center), c='blue', s=200, alpha=1.0) +plt.scatter(np.real(excited_center), np.imag(excited_center), c='green', s=200, alpha=1.0) +plt.scatter(np.real(sup_center), np.imag(sup_center), c='red', s=200, alpha=1.0) + +plt.title('Kernel integrated I-Q scatter plot', fontsize=20) +plt.legend(loc='upper right') +plt.xlabel('I (a.u.)', fontsize=16) +plt.ylabel('Q (a.u.)', fontsize=16) + + +# +# # Cross-Resonance + +# Simulate cross-resonance by driving on U0. Note you need to run Rabi first to setup the hamiltonian. + +# In[23]: + + +#qubit to use for exeperiment +qubit = 0 +# exp configuration +exps = 41 +shots = 512 + +# Rabi pulse +cr_drive_amps = np.linspace(0, 0.9, exps) +cr_drive_samples = 128*3 +cr_drive_sigma = 4 + + +# Create schedule +schedules = [] +for ii, cr_drive_amp in enumerate(cr_drive_amps): + # drive pulse + cr_rabi_pulse = pulse_lib.gaussian_square(duration=cr_drive_samples, + amp=cr_drive_amp, + risefall=cr_drive_sigma*4, + sigma=cr_drive_sigma, name='rabi_pulse_%d' % ii) + + # add commands to schedule + schedule = pulse.Schedule(name='cr_rabi_exp_amp_%s' % cr_drive_amp) + + schedule += cr_rabi_pulse(system.controls[0]) + schedule += measure_and_acquire << schedule.duration + + schedules.append(schedule) + + +# In[24]: + + +cr_rabi_qobj = assemble(schedules, backend_real, + meas_level=1, meas_return='avg', + memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi, + evals[3]/2/np.pi], + shots=shots, sim_config = back_config) + + +# In[25]: + + +sim_result = backend_sim.run(cr_rabi_qobj).result() + + +# In[26]: + + +amp_data_Q0 = [] +amp_data_Q1 = [] + +for exp_idx in range(len(cr_drive_amps)): + exp_mem = sim_result.get_memory(exp_idx) + amp_data_Q0.append(np.abs(exp_mem[0])) + amp_data_Q1.append(np.abs(exp_mem[1])) + + +# In[27]: + + +plt.plot(drive_amps, amp_data_Q0, label='Q0') +plt.plot(drive_amps, amp_data_Q1, label='Q1') +plt.legend() +plt.xlabel('Pulse amplitude, a.u.', fontsize=20) +plt.ylabel('Signal, a.u.', fontsize=20) +plt.title('CR (Target Q1, driving on Q0)', fontsize=20) +plt.grid(True) + + +# +# # T1 + +# Using the calibrated Pi pulse add a T1 decay channel and simulate a t1 experiment. This can take a while to run. The noise operators in pulse are still a work in progress. + +# In[28]: + + + +t1_times = np.linspace(0,500,10) +t1_times = np.array(t1_times, dtype=int) + +T1_exps = [] +for kk in range(len(t1_times)): + schedule = pulse.Schedule(name='T1_{}'.format(kk)) + schedule |= pi_pulse(system.qubits[qubit].drive) << schedule.duration + schedule |= measure_and_acquire << int(t1_times[kk]) + schedule.duration + T1_exps.append(schedule) + + +# In[29]: + + +# Add noise to the Hamiltonian on qubit '0' +back_config['noise'] = {"qubit": + {"0": + {"Sm": 0.006 + }}} +#back_config['noise'] = {} + + +# In[30]: + + +t1_qobj = assemble(T1_exps, backend_real, + meas_level=1, meas_return='avg', + memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi, + evals[3]/2/np.pi], + shots=100, sim_config = back_config) + + +# In[31]: + + +sim_result_t1 = backend_sim.run(t1_qobj).result() + + +# In[32]: + + +t1_data_Q0 = [] +t1_data_Q1 = [] + + +for exp_idx in range(len(t1_times)): + exp_mem = sim_result_t1.get_memory(exp_idx) + t1_data_Q0.append(np.abs(exp_mem[0])) + t1_data_Q1.append(np.abs(exp_mem[1])) + + +# In[33]: + + +#Fit the data +fit_func_t1 = lambda x,A,B,T: (A*np.exp(-x/T)+B) +fitparams, conv = curve_fit(fit_func_t1, t1_times, t1_data_Q0, [0.5,0.5,100]) + + +plt.plot(t1_times, t1_data_Q0, label='Q0') +plt.plot(t1_times, t1_data_Q1, label='Q1') +plt.plot(t1_times, fit_func_t1(t1_times, *fitparams), color='black', linestyle='dashed', label='Fit') + +plt.legend() +plt.xlabel('Wait Time (dt)', fontsize=20) +plt.ylabel('Signal, a.u.', fontsize=20) +plt.ylim([0,1.05]) +plt.title('T1 on Q0', fontsize=20) +plt.grid(True) + + +# In[ ]: + + + + diff --git a/qiskit/__init__.pxd b/qiskit/__init__.pxd new file mode 100644 index 0000000000..e69de29bb2 diff --git a/qiskit/__init__.py b/qiskit/__init__.py deleted file mode 100644 index 7909fc6dac..0000000000 --- a/qiskit/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# -*- coding: utf-8 -*- - -# This code is part of Qiskit. -# -# (C) Copyright IBM 2018, 2019. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. diff --git a/qiskit/providers/__init__.pxd b/qiskit/providers/__init__.pxd new file mode 100644 index 0000000000..e69de29bb2 diff --git a/qiskit/providers/__init__.py b/qiskit/providers/__init__.py deleted file mode 100644 index 7909fc6dac..0000000000 --- a/qiskit/providers/__init__.py +++ /dev/null @@ -1,13 +0,0 @@ -# -*- coding: utf-8 -*- - -# This code is part of Qiskit. -# -# (C) Copyright IBM 2018, 2019. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. diff --git a/qiskit/providers/aer/backends/pulse_simulator.py b/qiskit/providers/aer/backends/pulse_simulator.py index 4ddf647d9d..b5dada7cd2 100644 --- a/qiskit/providers/aer/backends/pulse_simulator.py +++ b/qiskit/providers/aer/backends/pulse_simulator.py @@ -30,6 +30,7 @@ logger = logging.getLogger(__name__) + class PulseSimulator(AerBackend): """Aer OpenPulse simulator """ @@ -45,7 +46,6 @@ class PulseSimulator(AerBackend): 'open_pulse': True, 'memory': False, 'max_shots': 50000, - 'coupling_map': None, 'description': 'A pulse-based Hamiltonian simulator', 'gates': [], 'basis_gates': [] diff --git a/qiskit/providers/aer/openpulse/__init__.py b/qiskit/providers/aer/openpulse/__init__.py index ad3da6e242..74d5c7b286 100644 --- a/qiskit/providers/aer/openpulse/__init__.py +++ b/qiskit/providers/aer/openpulse/__init__.py @@ -13,7 +13,8 @@ # that they have been altered from the originals. """Init for openpulse""" -import distutils.sysconfig +# pylint: disable=import-error +import distutils.sysconfig # noqa import numpy as np from .qutip_lite.cy import pyxbuilder as pbldr diff --git a/qiskit/providers/aer/openpulse/cy/CMakeLists.txt b/qiskit/providers/aer/openpulse/cy/CMakeLists.txt new file mode 100644 index 0000000000..57ebb25c4f --- /dev/null +++ b/qiskit/providers/aer/openpulse/cy/CMakeLists.txt @@ -0,0 +1,32 @@ +# Cython OP extensions + +include(Linter) +include(cython_utils) + +# We need to remove the -static flag, because Python Extension system only supports +# dynamic linked libraries, but we want to build a shared libraries with the least +# dependencies we can, so some of these dependencies are linked statically into our +# shared library. +string(REPLACE " -static " "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + +# Set some general flags +if(APPLE) + message(STATUS "On Mac, we force linking with undefined symbols for Python library, they will be + solved at runtime by the loader") + if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set(AER_LINKER_FLAGS "-undefined dynamic_lookup") + else() + # -flat_namespace linker flag is needed otherwise dynamic symbol resolution doesn't work as expected with GCC. + # Symbols with the same name exist in different .so, so the loader just takes the first one it finds, + # which is usually the one from the first .so loaded. + # See: Two-Leve namespace symbol resolution + set(AER_LINKER_FLAGS "-undefined dynamic_lookup -flat_namespace") + endif() + unset(PYTHON_LIBRARIES) +endif() + +set(CYTHON_INSTALL_DIR "qiskit/providers/aer/openpulse/cy/") +add_cython_module(channel_value) +add_cython_module(measure) +add_cython_module(memory) +add_cython_module(utils) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/CMakeLists.txt b/qiskit/providers/aer/openpulse/qutip_lite/cy/CMakeLists.txt new file mode 100644 index 0000000000..3ff321d402 --- /dev/null +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/CMakeLists.txt @@ -0,0 +1,30 @@ +include(Linter) +include(cython_utils) +# We need to remove the -static flag, because Python Extension system only supports +# dynamic linked libraries, but we want to build a shared libraries with the least +# dependencies we can, so some of these dependencies are linked statically into our +# shared library. +string(REPLACE " -static " "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + +# Set some general flags +if(APPLE) + message(STATUS "On Mac, we force linking with undefined symbols for Python library, they will be + solved at runtime by the loader") + if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set(AER_LINKER_FLAGS "-undefined dynamic_lookup") + else() + # -flat_namespace linker flag is needed otherwise dynamic symbol resolution doesn't work as expected with GCC. + # Symbols with the same name exist in different .so, so the loader just takes the first one it finds, + # which is usually the one from the first .so loaded. + # See: Two-Leve namespace symbol resolution + set(AER_LINKER_FLAGS "-undefined dynamic_lookup -flat_namespace") + endif() + unset(PYTHON_LIBRARIES) +endif() + +set(CYTHON_INSTALL_DIR "qiskit/providers/aer/openpulse/qutip_lite/cy") +add_cython_module(spconvert src/zspmv.cpp) +add_cython_module(math src/zspmv.cpp) +add_cython_module(spmath src/zspmv.cpp) +add_cython_module(sparse_utils src/zspmv.cpp) +add_cython_module(spmatfuncs src/zspmv.cpp) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py b/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py index 2d1ca0b4be..b7f9792bba 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/pyxbuilder.py @@ -48,6 +48,9 @@ import sys import os import pyximport +from pyximport import install + +__all__ = ["install"] OLD_EXT = pyximport.pyximport.get_distutils_extension diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_routines.pxi b/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_routines.pxi index 983d21b908..f0664fad0b 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_routines.pxi +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/sparse_routines.pxi @@ -39,7 +39,7 @@ cimport numpy as np cimport cython from libcpp.algorithm cimport sort from libcpp.vector cimport vector -from qiskit.providers.aer.openpulse.qutip_lite.cy.sparse_structs cimport CSR_Matrix, COO_Matrix +from .sparse_structs cimport CSR_Matrix, COO_Matrix np.import_array() cdef extern from "numpy/arrayobject.h" nogil: diff --git a/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py b/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py index e77c68eefc..e7c6e9557e 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/fastsparse.py @@ -436,5 +436,5 @@ def _all_true(shape): # Need to do some trailing imports here # ------------------------------------- -# pylint: disable=no-name-in-module, wrong-import-position +# pylint: disable=no-name-in-module, wrong-import-position, import-error from .cy.spmath import (zcsr_transpose, zcsr_adjoint, zcsr_mult) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/qobj.py b/qiskit/providers/aer/openpulse/qutip_lite/qobj.py index b67f953a58..a199966441 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/qobj.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/qobj.py @@ -1248,11 +1248,9 @@ def transform(self, inpt, inverse=False, sparse=True): raise TypeError( 'Invalid size of ket list for basis transformation') if sparse: - S = sp.hstack([psi.data for psi in inpt], - format='csr', dtype=complex).conj().T + S = sp.hstack([psi.data for psi in inpt], format='csr').conj().T else: - S = np.hstack([psi.full() for psi in inpt], - dtype=complex).conj().T + S = np.hstack([psi.full() for psi in inpt]).conj().T elif isinstance(inpt, Qobj) and inpt.isoper: S = inpt.data elif isinstance(inpt, np.ndarray): diff --git a/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py b/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py index aaf148f624..adf769eebb 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/superoperator.py @@ -54,7 +54,8 @@ from .qobj import Qobj from .fastsparse import fast_csr_matrix, fast_identity from .sparse import sp_reshape -from .cy.spmath import zcsr_kron # pylint: disable=no-name-in-module +# pylint: disable=no-name-in-module, import-error +from .cy.spmath import zcsr_kron # pylint: disable=dangerous-default-value diff --git a/qiskit/providers/aer/openpulse/qutip_lite/tensor.py b/qiskit/providers/aer/openpulse/qutip_lite/tensor.py index 636c84ba21..041bf4d55d 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/tensor.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/tensor.py @@ -49,7 +49,8 @@ """ import numpy as np -from .cy.spmath import zcsr_kron # pylint: disable=no-name-in-module +# pylint: disable=no-name-in-module, import-error +from .cy.spmath import zcsr_kron from .qobj import Qobj from ..qutip_lite.settings import auto_tidyup From 133119f0555a11ab98dc7acdc8e2af02f9e19f60 Mon Sep 17 00:00:00 2001 From: David McKay Date: Tue, 8 Oct 2019 04:01:10 -0400 Subject: [PATCH 04/24] Added statevector and estates, fixed meas level 2 * Fixed ordering for meas level 2 * Fixed error in example --- example/pulse_sim.ipynb | 141 ++++++++++-------- .../providers/aer/backends/pulse_simulator.py | 2 +- qiskit/providers/aer/openpulse/qobj/digest.py | 1 + .../providers/aer/openpulse/solver/opsolve.py | 13 +- .../providers/aer/openpulse/solver/unitary.py | 2 +- 5 files changed, 95 insertions(+), 64 deletions(-) diff --git a/example/pulse_sim.ipynb b/example/pulse_sim.ipynb index e2e6a8751f..5b3f80a789 100644 --- a/example/pulse_sim.ipynb +++ b/example/pulse_sim.ipynb @@ -41,26 +41,6 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 2, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "qiskit.IBMQ.load_account()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, "outputs": [], "source": [ "#Get a pulse configuration from the fake backend\n", @@ -71,7 +51,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -131,7 +111,7 @@ }, { "cell_type": "code", - "execution_count": 5, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -194,7 +174,7 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -210,7 +190,7 @@ "#Q1 terms\n", "hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1')\n", "hamiltonian['h_str'].append('np.pi*alpha1*O1*O1')\n", - "hamiltonian['h_str'].append('2*np.pi*r*X0||D1')\n", + "hamiltonian['h_str'].append('2*np.pi*r*X1||D1')\n", "\n", "#Exchange coupling betwene Q0 and Q1\n", "hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)')\n", @@ -242,7 +222,7 @@ }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 6, "metadata": {}, "outputs": [], "source": [ @@ -265,7 +245,7 @@ }, { "cell_type": "code", - "execution_count": 8, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -289,7 +269,7 @@ }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -301,16 +281,16 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 23, "metadata": {}, "outputs": [], "source": [ - "evals = backend_sim.get_dressed_energies(rabi_qobj)" + "evals, estates = backend_sim.get_dressed_energies(rabi_qobj)" ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 24, "metadata": {}, "outputs": [ { @@ -320,7 +300,7 @@ " 14.76614835, 9.86913744, 14.87385165, 19.54 ])" ] }, - "execution_count": 11, + "execution_count": 24, "metadata": {}, "output_type": "execute_result" } @@ -331,7 +311,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -351,7 +331,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ @@ -362,13 +342,56 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ "sim_result = backend_sim.run(rabi_qobj).result()" ] }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "128.0" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#get the end time of the simulation in dt\n", + "sim_result.results[0].header.ode_t" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j,\n", + " 0.+0.j])" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#get the statevector IN THE FRAME OF THE ORIGINAL HAMILTONIAN\n", + "sim_result.get_statevector(0)" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -378,7 +401,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ @@ -393,19 +416,19 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Pi Amplitude 0.315141\n" + "Pi Amplitude 0.313255\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -454,7 +477,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ @@ -498,7 +521,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -511,7 +534,7 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 34, "metadata": {}, "outputs": [], "source": [ @@ -527,7 +550,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 35, "metadata": {}, "outputs": [], "source": [ @@ -545,7 +568,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 36, "metadata": {}, "outputs": [], "source": [ @@ -557,7 +580,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 37, "metadata": {}, "outputs": [ { @@ -566,13 +589,13 @@ "Text(0, 0.5, 'Q (a.u.)')" ] }, - "execution_count": 22, + "execution_count": 37, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZIAAAEgCAYAAACegPWEAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDMuMC4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvOIA7rQAAIABJREFUeJzsnXt4VNW5uN9vcoPZE0QCAQQSLkJERYEEQgYItkK12lbt0WpJLCg04SJoW/Wc09+ppe1pj7X2VKEiARFU0LZYL/Wobb1UApkAJmjVqlwEAuGWcBEyE3Kd9ftj7Ukmk5lkck9gv8+TZzJ7r7322nv2Xt9a322JUgoLCwsLC4vWYuvqBlhYWFhY9GwsQWJhYWFh0SYsQWJhYWFh0SYsQWJhYWFh0SYsQWJhYWFh0SYsQWJhYWFh0SYsQXIeIyKXiogSkafCLD/TLP9fHd02i+YRka0iUtPV7bDonrT0/e5ILkhBYt78oAE05o/zhVnmV53dtvMBEYk079/bXd2W9qS7C1pT8CgRmdaKY+0i8kMR2SIiJ0WkSkSOiMjLInJTR7S3M2hOGItIsYjs7cw2dTdEZL753GS2to7I9mxQT0dEkoE3gP7AEqXU77u4SZ2NCxgLlHZ1Qyw6DxEZB7wGJAIHgE3AKfP7jcDNIvIqkKGU8nRVOy26L5YgMRGRmcDLQDRwh1JqUxc3qdNRSpUDn3d1Oyw6DxG5BHgLGAj8N/AzpVSN3/444AXgJuBZ4N+6op0W3Ryl1AX3Byh96XXf7wAqgTPAV5o47nL0y1QMVAHHgI3A6CBlN5jnSQDuBT4GzgFvm/tnmvv/C5gAvGme3wO8B6SGaEMkcA+wHTgLlAM7gUWABJS91DzHU2Hel7o2BWzfCtQAUWZ795r36yDwP0CUX9n5vvsb5C+w3jTgz+Z9rAIOAauAwSHal4ru9MrMe/UWMBndASpgWsB9UsDbwCXA08ARoBbINMskAb8GCtCzsEr0iDwHGBLi9wz2Ny2gbIb5G34JVACfAj8GokNcV4b5G1YAJcAzwCDffW/Bc701WHuaOWa9ecxzTZRxAPvNct8Is94+wE+BT8zfq8x8bl4AJgQpPwX4k/kbVZmffwNuDSh3N/ASsA/9Pp0xr3t2iGc/2N/b1D/rwf6eCqir3d77Zu5ZsXmP+gIrzXtQAfwLWEwL3m/0M/8kUGQ+1yXod21CQDnfMxPsb2i4z9EFPyMRkXuB3wHHga8rpT4MUe5G4EUgAq0G+AIYhh6h3SgiM5RS/wxy6BPANLTK7HX0g+jPZOD/oX/QNWh1wr8B74rIeKXUHr82RJt1zETPHDaiH5KvmueZDMxt2R1oEX9Ad/5/RXcMNwL/gVYFft8ssxP4BfATdOfzrN/xub5/ROT7aKFxDvgL+iUaY9bzDRFJVUod9it/jXneCPTvsB+42qzzH020uT+wDd3h/Bn9gpSY+24Dsszj84BqYJxfG1KUUkfNsi8BXuBOs3zdtaAFqq+dzwDfM7e9aJ7XCfwS+KqIXKeUqvUr/wDwCHAa3amfAb5utqe8ietqMyJiALPNrz8PVU4p5RaR3wGPAwuA/2umXgH+jhb8LvRzXQsMBb4CbAY+8Cu/AP38VqOfhb1APDDJPN+LftXnAB+adRxD/743ABtFZLRS6mdmuVPAz9CCZ2jA9e0z/34G/BA9SFrut3+nX9s66r0PRQzwLlp4P29+vw34Pfr9uLe5CkRkFLo/GYQWms+jBdttZptvUUq9aRZ/Gn2vvonWyHzkV9XZMNt8Yc9I0KNpBewGRjRRPg49uiwFLgvYdxV6FvF+iJHJISAxSJ3+I6LMgH2Lze3LA7b7Rt6PARF+2yOoH1neGM6IJcR1NjUjUcAO4GK/7Q70C1kDDPDbXjcbCHGesegXaxcBsw/ga+hOZ1PA9e0z65wVUP4ev/sYbEaigHX+98uvzFAgJsj2r6OFxopw7o/fft9s7E9Ar4B9vzD3LfbbNsq8DyeAhIDrfcUs32EzEnSnroCiMMqONcueDaPsBLPspiD7IgKeoavM5+ckMDZI+WEB30cFKRODngFWAYOC3JOQ9xBzFhBiX7u/983ct2Lz2M34zV7RwtI3I3T6bQ/6fgPvmNv/PWD7dPPdKgXsQZ7bzJa0t0HdrT2wJ//5dTDKfPhGNlP+R2bZ7BD7V5j7xwR5oBaHOMbXKb0XZF+M+YNv89sWgR61FhO8U4wz63u+uQetietsTpBcE+SYX5r7rvfb1pwg8d2v60Lsfw09OjXM79eY5f8epGwEegQbSpCcA+Ja8Yx8CuwO5/747f8YPUPsE2RfpPn7ufy2/dSs7ydByo9GC7OOFCSzzfJbwyjr8HtnGl1fQFmfIHk2jHqfNMsuaelvFFDPd8x6AlVcbREk7f7eN3MNPkGSFmSfr7Nf47et0fsNDDe37QMig9TzQuB9oh0EyYWu2vobcB3wvIhcr5T6MkS5NPNzgogsC7L/UvNzLHp248+OZtpQELhBKVUpIqXAxX6bx6J1p8eBn2jtQSMqzHIdRaO2okde0LCtzeG7n18RkbQg+/ujO95LgX+iOybQnUIDlFK1IpKPHt0HY59S6mSwHaYK5k5gDnqEeTFaMPkIW7UkIrHAlejf54dh/j4Tzc/NgQWVUntE5AhaPdFqRORutFrDn3eVUrmAr5EqnKr8/u9F02qPj82/O0VkBFpdtRUoUEpVB5SdYn6+SRiIyHDgQeBatIqpd0CRIeHUEyYd+d6Hogqtig3kPV9bmjnetz9X+TlN+PEu2iY8Aa3yahcudEFyE1oN8S20TeJrSqkTQcrFmZ/ZzdTnCLLtWDPHhBJeNTTs1HxtSEKPZFvShvagVinlDrLd97BGBNkXCt+1/Hsz5XzXcpH5eTxEuVDboen7vxytGjuCtr8cRnf2oHXrlzTTPn/6mZ8Dafr38X+5m7uuY7RRkKCvY2qQNuQCPvtPoKAJxlC/Y083VVApVWPatH6KtiU8Yu46KyLrgR+rejfivubnYZpBRC5Fd9AXme3/G9qmVAuMRA8KYsK4lnDpyPc+FCXKnCaEqO+iIPv88e0/GmK/b3vfEPtbxQUtSMyR/7+hjdbfAd4TkZlKqcCH4Iz5eYVS6tOWnqat7Qxowyal1Hfaqc6uwncthtIux83hG/0ODLE/1HYIcf9FZDDaFvVPtCrIHbD/zjDa5Y/vmt5XSk1u4TED0faiQNoqRFBKNRWcuB2tQkwwDdV7mig70/z8OMisIth5T6ENw/eKyGi0ejIbWIr26LrLLOobSA1Bqyib4n70rPFOpdQG/x3m79XS36w5uuK9jxcRCSJMfM/CmcADAvDtD/XsDA6znhZxQUa2+2NO/2ajXS6vADaLyNCAYr6p5vTObFsA/0J7SqWJSHcfAHjNz1CzlJbeT5+HT6NOUUQiqFdBtIRRaHXN34IIkUS0rjkQn7dVo+sy1aK7gHEiEu5oz+cdNCNwh9n5tmRG1GLMWYFPvREyWt/07vqB+bXF6hCl1B6l1Br0dZ4Dbvbb7XsWvh5GVT5V0p+D7Gt0D01q0VrMoLpGc397PaftQTT16j5/rjE/Pwiyzx/f/unmuxHIV8zPnX7bQj7X4XLBCxLQenb0CCkH7WKXa+pifaxFj4p/LiIpgceLSIQ5le/INlajXQCHAo+JSK8g7bhERDrSRhIWSikvWv0RSmWyAq0iedxUVzRARKID0nzkouM7ZonIrIDiCwltH2mKA+ZngxfOtHWsJvi74bO1hLqu/0XbD9aKSCMVhIj0ExF/HfcG9H24V0QS/MpFAL+hoV2io/gxWrX2PRFZFtj5iEg/dMc9Au2A8GRzFYrIqBDP4cXoWCT/WehKdEe2TEQuC1KXv83jgPl5TUCZGwjt9n4S/VsGDg7998eLSDCVWFe99w+brv6+8/RHhwiA9kAMiVLqANo9fRSwxH+fiEwFbkdf86t+u5p7rpulu49sOw1zKrlARM4B9wFbROSr5miqVERuQ79QO8wcUp+ip6/D0DroWDrOPuHjp2ij8GLgJhF5F63fH4j28nGi7Q6fdXA7wuEd4FYztcYH6A7zPaXUVqXUv0RkPjq+4FMReRPYg9ZvJ6BHgEfQxmufQX0+2if/DRF5Ee2VcjVa5fJX4HrqZ0LNopQqNuu5Fdhp/qYXod2P3Whj8eUBh32K1jFniEgt2tFAAc8opQ4ppVabaXaygBki8nd0PEk/tA5/unnN95ht+EJE/h86KPJDEfkT9XEkBjqYr0MHBkqpIyLyNbSn3E/RBvK/0zBFSl+0DeNGFV6KlAnAJhEpQF/DUXRcyE3oPufXfuf/WESWoAdJH5rPyxdo+8Qksx0+tdoT6Bidl83f7ij6GbkObeu8PUhb3gFuAV4Rkb+iZ0T7lVIb/fZPAP4qIlvQxu4PlFKvd9F7X2zW+YmI/AX9TtyKVlUtV0q5wqgjG+3c8DsR+TpQSH0cSQ0wN+B3dKFtgz8SkQHUx1k9rpQqC6vVrXX36sl/0DCyPch+n0vrUbR+1Ld9JHoEtde88WfQgYHPAN8KqMPnBhg0OpTmXUmDuiWiR1dz0N4Xp9AP/mFgC/Cf/uejnSPbQxwT1HUQ/eC/YD6UtSHqvdq8d77o21PojudJgrsap6EDrNzokaIvsn2VWf+VfmWbdEE2yxjoWCLf73kQ3aFdHOqa0UF2/zDP73OHDYxs/xY6CK0UbYM4hrZH/AJIClJnBlrY+iLbn0Xrsjs8sj3gXtyPDoQ8jRbKvuvLoRmX34C6hpn31WVeeyVa6L5OaJfvqeiAuBLqI9vfBG4JKDfNvP+nzd9gi3m/Qz27kcDD6DiM6sBnAi0EctDvUA3B4zLa7b1v5r75R7Y/ad6DSrTwuoeWRbYPNd+Lg9THKr0EpIQ49w1oVZ7b73cP+xrErMTCosciItvRrrSxSqmK5spbhIeIzAOeQnfcNyqlznVxk85rRKQYqFBKNVL3dncsG4lFj0B0mvNgdof56FnJm5YQaV+UUmvRo/mvAC/56+0tLPyxbCQWPYWRaD31W2gdehR6FuJEqznu78K2nc/8GK2euhhts8jr2uZYdEcs1ZZFj0B0OvNH0G6eA9FGyGNoO8l/K6X2d2HzLCzaTE9WbVmCxMLCwsKiTVwQqq3+/fur4cOHd3UzLCwsLHoUhYWFJ5RSA5ord0EIkuHDh1NQECzfoIWFhYVFKESkKJxylteWhYWFhUWbsASJhYWFhUWbsASJhYWFhUWbuCBsJBYWFuc/1dXVFBcXU1FhxaW2lF69ejF06FCioqJadbwlSCwsLM4LiouLiY2NZfjw4YTOGm8RiFKKkydPUlxczIgRI1pVh6XasrCwOC+oqKggLi7OEiItRESIi4tr00zOEiQWFhbnDZYQaR1tvW+WILGwsLAIgVKKWm8tVgaQprFsJBYWFhZBUEpRWl6Kp8qDEW0wwD7AmvGEwJqRWFhYWATBq7x4qjxER0TjqfLgVc0vwHnNNddw4MABTp06xaxZsxg9ejSzZs3i9OnTndDirsMSJBYWFhZBsIkNI9qgqrYKI9rAJuF3lw8//DDXXnste/bs4dprr+Xhhx8G4MyZM3i9Ya8I3WOwBImFhcUFi1LgduvPQESEAfYBJFyU0GK11quvvsqcOXMAmDNnDq+88goAW7duJSkpiWXLlnHw4MF2uYbugCVILCwsLkiUgpwcWLRIf4YSJhG2iBbbRo4fP87gwYMBGDx4MCUlJQDceOON5Ofn07dvX2666Sauu+46Nm3aRFVVVZuvpyvpdoJERK4XkV0isldE/iPI/gUi8rGIfCgiW0Xk8q5op4WFRc/G4wGXCxIT9afH0znn7d+/P/fddx8ffPABy5Yt46GHHiIlJaVzTt5BdCtBIiIRwBPA14HLge8GERTPK6XGKaXGo1fM+99ObqaFhcV5gGGA0wlFRfrTMNqv7oEDB3L06FEAjh49Snx8fIP9n376KQ888AB33nknTqeTNWvWtN/Ju4Du5v47GdirlNoHICJ/AG4CPvUVUEqd9StvAJaDt4WFRYsRgexsyMzUQqQ9PXu/+c1vsm79Ov7zP/6TZ555hptuugmAnTt3smjRImw2G/PmzePDDz/E4XC034m7iO4mSIYAh/y+FwOpgYVEZDHwQyAa+GqwikQkC8gCSEhIaPeGWlhY9HxEoL37caUU85fO5+477+aptU8xInEEmzZtAqB3796sW7eOsWPHtu9Ju5juJkiCjQkazTiUUk8AT4jIbOC/gDlByqwGVgOkpKRYsxYLC4tOwau8xMTGsOm1TVTVVpFwUQIRtgiA806A+OhWNhL0DGSY3/ehwJEmyv8BuLlDW2RhYdHj6MrUJm2JP+mpdLcZyfvAaBEZARwG7gBm+xcQkdFKqT3m1xuBPVhYWFiY+Kc2sUfZiTfiOy21ydy5c7n44ou5yH4Rcb3jsIntgkir0q0EiVKqRkTuAf4GRABPK6X+JSI/BwqUUn8B7hGRmUA1cJogai0LC4sLF19qkxpvDSUeHb/RWcJk7ty5df9HSESHn6+70K0ECYBS6g3gjYBtD/n9f2+nN8rCwqLHYBMb9ig7JZ4SekX2wlOt82RdSB17Z9PtBImFhYVFWxAR4g0dt+Gp9uCIdrTJTqGUwqu8F4yaqjVYgsTCwuK8wydM2ioArFTy4XH+uxNYdBhNJbyzsOgSlILaWlCq1Xmy/GlpKnlfGvlNmzZxxRVXYLPZKCgoaPX5ewqWIOnmdNfOOpyEdxYWnU5pKRw8qD/b4aFsrSvvlVdeyUsvvUR6enqD7R6Pp8cnaAyGJUi6Md25s+6qhHcWFiHxevWDGB2tP8NY90MphbvKHTLepLWp5MeOHUtSUlKj7bt37yYpKYkf/ehHfPbZZ2HV1ROwBEkn0tLZRXfurDsy4Z2FRauw2fSDWFWlP21Nd29KKXIKc1j0+iJyCnOaFCZtVZH5mDBhAh999BFjx45l/vz5TJs2jXXr1uHpTi93K7AESSfRmtlFd+6sfQnvVq7Un5b90aJbMGAAJCToz2YeSk+1B9chF4kXJeI65MJT3TmdeWxsLPPnzycvL4/Vq1ezZs2aurVLeiqWIOkkWjO76O6dtS/hXXdrl8UFjAhERIT1UBpRBs5hTorOFOEc5sSI6ryRWlFRET/72c/49re/zbBhw3jxxRc77dwdgeX+20n4ZhcuV8tmFx2RndTCwkJniM0eP5/McRkY0Y5Oces9cOAA8+fP58SJE9x1113k5eURFxfX4eftaCxB0gxK6dlDW9cr6Mi1DzqK9rp2C4tuh1JQWop4PDgMAwa0cLSmlDbm22xBX46XX36ZJUuWUFpayo033sj48eP529/+RkREBL/61a+YPHlyO11I98ASJE3gs2v4ZhFtVS8JCgce9Hpc3btnburaLQFj0eMJ9PCKi9MqsTBQSqFKSxBPOWIYQe0xt9xyC7fcckujY4cNG8awYcMabe/pWDaSJmhXr6nu7MsbhFDX3sMuw8IiOC308PKhlOKEuwTP6RLKpQYVppvx+Y4lSJqgXb2murMvbxBCXXsPuwyLbkBzsRodfPK6SPcGiLTIw8uHV3lx13io7d0Lb2UFyrA3EEJz586lb9++7XkFPQJLtdUE7WrXaK21vYNoTj0V6tq72WVYdHN8sRquQy6cw5xkJ2d3Xq4q0w5S96AHCgyfh1e4dXm92Gw2jGgHp2PdOC6Ox+GIb1Cnfxr5CwlLkDRDu3lNBfTMCsHj7ho7Qzi2n1CCpic6DVh0HYGxGplXZeKI7iQ3xDbYQRrgJ5DEMBgwYECrFq06n7MIW6qtjiQwlN2USgrpUjtDc+qp5uwgVvyIRbh0ZaxGa+0gjfB69XtsCiTxelsc6e7LInzwzEFKy0u7Rs3XgViCpKNoojfuajtDA/tHmsJQ7m7VPovzBxEhOzmblTeu7Fy1lj55q+wgDVAKTp6Eyko4e7bVAqmlWYR7GpYg6Sia6I27MvWJT2WVlQUrn1BkSw6yuKGw686pWSx6HiKCo5MC/oKcPOxI96D41GN9+kBMjFaPtaKu1mYR7imcX1fTnWiiN+6q1Cf+k6TVq8HAgwQRdt09NYuFBXSSN5i/eszhaHY24luP5NSpU8yaNYvRo0cza9Ysvvzyy1ZlEQ7GsmXLWL9+PQCff/45aWlpxMTE8Oijj7a6zrZiCZKOopneuFk7QwcsRNJokkTTws6yg1h0V8LN3NtmQqjHlFLUemtDnvfhhx/m2muvZc+ePVx77bU8/PDDiAjusvAF3/r161m2bFmTZfr168fy5cu5//77G+07ffp0WOdpDyxB0pGE6o2bExIdFPVnGJCWBnv36k/D0X5Tj+66AJfF+Um7Ze41H1zl9YYWDAHqsXAM56+++ipz5swBYM6cObzyyisAbN26laSkJJYtW8bBgwdb12Y/4uPjmTRpElFRUY32paSkMHv2bN59990ON+5bgqSzCUdIdKC1W6T+r25DG6ceyqtY+7ibRQuVFe1u0Sm0xBss5OzBfBfVokWUrfgtB78sCsujqjnDea23luPHj9elhh88eDAlJSUA3HjjjeTn59O3b19uuukmrrvuOjZt2tQhqybu3r2b2bNn8/vf/57LL7+cX/3qVxw5cqTdzwPdUJCIyPUisktE9orIfwTZ/0MR+VREPhKRd0QksSva2WrCERIdZO32nXrUqPpTt3kmoRSVK3JIWrGIfzuZgytPWV5eFh1OU95gPsHhEx4hZw/mC6EShiH5+cRU1DTpUeWrN5ThXClFdW01R8qOoFAhBVL//v257777+OCDD1i2bBkPPfQQKSkpAJw8eZLx48czfvx4HnroIVatWlX3/eOPP27RPYqIiOAb3/gGL730Erm5uezbt4+EhAR27NjRonrCoVsFJIpIBPAEMAsoBt4Xkb8opT71K/YBkKKUKheRhcAjwO2d39pWEk5oeAdF/QWe2m5vh6SUHg8xhS7sSYmwy0X6kkwMw8p7b9Hx+LzB/PEJjpPlJwHo17sfnmoPMRExeKo8xPWOI0LMoETzhRCXC5WWRmWvyJAeVb56PVUejGiDAfbGQYle5aVW1VLjreHi/hfz8RcfM27UOI4dO0Z8fHyD+j799FPWrVvHyy+/zIwZM8jKygIgLi6ODz/8ENA2kgMHDjRrJ2mKM2fO8Mc//pF169YRFRXF2rVrueqqq1pdXyi6lSABJgN7lVL7AETkD8BNQJ0gUUr9w6/8NiCzU1vYVsIVEmGG1CuvwlPiwYg3EFvTUiDw1IGTo8zMVkTxGwbidDLR5aLyOifTlhiWgd6iy/AqL+4qd92swtfxl1eXNxYS5gshmZnE2u0YqJBR54HqrLjecUTYGkbJ28SGTWxU1lQy8/qZbHhuA//z0//hmWee4aabbkIpRUFhAUvuWYLNZmPevHl8+OGHODpowaHMzEzy8/O57bbbePbZZxk9enSHnAe6nyAZAhzy+14MpDZRfh7wZrAdIpIFZAEkJCS0V/vah3bKu6K8itzMHGzbXXhTnaRvyA5LmDgMHUxi2A2cTmlb3iy/l7GXlTPFoouxiQ1HtIPKmkoAHDEOBtgHhE5NYr6LAjSVPMWnzvIJpmCzFhEhOiKaOHscC3+wkPvm3cdlSZeRkJDAn/70J0rLS/my5ksefeJRpk6c2i5xNceOHSMlJYWzZ89is9l47LHH+PTTT+nTpw/f+c53WL9+PZGRHd/NdzdBEuzOBlU0ikgmkALMCLZfKbUaWA2QkpJyXpp/PSUebNtd1AxOJHK7C09JJo5BzQgov0Rb4nSSnZVNZqY0q0FrMsljE4LRWrvEojMRkTq1E2gBIECEok1LAPnX21yurP72/gxNGEruP3LrytV6azl45iCXX345VbVVeJW3XsUWgnASQA4aNIji4uKg+771rW81e3x70d2M7cWA/6ovQ4FGbgYiMhP4f8C3lFKVndS2bocRb+BNdRJ5tAhvqhMjPsiUItCaHqDPknJPs05brfVGttYusWgvWhJ8KCJE2CJ0PizQCReLivRnGx5CX73NzSROnjtJ8dniBsZ934ymurrSimzvBN4HRovICBGJBu4A/uJfQEQmADloIVLSBW3sNohNSN+QzYS8lcHVWsF6csNAOZ1Uf1GEClOf1VpvZCtnl0V70KbgQ69X58o6d05/er2h1yhpfQPr6vve975HlD2qkWuwAAM8kHBGf7Zlcn7NNdcwfvz4dml6e9GtBIlSqga4B/gb8BnwJ6XUv0Tk5yLim6f9BnAAm0TkQxH5S4jqLgjEJjgGOYLbRoL05AohR2WzSK0kR2WjwnikW+uNbOXssmgPWhJ8GJaQKS2FgwcbzVCajFYPJXx8KebN+u666y4GDxjcOKeW14t4PNhiYpA2rqrYEYKkrQGL3c1GglLqDeCNgG0P+f0/s9Mb1d0I1/AQxNXY4wFXvpB4qQNXPmTeGZ7dPyND/7UkdrFT1i6xjDDnPb7gQ9/iWKGCD3v16sXJkyeJi4urVz/ZbDrRottd/6B7PKjoaJTbjcTFIRERQd176+pQCkpK6p+zeL/FrALWPJG4uOC2FF/OLl8drU1p3wEopTh58iS9evVqdR1yvuXFD0ZKSooqKCjo6ma0D+GsSoVf/2pXSHl9Rxvm4c2erlv03y29GIsei1IKT7UHI8oIaaOorq6muLiYioqKxju93vrOu6yM6nNuKiNAORzExsTiVV5OnTtFpC2SGm8N/Xr3q59NnD0LZWX1D35sLN5YR/3+sjKdZj4mBmJjm74Q/3a0pUw706tXL4YOHdoo1YqIFCqlUpo7vtvNSLor/h0ndGEnGqCuUhmZeMTRQGD4Fs7S/auQne2oa2dzs4RAAREs1sQwWr/CYkfei9YFwlj0BIIFHwYSFRXFiBEjmq3LXVnGD/6cxaCBoygqPcjKG1diRBl6SeAD5pLAY81oebcbFi6E48chPx+VlsbuqDP8dvYIrhw1haWTl2LzvShtfdh78MCo+8yvujH+NutVq7rYE8nP8KCcTnI2GCxaqONJ1MKF8PjjeMq8TRq5m8olGXhtdjskJze0c7R1hcWOuBeWEeb8oKNTwyulUEDy6BkUnT1YpyoLmXLFMGDqVK3Ouv56agbEkTcUjqgzrNi+ghU7Vuj4hPZIld3DpNtOAAAgAElEQVSDvVOsGUkY+P++ubn6efHlq2rLILjFo3b/VakyM/EoA9diYfQlbmyb8qgdfZLIFSswEJxpS8lzCcnJWhi09DpdLm0T2bgRCgq0MMnK0u1sLstLp00UrAXkzyt83lk+W0hrVlQMqgIz3xtlt5OzczWuQy7ShqbxxA1PNFhwK+isx/8Zs9uJ9Hg4+8lT7Nrxe5L6J1F4tBBPtSfsdeh9ghJovNhXOOmTuinWjCQM/Ae+6en6r6lBcDiJEFs8alcKlZND1fcXcW75apTdwHAITifsOWJAcjIRe3dBUhKys5CsDA8pKbBzp17EKpwBXuASvLjduPIUw4fresrLdbnmFr7q1ImCtXDKeUNbU8MHdRM235vqBVlUrFyO62AeiRclkl+cj4D2oArw3Go0I/I9YzYbOBzcPWEeS1KXENc7juTBydgjwxupKaXIKchh1nOzmPXcLFYVrGp8nh66opxlbA+TcG0k4ao53W4tRBITdYe7cmXTo3ZV5mb3rEXkHUpkYFURR368kvn3Oerb0tuL/H4FFBaC04k7I5tFi4WEBNi3T7cp0A4YbEakFHjcCmOjvojcGidrI7JxTpUWPdvdwhhv0aNo64zEXeVm0euLSLwokaIzRdr2UanYfccsPuvtYew5g9wHb2fLqQ9wDk0ju1D0CqHmi6qgyfP7ty9tSBoVtRXsPLqTqQlTyU7OBmjSIcBd5SbrtSw+Pv4xIsIVA65gzbfWhD2b6QrCNbZbM5Iw8R/4NjUIDlfN2dJRuweDLbVO+pcXURjt5N3t2pW3ri0RNtSSpZT9eiVls7OxG3q28vZbiqN73Gx4TjWYlYSaEYmAQ/QSvJKYSHqki5W/8YQlRPxnYtZEwaIRzUzVm0oNHw4N1igZmoa9wstxVUbeUMWwM4q8oYo7Uufp+i/LbLTMdHMzIv/9Ww5tYcfhHQzvOxzXIRfuKnezQZNGlEF6QjpGtIE9yk56YnqT66j0JCwbSTsTrpqzpep9wyHU3J3N757O5JzNYM4MnR/LN/LXKeGFZ57Ro5u5c2H2dxWRa3NIrnTx4bNOPHdm44jVJ2rSjuF3EeJ04hhoNBuK24MdTiw6gzAfkHC8s0LhE0SZ4zKwP72BPcu+Rt5QxZMTaqgY5WHcyHHMjXZgs9kgSjV6UQ1oMl7FP54lPSEdhSK/OB/nMCdAAyGUeVVmo+sQEbJTssm4KgMIYiPpwViqrQ6go9Q6vgEd1Hf6vndz4kTYvh3+9S9dbtw4yPmtmyO3LOIzTyJjjSLGvKX1Zz7Bs3p1E+914EU0c1EtVdWFdbGWbuz8od0fkKbPVb0gi9crPmbYGcWcWW5mXXULJ8+dZOWNK+s6eOX14vmyBKNvPGKzNW0IN/E35gMN/m+ro0B3xIoj6WQC+72OeEdEGto53G5w5SlGX+KhsMAgNVXYv1/vmzxZJ3UcM9fJyFwXkelOlN1gxeOKT7Z7SE43yMqW0DMi/4sIMppUSIPrbavDSYP7hzW9Oe/oSI+kwJfPMIicls7Y1/aRN1Jx1chxnDx3ssEsQylV58HlHOYka8L3eTpvBbknCrUguCwzqG42cMbk/392cjaZV2U2GTR5vmLNSNqBrlLrKK8iN2MVkdtyqZmSzvQNC3C74dknPWz/xGDqNCE7SwcqKrvBY49ByX/ncG1vF4eGObntrXpVV5MEjCbVEyvJ2ehot2j3Rvcvw40s7qTRq0Xn0ZYHJNTsGEKmXlBuN55osEcZlNeUN+jgGxjmvzzAikPj+OjlHE5dPYZTFafI9Iwialp6eKkfwrimcCLzuyOWsb0T8XggLw8GD9afdQb2MP2AVZkbd5kKWUwpnYWhrKxhVeJxk77/GaYY/yJ9/zPYPGVEr8/h6jWLuPWUuX56uaAMB0ePCat/5+GKMy4KShKZXOPCIEz3ygDPAA9GA/vK8eNBDOzhXLvf/Wtg98QKNDwvCcMDw6de8nr1SofK623oFRL43e0O7t0igsTG4oiJxWazNVJV+Rvm0/snE1vwMfZRSfTf+TlTi7xEDh+pg8Z8uuT6BtY/12H68Lcpe3EPwVJttQN2u04M+uKLkJpqBgCGM00xfdx3r3fhwknlnGyyF0iDYr5q1q/X3+fMgQUL6qsSIEJ0tK67xIO9oOH66Xa7g5wceOcdOHTK4INeTibVuLjkVifiCLODDvAMMNAeYXl5UFEB998P06b5XWILp2iNtB4OK9DwQsTfvbbGW0OERDCjfzLzXDsRn6C4+ebGUbNhqswCZwV1qqhIO/Lpar1c9O33EmOLRp59Vh+0YUP9Cxf4XGdk6P8TErTQycgImmsr0BssmCG+p2PNSNqB8nKIjIRbb9Wf5eU0zonl9jQeoHs81OS6+MyTyPhyF4W5nobuwkrhOe4md7PC49H15ubqOA/cbv3SzJ2LunIcuSPmsmjZQLbUOpkQV8SkpU7mLTUoL9fNGDMG4voLm/pl89dvruSiB1qof/MbTYroKPdx43TYyqlTATMx89pVQiLVufram6u6URyW5T98weHrcAc7BrO9eDuXxF5C7olCKlP9cvTExzecrTocDR4eBUFTrASbFfjsHWKz6eWiV66k1+J7kTvvhBEjYOZMVH4+7tPHdX2B77TXS8XVV6DeeksHa23YEHRW0sAtuYnsxa2mBbP/jsKakbQDwe2I9Rt9ObFc+QEDdMMgMt3J2H16RpKcbtTNmH0GZ8PlIluc/LtdH5Q+vT5YEKcTsrLw3JzJ2vvtXHpJOauKspj420xiB+mRvK9t69fDoEHw7W8L99/vwNb0Kp/NUl4On3wCl10Gu3bBkiV+g0Fz8ay6mdYGg+wFTcuEjnJQsOg5+LvXpg5N5UjZEaYmTCXm5iyYU14/Ow02W3U4Gsxokgcns2TyEu3qSxizAv8H0OGAGTNQLhe5Q2pY+94DOBOmkj0xC/G902lp5P7PAqK25jPqrCL+lgwkPx/ubLwuQ4PZT3vbSLqJ371lbG8ngtrczI1uZbBosQS3HSulZyvK4LkNwpYtOgXLgsx6g7MqKqLs4ZV4xMFAexm2hdkwcqReTGflSpTdYHNGDu6/u/ikj5O+DzZUkZWV6RnEqFF1hzRYGiFQldbSCP7kZC1I/DNfu8sUP8jyMGiUQdFB6Rb2csujuPvjUz/ZI+2NDOQhDqj7Ud3VHha9vogTnlIOHf6MBSkLWPSVB+tce0MJmVD1uk8fZ+E/7ueSPkM4UnaEJ7/xJI4o/eK4K8v44N+mUTNkMMPe30XihGuI+sq1nd+Rd7BbtWVs72T8NTF1M030Rl9OrKC2YxEkVh/47LM6DuSZZ8CtGhqcn3/FzkM/KGNL9gbUvn3w9tsN0vEO2ONiX00iKVWNVWTmAIuDB/UhOnixsY2wJVmOfeqtRx5pLERA2zmSZzgoOijdwl7eaRmJLZqlqQy/PnVTMAN5QCV6hOT3oxqRdpIHTWTiq+/zpzVf8rWFj1K5cjmYaqysiVlMHDyRgiMFrNixgtra2nqDfqBqSAR733hq8fLipy9Sq2p1Ti3zRTcuHog3LZXIw0c5/O2ZRK5Z2zWzgW6SAduakbQzoWaagaNhr1cvuhYfDzZRlB3zMOtmA0+5Vke99RbEOvRBZbV2/jhzNZPKN2OU7Cdh7rVEF+/TEYWxsbjLFH+amUNCsYv3Kp0M+K9slt7b2GjvC0QsKYEHH2w8iPGfuXzxhW7nyJHBc3WFc53QfWYAnRkPZxGa9sjwW/fwbd4M+/fDzJl1U22v18vuW6+h9659GFEGcZPSkTVrwOGoc/k9UX6Cz0o/4+qBVxNji2Z+oZcZh6OImj4D8RMGvvKDHYM56j7aIJgRGgc0NnXNHer624FTbWtG0kWEyrXlP2PxerWKd+pUyJitOPd4DsaDi/j1qByuvEJxxx1mRyzadfcPT5cz+ICLwtOjcDggqni/nmI4HCgFXiWcvSObF6atpP//y2bJUmn0PPmCBlevhgcegJqahoMYpWDjBsWxvW7efksxfTpMn64nPsHsiMGuM3DUD93HXt5NBm7nF60w8rY1wy+gz7l5Mwwdqs+9bx84nSi7nfIYYczN8xkyaDRx/Ych6el1P7YRZZA8OJnPT3xOTGQMb+x5g9zP3qTkrVd49vR77H5tPcp3PW43RqQd5zAnR91HgxrJxWbD0W9Qs0Kkw11/u4FjimVsb2d8C0GZSXiDdlglJTqdyeDBkP+2h+35LmKvSGR6nIt/jc9k204Hq1frUb7HA1t2Gnw7xcmln7u4aOkcZF6GFjIKVuVoVZhSwne/62DpUq1mCjZI8cW7XHIJHD4Mj/xaMdDhQTBwuyF6fQ6PnnPxQW8nt2fqbKbb3vYwcKSByyUN7IjBHAy684KFLc1tZtEMrTTyBlt/PdiIPeQoXinUc8/hzXdh85QjM2fCqlV4DYMVO1ZQeLQQZ8oUsm9+FXE4UOZMBHQU+pLJS6ioqeCJHU9gs9k45nWTN0z42vFytoyv5ZJIL1ErlxOzvRBxOsnOymqTkfxCcP0Fa0bSriilR/wFBTr3lW8hqEDi43W8yeHDIA6DLy93Ur6riLJxTrZ9bDQY5RsGOKcKL8VlsW/BI/RakgXPPw+LF1O5Iofc97yoMjflHsWOHdqbKpQ9wD/exVuriH85B8nOgpwc7F43l5a4cBUnMuaEC0O5MTbmMG/nIqLX5VBboxoskBXMZbe7j/q7wcDt/KGVq/kFZvgFGo7YvV5UWRk5BasajeKVUpSdOsaeV9dxWJ3hVGwkClAiLH9/Bcu3L+eEp5SYp5+l5sH7Uc8/32j9DxHhAecDLJ68GCPSoE9MH55J7cVvZ4+k+u67+OOOdby/aTk7o06gXC6kvLxNyRUDMxIblardDXQdvapkOHS7GYmIXA88DkQATymlHg7Ynw48BlwF3KGUerHzWxkc37s1fHj9QlDBRuQ2m1YVHT8Or7wMr+dmkHpPBlOXOnCukQajfBHIzlLMrVxNTKELeSJZS6rhw4kucJFVVUH58Z18HOuk7/RsDENCzgz8411OFbnxrluPrcID+/ZR/q3Z7I13MqWXi4/7OJlYDjFbXJxyJHKL4WIVmZSXOxpcT6DLrjXqv4BoQ+4s/3xV7ip3/Yj9YB5zt1cSkb+dGMc+Em+bWTeKN6IMcgpWse3zt7msfwmzexuc9lZhTE2lJhoKjxSSFDeGE/s/ZUrRACKTR1KzNZftjmo8VR5EhNyiXO68+k4c0Q4ecD5AdEQ02w5tI3VoKvMnzkdEWPz6IgaMT4IPd1F523XE2O14qtytnpH4ZyQ21m1EVixuVzfddrE5tQPdakYiIhHAE8DXgcuB74rI5QHFDgJzgec7t3XNUzciP6BIn+jGsIceIdhsMGigYm5VDk/IYub13ogZF9VogTQp99Cr0IUMHly37q0qKsJVkUzkPwvpPzGRH05xkZ3paTgzCGiHb/vRozqpI5ieZbW12O3w9shs7q5Yydsjs7HHO3SMi1HERw4d4xJOX2GN+i8QgkaRBqdR2hO/kXNgqpKY7YVEDh+J8xAcO/4FzqFOfXxlGTFrn+HeZ/eACD/98RTeW/NjYhYtxYh2MHWYk1u3nGK9awBJfUcjRUVETksndcxXg67/YbPZuDf1Xh6/4XHum3IffXr10TaUS1L4c3ocu36+hOgF95CzczUL/28hj297nLMVZxuO+puyEfntExEc1dJo/ZP2oF1sTu1At/LaEpE0YJlS6jrz+38CKKX+J0jZ9cD/hTMj6VSvLa+ickWOnj2EGHn4nrE/POXmst8vwp6UyMT+RUgoVyKfdX77dq0Te+453KXnWHS/nW+fXE2/z11MutdJ73kZdb248ioqlucQsd1F1AxnnTeKz2vy6bWKi154khuOryN+kI3K797F9wuyuWSIcOQIPPkkOAwd4+JBL+sbrK+wYjMsmiJY2hPfioKN7CGRdsRc20A5nbjnzmbDxxvJL85ner8JpD/yR3OlQzuXPPuKNnT76igro2ZhNpHDRyIHD2q/9IED6yLdoWFq+AarHQ5N46akm3jl81fIL84n+ZJklk5eSnlNOQv/byEnyk9QcPh9xvZO4LtT5rNg0kK9PE8oG5GpW1YuF5WpycQsXKLP2wGBgx09I+mpXltDgEN+34vNbS1GRLJEpEBECkpLS9ulcWGd1zd7CDHy8NkvsrNh7R8MTo7R9pGzV+o070EHOeXlEBGhdVIREXDuHMZAB85pNh4+lc1P455g+zaFysquN4p4PBz8g4s3Pklk9/qGaUqefhoeXy68dtGdfCGj8aTNIrrQxYwUD0ePam8yn9eYxDpwxIYWIlZshkVTBEt7EjhyFhEcUQZSXq4NiytXItnZiM1GfnG+XpHw5E4GzrqFG3pdyZhv3kWsnxABEIeDqGnpWog4nTBwoJnOR4iNiSU2JrZBeV+7Evok8IjrEdKeTuM3rt+Q0CeBnUd31gVDJl+SzOcnPuPuHdX8+7P7iHrqaTxV7qZtRB4PyuViZ9QJ3t+0nLVbl6Og1euxNxd305ZVJduL7mYjCXYXWtU9KaVWA6tBz0ja0qgW0Yzu2Pf86fgM4Y8XZdNrQgYRhZC8CiqrtH0lMJUKU6fqA81eXkTniNu8WRg7FIaufwbvAA9q7z7Kv5mBRxzkKScTRKcpGYKBQyncxzy88LxBZaWQu9PBdYnp1L7mwpvq5O4lBnecC3920Z29tCw6jpbERYRKe9LAlTaEB5j/sTWqliXDPmbGxFTmTQvixdJCA52v7nf3v0tZZRlJ/ZLYfWo3u07uYuaomXXXtnTyUqI8FaQv/29iqmpJdp3UBvNYR+j33DCoTE2mfNPjnL1iNLmlBdxR7dF2oRa+IOHMONqyqmR70SrVloj0A3oDJ5RSle3WmPNAtQU0qe8JfGdu+pbizVtymHDOxZtnnKyRbMZeLvSPU6z8jcdc5jZIRKNfXYXvlfGLbbOIrC7nyJd27uj3FvaBsVw6SuHAzZQpMG+pgaxZTdVmF4+6nDzvyCY6Rkgao7g80cOeIwYrn5QGz3lzwYVtSfPT6HIsHVmPIFxVitfrpaS8hHh7PCKi055E9Kb8TGnjAL4mokWVUhz3HOeBv93PmF5D2FN5hJXfeLJFHWco92Kf3WbB6wvYUbyd9LhkHr/1KWJ79UFE6o7rXV5DzayvEnmuEltvO/LOO9CnT5MBiaq2lq0P3gEFhXidU0j/5YYm401C0WDdlDNFjYIiO5p2XSFRRAahDdzXA5OBGL99h4Bc4AXgr6ptRpf3gdEiMgI4DNwBzG5DfV1DExkIAwdOuD1MFRf/qk3kao+L8eMz2PsvxYMTn8Z4YCdMre+hleFo0Nf66vJkOIh4ag7v/SKXv9aks+eoA6NMT+/eum0jF33gQlZMRBUU8q8Tg5lYtpm/9svg9nmxREQILpcD59SGgyp/IZGWps8VKDBa66XVSABlKWR11yees2iecOIivF4vmS9nsr14O6lDU9lwywadoyonB4fP/nFXBobPZmHO4utsCnZ7nWpCRIjvPYC5OyqJ3r6J6VNSUTd4dfZepfzSQwR05H45u1YHrITo+bKEDXtfJrd4C6mXpPLk11fCmtX0+fsn2Dwv6CzC/rad2mpmTojkxq0nibc5YONGvFlZLH9/BYVHCrXNZ2KWVs2ZL4KcO8e00t5UT72NqOKjel8rpuvB4m66I03OSERkKPALdGdeBuQDHwClwDmgHzACSAWuBoqAnyilNra6QSI3oN17I4CnlVK/FJGfAwVKqb+IyCTgZeBioAI4ppS6oqk6u/Wa7eaaJNWbXbhUGvv2wQ1Hnyb+3AG8E1OIGDgAeXIlXruD5ct1oOPUqY372rKzim9+1cOuYoPSE8KAAXDpIDd/u3QRvZMSkQP7qfJUUvHme1T3cvDyqAe4/R8LccRK0Lb6DxL37tXxJ2PGwMGigJlSK2g0AH3EjeNBK39JTyCcGckx9zGmrp3KIMcgjpQdwTXPxWCJhUWLUAkJ7P7gbR7NGEHymBl1xyuvl7Vbl7O5tIDkISksnbwUm5lsce2Wx0l6aAXRI0bR9/gZHs0cSfKl08l+bCvic0DZsAH81l3f+NFGXMU6QWPBkQKG9x3OgdP7mbujishtO3gz/gzrU6Jx13qYaIxhzd+jGTNhpraxrFyJO0rxgz9n0a//MF787M/MHv5Nrn/0VSZNu42ow8d4cu6V/PbjHJL6JxHXqx9rjk2i1/bC+oEQtJtxvStXV2wvY/suoC9wMzBQKfVNpdRDSqkVSqmnlFKPKKUWKqUmAolADvCIiDzQ2oYrpd5QSo1RSo1SSv3S3PaQUuov5v/vK6WGKqUMpVRcc0Kks2nKAB3UkC6CZGcTtXolyf+bSWbiFgb2OYenJppTrs/Jq0jG29tgxQpYsQJOnjTX/nA3rMwRK3znbgdpTuHmm2HIECg+bfD4+052v1XEuXEpRMZEUt23Px4cpNu24BBPvbsuDevzRegfOKCbWVQEb7+lmFer07mQk4PyqlYtg+AfuJicDPYB3TyS0aKOcIy78fZ4Jg+ZzK6Tu0Dglc9fQdnt4HRSc2AfrmEwaOCoBkZ3T005m08UUlp+gt/l/47Htz1e14Hmnijk1PgkKvfvYctQL4PiR7J7x1+pyduKGjRIezOWlNQJuazXslj7wVoSYofxyb5tJA+ayN7Te5kQO4bo7QUU97Vx5Z6zVLu/pLa2lhO2c2wZWkvNgX11WU2NdRu5f+N+Lnspl9QhkzlQc4KaaWlEHT5GxeSJbDm1kzFxY9h1YhdTLh5HzPbChob3cN2jw0gzU7duSjeepTen2pqqlPownIqUUsXAr0XkMWB4WxvWUwllgA5U52RlaWcs3WeKXgM9TzEvMp2p9n0cizDYNekO/hSzhEtLhcJCSEqCzz/XqiD7czlUb3UROT0NycgABJs46NVLmDRJt6WiQnhBsnmzOpMhhb352f7tXFpzgr4XObDdlV6/QmJA41RWNqtXC++/r2chu3fDrFlQ/LmHNKU90pTLxdqKTHJ3Olo84BLR119RocNiVq8RsrOyESuSsUfQwLgbZPptEyHnmt8y33svY+KSyC/O14GA2dlEZmRQ+fkGiorzG6hqjCiDCYMm8JP3foJSiuU7ljNv4jxiY2JxJkzlz+l5pN9yL9UxkYzOWceULfupOOkm4swpes/6OjJgQJ3a7cuKL9l/eh/2dRu4/8tBHBmn2DhiL1+c2ItxaV8G/HM3/0wagLJXMiAmlj69LqJm3hwix5ovq8eDuFyMmTCTkQf2MedrqyiPEYxZurNf//kG9n90ABTcM/ke7hx/N+x+obFqrgkVd9296wZribQHTQqScIVIwDGV6JnMBYV/dt1gzhw+AZOQAJvfU9Se8bD9EwPnVKlbsTNxuLD2QDYTX81g8x/RnfRUqVsULi8PUlJg104PudtdnLQnMNX1DPFrn6ZaRRATOYdRsxbwwQfCtGlQXAy1tUKlzcHY4W6OF0QyPPMuoo8dhDsz6434x4/ryocPB5cLz82Z5OU5OHVKL4iVnKzVWzO+ahBl0xdXOdHJtnzF4ERFXp602GOrvFx7pyUm+lYpFWJjLXVWjyJYRwiQk0Osy8XiIVGsnVSE0+elJXod9eyUBWRefWcDVY2IcMeVd/DLLb/EhqDKyvBUuenTq0+DJXFZvpyad0uoLC3DhuCJrCWKWqLWrMHIyiJ5cDLLty9netxEphbv4ZLUNI7nv4ptoJ3yGBvvzhpLhPMS9hT/k2tHTGXNt9YSERHRcMRvTpnF5SJqWjo4HDjM+JaKq68kf/hHzBwxk72n9iIi3PPXJaRNnELU2InknnifKe89yoIZP8IWEWHephCqqfPI7bG7xZH0SPzVWatX17nCNxhg+NQ5b7+lGJefw/DfLOLbJ3Jw5Wn1kE+zk+YUiI3l7ntjWfmkkJ2t7YhZWbBsGURFwf4Sg02Hnci+vZwuqeLEoXKOfVHO6GO5HPvCg9MJS5fqVPTvvANz58LeowbeKVOJOnUMrrmm4TTpwQe1EeTAAXA6MeINkpP1yodJSTpDd20tiE0gKxueeILoaMX3diwm6unGebjCoe5+hMgubNEDCBZLYW6TxETSD0ey8prfNFKBNVDV+Kl2BjkGcd3Ir/H9QsWzb8fS95k/4a2t1SlKKhXi8UBhIUcG2omsqsETpTCqbUQOH6XPWV7OkslLWJK6BMfFA/WzfPQk3rQpYBj0iuzFlCGpLF73CW8+WcZ9TxQSabMRGxOLUopj7mN4vd7GainfetUnThCzMofvuyo5eKaIKcOmsPPoThIvSiT34BbeKd3GpNc/ZNC//4J//PgOnTfMP/tvQQ5llWX18SDdPTldC2iXOBIR+S+04f4X7VFfTyOcgYUv7mPb2x6+5nbxUU0il37uIiIlkwcf1Oqh3/++Lh9jozU+Vq/Wk4bPPoPPPhPybVk4pIJL2Y/XfRq5KJ7dA9P5xf8aDBykj4uN1cdmZkJmpuAwshFPRqOGq4REar4oIvKRR5BBA7X//FJdx7ZtcPq0Fij62gSHCLVb85vMw9Uc9XEwev2TEKuUdjyW23HrCRUzZW4Tp1N36E3ZB/xmNLbsbDZcl0PFS/P4dJSbgj8v5+m+W0nPK8Z5CMZ8Yw6VqckcPLiVL9OSKKtxMzlhCnL8OMrp1IJFhHtT79UzgFvsSHk56b178933V7D98Hb6llVz5T4PR/tGceU+D8ZpD96BjkZeZjabrWGq6+RkWL4cSUpiWkkvJlzzG+x94+s8wtIT0/GWnWXwx69TOWQg0dsL8XxZAg4HroN5XBo9mPUfrmNz0WZmDK93MjhfktO1V0DiMrS36QUpSMLNX2cYUBlp8NIxJ9fFuhiX7aTmE4Phw3VHesstwQWS263VP0OHwpYtMGwYHNtbzlW2neweM4tevfeyauh/M+a6kQwcJPgP9DZsoG753uwsYOPGBoaaBmurvzJQL9GLngUtXQp3363ryM93iLwAACAASURBVM9vuB594FrzrRlM+VZubEXev/bhPNJRdwmhOsJwO0e/EZhyufB852aMvvHYpk3j3KbllF49moIjBdzzhYPPLhJG5m0h+okn+ejySrad+ogZ8ZNwOu+h7EwpG794Bdcbi+uW0bVH2jluxrGU15Sz8+hOLr34Uv5x+hMypl/D6O3vI2kpePraKfMcZ3vxdgbH6uj7457jdTagupnTkiXaw7KwkMopKXWxI/5rsSuvl398tYDo7YV406Zg9I0HYN77tUj+JqKHgXtOfSJK37K9PV2IQDvl2hKRBLOuorY3qf3psjXbAygrg2uv1a66A+we/vCawV9ekwYGeFMVizNNkZ2pK1yVI6xfr00ZPgERFeFlqSxnevQ2UlMFiYoi0syppRBycuAf/9AzCsPQs5O3XnbT+/5FRI5MRA5qN1u3MppcW913PpTCIbo9nnLRiSA9Tefhaq/71mFYyyZ2LX45qXKH1LB2UgTOhKlkTfg+T+etYHNpAbWqlllv78d5CEbf+D2evqKS3JM7Sb4khXsm3cOaD9aw+cBm9p/ez8W9L2b3yd0snrSYgiMFbD+sZxjP3fwcaz5Yo12WhzrJuOIOjOWr2JP7Mq4EoeLu75F7cAs7Du9g8pDJTE+YzrMfPQvAHVfcwdJU0xW5tpZn3nqUd9wfkTx0Up2Lsr4UFTzo0u3Gu3AhnsFxHP4kn99mjtRuzxOz6vKKdedBTLsGJDaHUupge9TTk2nOQQP0e1NaCqdPCyURDn74Iz0if+KJ+oy52dmQmaEwNuYgi11UJDvJL8hmxgxh0x+9zP16Ca/vGMAtJ1bzjZMvMCiumqhDUXqBH221xiOx5OVpV+HDh7VdZeBAeOoFgz57nEz/wsWYu5yIYWCg11YPNiuoG7Dnabff6REuttQ6WWvLIj2lnHlLDRy2luQMaiw0gt23ThMubUiFbtEOmA+85zs3s/a9B0jsOxzXIRcZ4zK4PXUetzMPI8qg/JsejEpF5bNPk/TT3zNgfBJ/Ti+g9FwprkMuRl08ir2n9vL5ic8ZO2AseYfy2HlsJ0Nih7C9eDul50rJTs4mY1wGGz7awA9fWcgPc/fyuf0c4/fZWLl3CznfzqG8phx7pJ0Fry/AU+Xh1LlTPLb9MSprK3kg7X4qn1zByE2rODvSzuNX5yMIS1OXApBTkEPuwVzSE9LJTvFLSGm3s2VoLbb81/BOSeV/v70KR0ystvfUed9s1npe/7WsexiWsb2NhHIDD7ZdUAzv72bwIIWgGDXQTb5L1UWJg/408FCzOQ81aDAxBXmkJ3s4etjLcyqDhc+lsVHdzv2TNnPFiHPEOap0duC//73Oam3YVZ2nld2uBUnfvvDCH4TlFdks8K7EPTvbTGoX3N1dKTh2VLHtbTcJ/dzYtrso75+IbVset5euIGnFIipXBMnU6Hfh/vcg3ASPnZoIMlxff4uOQwSjbzzp/ZMp+vIAzqFONny0gcVvLGbjRxsQj85RJTYbMTt2Yh+VRL8Pd5HeP5l4ezzOYU4Onj3I3ePvZmnqUuJ6x3HtiGtJG5LG0bKjpA5NrUvTIiK4Drno138Y+cNsjHbH8OFIO8mj04mNiWWQYxCxMbFMT5hOdEQ0lbWVeh2U91fx1F9/SdEbL7DbUcHAj77gKmMU24q34a5y465ys/6f6/n4+Mes/+f6umzDoONj1k6K4L0HbmXt5AjEZquP5k9L094m+/drlXMP9jYJe0YiIk83U0Qppea1sT09ilAqduVVrF3uIbdQu/dmZ2sh4ng+h1U2F38+58StFM6N+cR8xYm9dza+fJVKQc5zdq7aVssVb71I76+kcvdcL7ffcIyICW9RVWNj6O73iLztfkoKD3C2DI5/5Q6mRW5DLr0U8vORO+9k6VK9nvvjj2uV2ujRWnujEM5FOMAXgGhol8S6WYHSqeNznrNz+pHVXH/UxfsRaey63MnUEy5ITqZPYSH2yxKJKXSBx8+zwO+GKKeTHJWNK19wOql3cW7G07HTPSLDmUpadBxKIatXM8+1k8zUFKpvmM3iN+8hsU8CMWufoaYsl6hJqdpG4fz/7J15WFRXtvZ/u6qgoE4hDgyCTALOM6BIoUVMNEMPiZkTwSEaKaOt3vSQ7vvde7/vdufe7k7S6QxEIyQak2CGjhm700k0rRGkEKUwTnFGQRRFFJWqYqza3x+nKAZRwRijie/z8KDUqVP77Dpnr73Wete7TIzI/wrXzzOZkLoQodGQmZDJ1MFTCfYLwnn2JIyZg1EfwLykeV6tr5bwk5/Q4zp3lr+V5ROUEMTGCXGMjE9hUUviu83OJ75XPGHGMLZXbuOXOxUGfbicajck+Afx+WBfKtw1aGtqWb51OY+MegSg04JBxUfBFJWqhtU8NGgvHTg9HZGfryq4Xuf03+6Etm7mfCXe3kAAcMbz86NCp4ueovYjGZRlJXiQifcLLCrTCbXIKSYtmrR381D6Sopr4hlYbGVFVgZzFhsRQj2nLd9JslHLp86fk7SuEKZYiLx3HLUiACM12EUvzt0zj0fem8lpfwVRprD+PoH/rtZG8RoBc+ao4+rXTw1zTZsGmzeDeaJq1M63gKohaM6z4rcngaE1JeyR0Uz0KeTDqCU89EwGE4INNLyU09pvpW04qM2ENOdZsckMouPVsFl6etcJCTeiTT9stKuraEMX9iuyoZ8xG1OkCdu+DWSUS3TyDGRlIYHsFB+UzQcZt+4QA5VAZGYmOSU5FJRtJG3NXgbtPY07JRnz/6qsq1Al1Ps5bpeLVx4by09tO4kf2Jv3x1QRFDOJoqObcTTaCWgEVqygubgIP+MhzqX2ZPPRLfg3uOi7o4rq/nEMcxh56f4oYgelEHNU9UayirJAwoyRM8gvzye5X3I7PSxvh0RPQh5olZiJSMFiNqsNr67zm73LhkRKGdPZ3z2tb5cB6Z29/kNGp4uew4HeZsUwKBr2WjEvzEBRjIB6sK/VSrPJTPF+SdjJQk4PNpFnU3jIoRohRTpInOCPw9rMTWc+RO8nyHdOJubrEvbevhjdZisNpptI/uxtflFRSLGPCb3TjXZzIXJCMo5pmSgIkKq3vGULrFsHt96qburq6kCRDsSCVgvonpZBldNIsL8Dd54VXWw0KQdsvK1NYoDbxmadieRbjCihaihMv9CCoyoDJaRDgVWbCdFNTCG5XrJus8Scpno8XSHztMsT4UCg0Hl3gRu41nEh1d12Wl0JmeqGxPMQCaMRS6IFx4h0lKrliKwsGDSI5uIidvZoYk5FA7t7SGI35tHwwFSsR6zE+ATTu+RjGgYMR19Y5FXkXZ7/IutOFjEx2ozzVBWhxTs4HCj5qbWayRXhFOx8j7yJwWz799mk5h9WuyomJZF8qpmnonei1Wqp1TWxe0AvbjleR/R9mfxp2mxyt6/i8JnDHD5zmKTwJGyVNpb8ZAmN7kZsx2zklOS0q525YGvhikIyHlmCMf36Xzq/dbJdSpknhHgOyAImfPshXT9oy340GDwJYoOCMJlIsFppuM3EhIWKZ9FUDxYZGZgNCgl2eGf5dPJL1PCXYlC9AWG1YhmTgCvoIGcajTSfdTDUvxSdOQ1b3Vx2Nz/E2HEGzCW/oO/YaCbv2kA8B/DZ38CJksP8V9GjJN4UQHq6mntvbFSLCffsUcfXowcgWxd8d4qJ9LkGthXaUYINPKYzkVpqJWpaKnsLM2nq62TfEQO/u1td1KUUZOd4FIM7kk1aJiQ9HXJXMfGdBeA20TRRDd11KYokJcJux9iWc3wjf3Hd4ULijm0bSm04vIH0EekEZGbC1Kmqiq9Q6edGfQDeYiabDZ3JxPDhbr6OrWB8uQvtLRNReqo5koKyjUQnDCZ4bxXulGSUwGDql75I2Fv/y6BoH1bctJ/IHpFExvgw/mAjOo2OISn3wJa/M6rYyMCPPkfqjAgfH9izh+q7E6nTV+Goc+Cn8+OzSZGEDLiPCWkLcbnqKDxayK2xt7KmdA2B+kBSo1IRQlBSWUKMhzDQmSoyXEDN97Vrn711KVypOpJSYMwVOtd1hZa8WWuupFU3yq9j8w4PFUkIQUAPePTfjDzcwk5qExYSm4vQaSR9gjS4IkLp88Ff+d8VodRn5XC/3sqRShOND6cwxlZI7ZxklE9KcTsl586p7KyWUFJysprLk1KtTn/1VXj8cdoVQp04ayD81znc1Wwl/5iJ7fMzKTyZwV9nK5j1gtdXKkytyqbyHisBs0w40i1YreLCOQwPc6A538puZzRjpJVl+Rk4ZnShYLElx5KXpxIHJk++7mPHP1ZcSG5e8VFIiUjh9W2vA7BqWy6WErVHQUtbWjwGR/FREIsWIe12HL4wV2cgy9XAs6VFJA0ES5uwkWFqG9qt04l2UxEnevsyptTJehOkRk3ghYnFfDC6lv97NI4xJ2rQJCURsKWYuvhoxP4TEBNDw8P383JkCYHVPVH0Rgb2Hkhyv2Q2Ve9EW5JD5qB0TBEpWCsKmTNmDukj070GwxRpoqC8gMTwRAy6zqUeOoa6xA9EJuVbGxIhhA61V0nFtx7NdYrz7wWBse3N4Har0r02W7tdR7sdets4mdmMnGim+at8tDeZefDxvmz4p4OXpJXdzdFMdlvxnfUSr9ffTfb7wdxV7cdEmcc/pZmcXCNTblVPt2iRKoz49NPg5wfvvAMPPwx9+3qMidGI4aydsc1WDjZFY9JY+aIiA9OtRowB6j29eZ2D2+qs7HZEE5tnRUnPwGTqnC7shaKgnZBCUEEeH9rNNA+WGPwlIC5O7W3fPhIOHlT50YpyowD9OkPLzrvjwiqEIGNkBvnl+cT2jMV2II+6Dc1842+n7r0X2TPcjcvgj7XC0z8kIZOcvauwHlEl4W3HbAwI9HgzIzMI0AeoC7mUKD6KaoAMCj6pZiZ8tJ+8UfDAuEdocDei1ekYEDeOvBEhPDzpGVIDg2lY9hL6TcWIBxJgzhz0RiNmWzalZw5z3HmcitoKKvdWMqX/ZPTLX8dlz8OSlEzGvJdQOrTvzUzIpKG5AVvl+eGttmgnevkDSQp2h7W1rpM/+wIDgT7AvCs1qOsNF70XpIQXX1QNiUdnRKZn4BBG76KoLpICxePJSIOidj7UTmdArcKWYoE0KKw/beL+ICuDHjHRuHIVcdmF/KQhhfeN6bxZl44MMdJXpy7WTqeac5k/w8H7qxWcTnCccPDLxxXSbhJeD1oToHAozMSwGisHAhN5KstA3/BWT2t0qsLXR0yYsKIzmxBGpUu5jsZGgUbAvSF52G1WGl9KRb/Q4gmLXcCLbzuRs2apbpXR6C2wvM69/x8NWnIjc8fM7XRhNfoaMUeb1aZRvvBWwGHCdh6maVwS66qKEBoNcb1Umfmpg+7Ctm8D0aFx2I4VM7OogYaNr+EbZ2RVdC5zEzM56awi5M0P2f/pG1gjoWH2DCwIBvQeQNTIZJpGTWf+p/MZYxzAtur9TB012Vsw6Dd/Ecxss0ORkvQR6ZytP0u2LZsg/yBO153m8NFdZJRLcJ+CrCyMAIsXt7tuZ7OT4mPFhAeEU1BecMHwVjv8QGRSuuORaDiftVULfAC8I6X86koN6npD29TAefAIzTFoEOzdi7z1NrJzFayFnVSzmwQWi9oF0VoI0fFGduyE0aNh7VrB+gEWGkdnMHaqRP+rBRgGRTE1/3XG1udzNM5MDhYkqhxKS84lwGrlmQEmdu+SRNoLaT5r4oMWJplR7WPS8zeZnFlez891xfT9ew7CYsHtgmXPOijerpD4oIWwBzOgr9Iaw77Y8+FwoC+x4j8winDrasrH3YdvsRVHVQZWq5HoKIltgwNHuoIxoM2Dc4GHymH/QXj/Pwq0zY0khCVQUlnSPh/i2cVbEi1MHTyV36z5DYcfuJVVI9fQNzQQc0waAqF6JP1SCFz5Lr/6rJSNEQeImvYw5qNb+Ed4CLcd17Jk/wb+dXgdew4Xk/Wpm5rgAEaXali+cx11+Rr84wbit7kE/YzZqkyJdR999IEMtW1H7Mvx7kjcBgNVjhME+wfzytZXyCvLo7SmlMFBg9lbvZfE8ESahYZNIU30+qyQ+rhoomw2NSzV5kb01/pT31zPe9+8R2JYIv5a/65N2g+Agt7lgkQp5U1Sykkdfu6QUs77MRuRtli1ShVcbFdIpyhqS8M+fWDhQhyzF2ItbM0xVFWdL6DaVhQ0NVXtBTJ4MAT2VKvQcz8y8sYBEwHVBwkKAmffWFKklRn3OoiPB42QNB05zsnPNlMXHE34/g3EHVnHwaYofLZYMSc6vF6TEDBvhpP0wSUMvDUGYbUia+2sfyibvn+YT6Itm7feAsuvjGTniK7VTCkq4WBUaCWnByVTf/gY+S4ThmAFU4ok9stsfn1oPsqqTioOWx6qNjuz61YktbkZzp5V2Q4/ErTNjdiO2Ujom8CXh77k0JlDrNq+yqt8K4QgVAklNSqV8tojPJg8h5w7X2Fe0jwyEzN5avJTaB11lLz7PNv1NQz+pgohQTfBzLC6AL6OMzAwagy2ShuBfcJZG+rwFhieDtDxTkAZu0u+wJ2SAkDY9lIO+9cT+PVetokqpOdhc7lcPLj6QUzLTTz0/kMUlBcQG9gf/zoXis7ArNGz8NP5Ed0zhidH1VAwNYFyHwfnkkaozbo8kFKStSULW6UNP60ftkobWVuyuBISVF1CFxpkfZe4Ilpb1zquhtZWO9mmw23a0ba8CJ2Gadp7JO1LOhwOtbjxlxYHvSIUjlQInn0W7rkHnHY3YZoT3O/zETHHC1lXb+KLaAsRkVC85jSV9b3Q0UwzOqI0FcyWrzJZfsn6ftNZuGsePQLVhdrthqoTkpCPstEUqoWEVZPT2TtlAd/YowmoKeN/wpZy93Qjhw6pY72kkoPnprbbYf5vFAb0c7L/mMLSlwWKtNNsaa/31ZXd2HWTI2logPfeg6eegl27VFmBpiYYNgx++1u4/37Q67/vUbbiCk9sR7bWtOHTmPfpPGJ7xlJ+rpylP13aLtzTkSLc8v4Nh75i5IeF3L7xOL3PNnI60Jfi24bz0IvrUJoEVcJBkH8wMz6eoar29hvHm1OWcVLj5Ndf/Jra05WU1pTyqPnfmD1mNu8uuoWQbQeQ0oWP0pPxdz5Gz9nz+cv2ZTyZ/z+EKqG4pIvHkuYRnPshcbtPsDHCzUfmEOL6xKMVWr45+Q01daeJ1PYmut9QUqMneMN19kY7j/3jMaocVd5rD1FCePlnL186vPXtJ/07Ex+9qlpbQohIVKP0o9Xc8ob3C1ra0Xq+VCnb0Vg7i950YD8Cno25InEvy2b6Jitrak2IKRYURbUy957OIanRinZCCo+fWoIx0si2YsG2bRKXuw8ATfgCUOaO4s/8jud4nNmNn6htdRG43S0V5wJTioXc7AxeeUvB+ntI7WUi5KSV8gEmegQorFmjjik3t7VFQ6drT5ubWjGZMKVasBYaMaV6jkfBx9z95OJ14f1v3gx33KFyrls2D42N6u+dO+Gxx9S4+uef421j+X3iO1iAhBCt1eb+wTibnZijzN7kedtivZbj2y60LR7NYL9Ihu//HL2zkbBasOsa6fv1Qd4uWo5L8afQ02HxzalvcrLuJMH+wdS56gjWBDPxi90Yi7dzOLYPm/oXMm1EOhvvGMbqqJ04XPVosCPP/h/i//gkaQ1hRMZHcORcBbfH384vh1uoq9nEv3qeYfiB43ycZMTdy83Q0KEUlBfQv3csh2oOMT4gnLyyPNJHqKwtKSWmCBMbyjZwW9xt+On8SG1p6PVd4xpgfl0p9d8mz7muFJ34iuJqeCTg2dydsKM8MR8RHa2yjqSE+PgLqste9Fm222nKnM8/tkcTRRkvD1/Kc68YeXe5nYEvzEcZEs2YPmX8SllG1quGLkVQDDhZ//gnjHv2QY5VCgYOVDfMPj6wdSs8+aR6Px4+JEkY5GDrPoWEREHumxJNnQNhVHh4mqCk5AJrTwdFXblkaTtiQetEdW0XfN14Ilu2wKRJ6mAvBUVRpZm/b2PyHagft/VImt3NaIUWU6TJm3i+aN9xKZF2O9m7c1m5bSUPfVbB3E8rcWolfi5Ydkcwf7sjirje8QzoM4Cys2Us/elSVQ/L85njA4cz/Pcv4z5ZReRxJ3+6w8jbw9xo0GBvsp/3kQaXBpePjrmJmTx363O8WpLDiF89Tdy+arbG6Pn9nDgeHPEwJZUlnKo7xZ6Te0gMT+TI2SMg1Ip2jdBQcKSAZnczCDBHmbt2vReZw047Kl5k3r5vj+RKiTY+yY+0F0lbCAHGUDU/QFmZmvU2m5FlZdQnmpCGDrsTKXGcsGMtkN7NhN3eJtSpqH0/hhrL2G5U+35ICffPUhg5z8SYPmX8q3ECS1/z73IY3omBO5b8jIbTDpUyKe0IpFdYMSXFk5uZIFj8H0aWviyY/Yjk3lPZ/Mex+dx1IpuiTbJdTqcdOiQ0hFHpmPLoNA/SGa6qgOO3QUMD3H5714wIqMfdfrv6vu8T30HyqcWjCDOqvT3CA8IprCj0iia2QEpJbUNta8dAz5ctFixg5uYG+vfsT/W8GewYE0GPoDC2DAnkjZv7oNXoGBc+lsNHdzE+PBkpJfZGOwXlBfTx74P19DYaRg0j5kQDnw3Wkhtrx9nk7NSIADi1bhrcjbz29WsUVBRgO5CPn6/CpvERpPWfxNp7P2Zx8mJSo1IJMgSxePxiXv35q/Tv1Z/J/SeTX55PXnke4QHhbD66mageUZ1eb1fRrqOiLbtrOZZrQHz0Ro7ku4BH+NCBgsEAK7IcrCtSMKe10m5bHhx3gZX19SZe1VqYaBY0NtJ+t496LrtUyF3V2pekT2/Jw3c6WP25QkkJNDV1/eYx6htZ9oqOh+05bHzayj9rUrDGpDNwkCDpJiPpHkZXy/3oPmdn46j5fH06mlG9yti3eCn5W43eHI83zIVsbVzvdCINnt4lHbyJrnoZ1027kNxcNWxl73yx6hRGIyxbdgGq31XEd5gjafFIUiNNWAZnIDw3lZSSZcXLvEWJs0bNwjI4HbFggdrkqqyM5Y8mkFdtY86mRiau3UdVw2k+H9cbp2U2Pq+9Tu+te9gd34vd90zEFJXKa1+/xp7qPQwOGsysETOofeFp/hh/FLtv18fe2783t0TfTOTbnzKxHHpOuZO0P72F0GjaeQnQqpeVEpGCQFBwpACXdKHT6NpV8ncX9kY78z+dT3RgtNfj+s5zLBdBVz2Sa86QCCFuB14AtMCrUso/d3hdD7wBJAKngAellIcvds6rbUjaepoJCfD22+oaExAAa9dIAjSqNyAXLMB2MpoTW8r4Y7+lhA0wUlICgwdJ+vV08FxOKz3Wboe5c9XwU1mZ+hlaLTQ1Spqau3/DDh/qYkfiI8jIKOr/sZaKI270/lr+FTGLOz6yeDstAthrJe9NyWak3cp2o4n71lgQGoHBX7Iiy6NybAKLyPYK0MnMzmtGuuOFXzcNDEeMUHMg3cXw4bBjx5Ufz/cMb5MnnQFnkwPltVWtwoQWC/YmB3M/mcuuk7uQUjIidAQ5P8vG+NoqtZ90YiJy4UIcZ0+iLHgcsWsX8tQp3D4+1M5OZ93fX+BoLx09q87x1rxUfHr0oqC8AI1Gg1u6uSnmJuqb6llTuoZm2dzlcftqfRkWNJTJaw4y9mAd+4eFsfDFTQT0CWvPgFEUJLQzLN7rbXZ2PSR1gbnrTFrm+8J3FtoSQvQSQowTQpg7/lzeUNudWwssAe4AhgIPCyGGdjhsDlAjpYwHngOe+rafe6XhsEtsG+xER7r5eqOd45WSY8fgxHGJboUnVpObS0OCCcfuMvKaTewsNVD0LzvxsW4StmTzywNt6LFSYnCr8a6qExK/ploUdy2uZklT15+Tdti1W4NrfCocPEjtqUY0TieNp84RX7mB/3zcQXa2yuiy28GgCBpmWlg2YikNMy0YAwRGRdL4UjaDsuZz76lsbBvsNOe1JvwcVY7zaM1wfl7wYtGga8BjvzRcLpWddTnYteuapQa3hIwuZ6MpAGOjR2qzky9c8VEwR5sx+BhQfBXMUWYUX6Pq3iYlqS75K6+onq3ZDHo9orER7ZAh9Nh7mDPD4ulz0sGOuAA21+zy5isaXY3e3fvaQ2u7ZURAff+O49sZWeqgIsiXn206jX7BYrwPQ3Y2cv586pa8gL2h1mswWggDGo3msvMi3rnz1Ngs/enSdkbk23wfVwPdqWz3A1YAD3BhOVbttxzPOOCAlLLU85nvAHcB37Q55i7UHvEAq4GXhBBCXiszLNXuhr8utXJqUzM9+2gZpEklN8xCsMGBtsgK8dFQWIj+pSXsqM9g+dMG5pHDuCYr504lkhxTzODb1JoO0tNh1SqaN1gZWZjCQB/JVPEaGq2G1/0yeb5p9mXlDnQ6wbkH56KpssPHBUQ2naBJ+rCjehRHaww4NqjyKi1htkyLwDm9TdLc7lE5HhiFdnceyQunofU30ZSvVsArIUq7an+DwWOUDN1ThLjm2Vp2u8pUaGFndQc6nfr+wMArP65vgW+1K+7YPjdJw5x+bsxlZd62A0II5iXNI2NkBtCmL7qneFdGRbHv7yv5S48NJCaZyXx4LY3Ls9F/vRORmsq901/i1Y0vUnZmF/3PlDIpZhJ5ZXnUNdfho/Wh/Ew5Te6my7r2ZuFmS4wf957sRZBBi+wfg7RaEVOnIq1WbLqTHF/1JM+yigeSZzMvaV6nc9PthHnL3DkcCEU5jyJ9LXkpnaE7Hsl/ATcBM1ENyS+AR4GNwEHgZ1dgPP2AI23+X+H5W6fHSCmbgbOoEi3tIITIFEIUCyGKT548eQWG1kU41L4jA9PCSKaIITeHc0+olbFDHTw4W8EnrU0iOsDI/CeM/P63Tn7ay0r0xGjSB9sYkpGo1liYTEgJTXlW3BHRDDm5ganVy+nvOsCwwApmR315vtZAF9HUBIvnOqh68R0Mzedwu+G4o4MRAQAAIABJREFUTyQ9e0h2Fzso22Un901JZKS66DudHfLjioJISSGh+gvGBR1ktt8qcmQm8+VSsqXqPrR4Ey21MvPnq78zM69xL6M7MBrVybwcNDdfk1ayo+Cio6mLJALweiBNEWFoCosY4NeP5WO1OJ5/ut0XLoQgQB/grXQHvMn/5sOlWCOhb2gc1opCXtyzksz+O3n10QSyEyQL1yxG6R1Kzp2vMLDPQD7Y8wFNribO1p8l2D8IfX0zmm/BIzp8/xS2/fd8Xh8Fazes4KvwRmoD/akbO4bKb4r4MtTJvvqj5JXldTo3l5Uwvwiz5ILfx/dchNgW3Znte4E/AO94/l8kpXxNSpkGbANuvwLj6WxZ6ThLXTkGKWWOlDJJSpkUHBx8BYbWRXgeBnG8Em1KMlQeI+phE1krFOY9JhAdYjUajVq0N3axiZE9y/BJMyEWLYKlS9U8w5sGVu8Zxv61h9jXKxmh19GgNSAaG9mhGU2s/vK0MoOCYMNX4HBqsGPAx+CDEqqwN9TMXMMq/lA9n7S92az53M3EMXYM/pLaWrXbove+bWhAVFejC+qNK6+Aneuq6BunYC0UOByt3oTT2T66cZ5Rup6h1arFhpeDYcPU918FdCc00iK4WHa2rNPaj4u/Wb3/fSoqcacks7/hmNoZsFdop194u3F5Ypm6l7NpmDOTsnPlXqHG6J4xrDu5mbwj+Z5eHlbqXHXotDruHHQnZxrPMChoIEn/sLH0cw1SurszPV4IBK/d9Rq24yVkjW5g3u0uZoVYmfsPCzOCN/KLnwpWJvtS72pgXL9xnc5Npwt/h0X/vO/jIjHfTr+Pa4zS2J26jyhgl5TS5akbaTuDK4DXgMWdvrPrqAAi2/w/Ajh2gWMqPMrDgcDpb/m53cJFiS5tKg6lv4HlWU41Ge2n7tC9q2vLjeU5yet6CzYySJQKFiFAMXKi0s2IZ6bTv6qIouZEXgpaSHOwP/eFbCA4PZkquZBJS77i2KEg6mQXdX0Ava8kLg5OHDfysd8jjK/fwMTfjON95rB5i+CRMwvYfi6aOwIKGOFuYNpmG+seMvHvhyxIBOnpsHiOA01JCQwZAnv2oEtMZOGRJ7BWmOg3s7VwEoeqxmoyiS6Fs66bupG2+O1vL4+19bvffXdjaoPuhkbOkzrv4hfhDedkZnr67hhIvEjy+ULjEgEBWJLmkTFqOgadgZySHKxHrJijzV4drsSwRIL9g729PcZHjMdQ7ybd3p/Y0ZOIcezgkLH7nuKw4KH0yn2PJz4uo4+/nbdSjNQ3O+lr7Msnez9mZOhIrKe20c/YD1+Nb/vr9lzneT1HdIZ2rBGZmUm255q8130R5ddOvw/7tSVA12XWlhDiCJAppfxMCHEAeF5K+ZLntenAS1LKbxXs9RiGfcAtwFFgCzBNSrmrzTELgBFSynlCiIeAe6SUD1zsvFeStdUdJlFn9FVFUZPxSm42Ij8PzGbs6RbmLxDe45YsUXW7tn5+nN+vTaW8KYxgVyUz4wsIGR7KiiwHb31koDjPSf+h/vzpD404XF03JL197Xzzf99ideBcvvoKppgcOIVC1kuCgQMk5j3ZjKi1steYwM/6lnA6IJrD+WVYmpZSpzXSowf8139KFvt7WFoe9pGMjqG5tAxd9lKEUenw8Fg6pQJf7txeU2hogPBwON2N/Uzv3nDs2FWRS7kalNKuGquWnXgLFvxzwXnj6kw2xdFoR2kEaTDw4pYsio8Wk9QviYVjF+JsdiKlVJP8K98Cq5X/jNzP037FapFgF2F06Vg25XnSXylC9u3L7h3reHpaDI3+vmgQ3LR2HwP3VPNZyFn+kRaO4mdkTcYa3tr51nnX3bGdsJw/n6aIMHwqKnE8/zTzNzxx/vfRnV3UVXpYvguJlE2ozas+A94HnhRCBADNwK9QcyXfClLKZiHEL4AvUBP3K6SUu4QQfwCKpZSfAMuBNz3G7DTw0Lf93O6gO2oEHTcZBs/GxPaVnSeLVhJqdCBKS1GmpWMyBXiPkxJWrgRHbQhb/ZIZ1lREgUxmV1UID94sEEYF/RvZLHBa2XEggVfiapi57z+8kigXg0Fbz3OJuexbbmVLwjR0PkacGqNXoHj3bkF1kIWmBzLYU25g9ugc9j9jpcBtolYqCBf4+kJRETieS1fbhCoK5OQgrFZV/sSonDdRIiOjfY+Wbzm31xT0elX2pDuV7Z9/ftU0tzrtyneFcaFGVm3RsX5k5qiZpESkeOVOFB+lc4MEKjXYaqVhXAI7exZymnNqv3RAr9V7z2GZOxcxdSr/1asHLz8fQU19TZevwVfny31D70c2bcS9+j0GJ4/npfuzMfgoOI8exvDR/8ORnMq5vDf5stEFfhe+7hYml5SSWp0bW3gTWutq3CnJTAwM7vz76A6z5BqTn++OR5IEREkpP/AYkJXAnagL/ibgoWtVa+v78khajm/ZZDgcqocyoG8tD62YQmxfJxqjAceHazGEBngL++x2VfHX6QQtLozVh2mOiOH4SS1r10JsiJ39t87nG3s0A/WHOd4vCdsXVfxv4xM04EcDnS9QWq1kjeUD/P75PscHmPnNAQv33S+orFTrXUpK1N++vpCfrzIv06dJ7rzFwb6jCmfOCvr0gfAwydPx2Zh1VpWJY7GoH9B2N3UZO6br1iNpwZYtasV6W62ttjAa1cn9HrS2LotF1I1zAhf1SKSUnHCc4N8++ze+qf7GWz+S/bNsbzioRfywrfe05CdLEA4Hyr89gYiKQn75JXt6NLIqsJxvbh2DtkcgOq0P8b3jKTtzmJzKJHw3FVObNII995i5+c1bcDY5L3ktis7A+h4LSbSWcXyblaJ4PUObAhm4/GPExx9DYSHupib2nNnPx32q+WBiELPHzMGSZPGG3jped4tRzCvLo/T0QX4SlsaBxkqW/HSp93O/LV34u8ZVKUj0FAfqpZTnLvskVwFXuiDxcuP43oWyQDKneRkTZR75wsxy3TxMqaJd0d6yZZC3QZJJNtoiVbTxixgLgwYLJqRKMmU2e16z8lGViWfPzuUx14vc4Xyf9eIWliuLKKvtjZRecSviIxr4xS99WajP5sBreWwUZr6Mm4fOR2BKkUy7S9XRUoyCnBy12+3EiV72MXl5auveRx4BjdOO8bcePbGLlZy73apOfkgIaDTt5uFC83dd5kjaoqEBVq+GP/9ZrRPR6VR21rBhak7kvvuuLfXfy0RnngPQqbFqe2yTq4nSmlKEEGpFe9L5Bsd73ggTEklheQFzCxpIPgo+ZUfg5ps5/skqthnsbB0YwPa7xuOj88XcJ4HZr9j40GmD8jI+/MUUFiQv4o7cW6nXuGnQnr/W6bV6JJJfj17Ak++eZLP2OJp16ygNdKP3MfDTAXfgW1aBvPlm9mz5jJkTTxHUfxiBhp7k/CyHAH1Aq0HVGcDhwOELiq8RR5OD+Z/OJ6pHFF8e+pL+Pfu3y/Ncq1TetrhuK9u/C3wfEikXWg29LxkkjioH83+jEB0j2q/HLRIrdony2wUQFY19VxmLfZYS3N/IsWPw9FOSJxY4sO1RaKxx8Pvq+RzTRjE+5CAp23OoJYA5c2D9OtUYzYi3MmRaAq7CInQDYmnaV0r989kgBCW/XoW2yIpITCTu+YX89t81REWp/d7791e73XqaFbaTd7lo/uMC7sV173V0By6X6pkYjVeNnXW10JW8S8sCK6Vslwt5avJTGH2N3t14pzmRlvd9Op978qrxKdrCycGR9A8ZhLlc4Co9wMcRdmLP+bBk5hD+d/IfCQmK5uxf/sin7/6BjRFuXkkUPDnpSR6xucj9/CleHdbAvsBm9T5EEqgPZGjwUNKi0zh6roKsIyPY+sESVvc4ypdx8N8bBD9Nm4vRWkxjcyPl9go+Tw3l+ZFOfjXqMR5L+xWirs6bGJfZ2ez7+0q1S+OcmWQmtvFWIkykj1TlcDrLC12rO6grkiMRQtwtpfywmx8cBkRLKTd1530/GFxipWwNgwqUUFVevS1RQ7olDVnZ6G1WjCkp3iSLcquJ+jyF1atVz+CDDwX5W41UV0Of3go7Akwku6zka9KwrTRSslX1KE4cdJBabqW4oi89nn2bhjoXwes2URcQQumEefTu5aZf+SHcPXpg+OQFPj8gaR68mIMHwN/lIC5WwVoAGVNVjwVEe2aaQem8fW7bhEdBgaqTHxqKwyGuzzzI5UCrveaKDa8ULpV36ehZtM2F9DX2bR/+Kc4mrzwPc5TZ66G05BfMQYn03voCB/roGVPhYulkSHzirxje/ZAh/3iNTbEapu/UEPLFfyNcLnya6tjby8Wy0aDRCHK3r2Jnrzgec/Yh7ogRTWElC+5wE6APYOFNv0Oj1areQVQqAXfNZf8oHT1e+h/++6taEmsDUD75nAP9e3Ky/jTHY0MYfaiO5T1HY7ZtR7w6XfU4TSZIT6d5Yx67/R2MLhUs3Z+Hc9T089hWUsrz560Lu6vvIjR5JXFRj0QIcQw4CbwM/E1KeUFaihBiIjAdSAcel1LmXOGxXjauqkfSTaXBthsRgOUv2Bn04mMY48MZHXoMsXQpCIFdqnUogYFwqlri06hKvLulIC4Otn0tcdc60PZQMKUK4uPhwAE4sM/N/zuQwfDaQqSEL3vey88b3qc44i5STv6d/OB7uOnk39DXnqJCF8PZ/qN5ecTLPJu4ihMfWLFiIjZWkkKhWuPS4SbveLlLlqgvKwaJyMlWjYjL5X3gLqTBdQPXHy62uHWa62iTC2lBbUMtU96cgqPRgeKrsHb6WgL0rZ3TpNtN/dIXKf/snfY7fVs2tv15jAkdzbyVO9GEhSHffZcmP18aDx/k03jJQ/eBVqMlRAlm4dd6MhuG88fm9QgESWVN3Dbj9/Rc9ASOZqdXJ8tQ76b5MQsNwb1QPvmcujsmU7LrS84OjSfwmwOM/Mkj9NixDxEeroYw77sPKithyRLkqlXtPBJLV6veL7FmfJ+V7VdKayselaH1B+CEEGK7EOJNIcRfhRB/EkIsE0KsEUKcBr4CBgBTriUjctXRmTT3RSpQ2yqqOxyQV2wgwOAivHA1TQ0u9f1GI/4Gwd698MbrkpGbVEn3DGc2PQIkkyZBWLigR7iR0L6C5ORWFfvMDCdKDy0f+9xPjU8IxjNHsfmm0KPxFJs1yfidOkJ9YF+Ox6bg2+zk/fIk3G7osdPKwCnRpEflEbY/j3/ujGbfSivS3p6VZPCXjB9up+ywxGRShXDnz0dty5tpgWeeUY1IC3vLYceSbmfpEnnDiFznaPEcOlvUulvU2JmmlJQSR7MTv/mLGPjOWu5/YS2WpHk4m51YKwrpGxrH1uNbaRyXiNywgXN156C0lHM9/Ug+rmWoqw8+Wh8cTU4+mBhEw/N/5bPk3iSWNVIV5IeyZRvCqRqRrM1ZzP90Pjl7V+EzMQ3jqVoODOxDyc61fDOgJ+/eHMzePywi4Jf/TsP4JOSxY2pooLJSfc6NRoTF0m6cF1rsz5u3S8j5fxulgaul0XXR0JaU0gn8QQjxJ+Ae4DZgPBAO+KGq7+5BVet9V0q55zsd7fWAjrQ86HJSQFHAnOSk1qpDptxHiL7SWwZ+8iScOgVjhzoY/I2VfndH88sTVhb8NQMl1IjBAHlfuZkyuop7Z4UwZ47Gk29RqBepaJ63kls1i1xtBqMSFcICnTgxMKK/nWNfriC2xkZh8M/4OHAho3SCxiQTfjYr7lQzBeWS0aIQKyb6odCyV5JuSV5GNsMKrQwca2LcwxZ+sVC0CVsJjKGhrRzolBRYpSrBGr1srxuW5IeItkV0bYsKO+6ojT4KcwY8yLqqIszRaazasYrCikKvPHvbpLTRExqSUmLql4J+xetkHAH95GSaYyJZH3YOc6EbnXRxOmE4SoSOkLqT9PbvzSNjZhPaN45Rsalsj1vD7VU9cI1PxqXX88KX/0PWrhUMCBpIwRErGY8shQem8uS6X+E424uva/czL2wUj4xfSM7WV7CGFWOem8ic1IWtOZKWZ9pohO5IyqiTdVEqr+KjYIowecN/XaVvX01PpksSKVLKJinlu1LK2VLKoVLKnlJKPyllPynlLVLK398wIm3Q0c3oRPqgMydFCJizSJVLGRVaSUNSazOskBAYPx7KqhVODzGhnPLIqRgV9T6c62alK4N7nk1l55gMct9we8/vejCd0RuXcOQn8wjqH8CmzRqcGiOTbhb4rH6L0Aobh/ok8lHEQnr01JB2k0C/UJVy0S+y0DBrHkuHqcq/irFNWOuEA8eXVvY4o2n4Sr228zZWbSV8MzK6Lv17A9c9WnbezmbnBbWiRE4Ojy7fymtVKWSMTKewopDowGjyyvLIK89r956WhXHBPxegrasn3d6fgWMmI0pK0KVMYEhTIB/dOZCPVvyGIf/cwpez1vH4+McZHDwYDQLH6ePonA2cybif/7qnN4+EWHl1fjLR/+dp7i+owVpeQENzAwYfBaVXKIkRY9lmP8jg4CHsrNrJybqT6nX0jCGv2kbVycNIgwGJGspzu93d19hqnayL6gZJVAMquyGu960007qJa7I17g8KnUgfXCy3JjTqIr78xQzyihVMOa204GXLwOEQhIZYEM4Mlr2pkJcpME+UzLv1ENriIioJY9CZIp5cXkVefii3HMxmYLUV93gTJpOFLcWqY+DrC7XHHQw6ZeVsaAzxZ0v4eI0TJdSo3s+gPugOOxaLEcf09u1ypQS7VNiumBh21sqOnibMRqXzjVVbWZjuSP/ewLWPLrCNLpiY92yyRHQ0fkU29DNme4/rSJNVfJR2C2P+qRKmp4yHIhv145PQz/sFA2bP5rNdyyk6thn318tJH5lOyfES4gNjMSxbjn3Tn1hYe4zXR0t2mnqQ6pNK0Nf/xBkexKiDFZinmNDr9DiaHAghWDh2IQKBrdKGKdJEiCFEHV95AeYv9rDvxSnsHJfIvvsmUXh0EwlhCZRUlly0KPNy4GhyUFhRSHzveAorCpk+anqXzns1ClFbcIP+ezXQ4WG7VD6+5fWoKLXte3Y2vPVWe8NTWwu33CzROO3c7czll8kF+JTu5dyh02zzT+aJsFwmm5yMWDaf08ZookQZpb9cyhsfGBFCPXeJTTK9Tm1YFXiHiVveVRtWeS3dypXqgGbOhHnzvAtFy8sFBeBqlvg2ORh/i4JlnvDWwVxwbblGaY43cBm4yI7oQpTedsn2Nu+XJhOOR9LVKnKPPhe0r0txu91kbc7yLuyZY+ayoiCLvGobpqhUpg2fxq25t6qJex8Da+7+kFUHP8T/5VeZ+kUZTmcNJ/WwO1Twm/sCCQqO5o71R0itEFQMj2LjbUMwByfh8vfDerQQU0QKmYPSceoFShuqctWJUvY9NIWKnhp8jx7nhekDMQ/7CWVny0gKT/KOr7NQUrfYV55nRRoM52tzdVf/7DLZXt+FRMoNdEBX1kT1GIGiGL3HXESfzft6Sgq8ripJsGIF2GwQE6O+J32a5I0ldsy7c0lzrSdGW4aMmkITsHrK71mzvz/9dRoOVCq4FRPjXVa29TCx/WuF226DvXtVZqq/QfDnoxZigjNYfJPCLS0DdDjUCsQWCd+8PJg+3WvtWqJ1MTFw+LDgz88ZCQ3tYkF7d2QgbuDaxgU0bS4Umz9vF+0Je8pp01i+dTl5n87HFJXqPd7tdmNvtGPQGQC1cr6w3MqEPmOYO/pRqupOsqHaRnhAONYjVu4adJd6WmBqXhV+X/2K4aHNyEM1bO/VyOCz0KDA+iiJ2+CPRqNFZFp47/heXrztBWb+bTWaj4pYZTxE9H23oF/+Oi57PsYJZq96gwBCDMHsHJeI7/rPqBgWRYOfjtIzpZijzWQmZLYzhPZGe7t/527PbZVzuZhBaPMgCZMJS2Zmt0U01SnuZN6/A9wwJJeJtrvyxERYtKhd8Xa7Y1ryzC01E5eSyRFCLQBcvx4GDlSlSxITPU2mUtQui2OWfcW97iJqmhXCDQ4OrzvA+9U38dy/Ykkaq0qZPPNXwYcfWPhgfQbJkwzc0uggv0Th5psF587Bpk3Qu49A19PIxgKYMdOzxiuKSvkqLVUHZDa3s3ZtDWFqKl4jAq1rS1QUbNigXkdAADfwQ8QFdkRd0d1qi4Y3X2PQey8RPHoQ75sLvAn6jA8zKKooIjkimZd/8jKvf72Sn6yroH/ZOtZPsPF6sp491Xso2Z/H0JixBPkF8dCwh/j6wEbuPn0EOTISrKupHhJD3bkK/jnJj5dG1NPk50Na8HDONJ5h3+l9LNjlS8A/f4M4dAg5eTKmrYewle/FdAR0Y2LVjVRLRa7ngdaGaXkhYwAN/j7MGv0IGaPO19jq2Nc9rzyP0ppSJveffOl56ahVl56OUQjw+S6+yG+PG4bkMuFwqEbk1CnIylIX0kWL2hsFteWug6hYhddfF179qpZd+oU25lKqsiTl5erPjBlqPd/s2RAgHLBA7UyoP/olvj4KzoBQnu33HIUNfdE1CvbsgcWLoW9feGy+YMYMBUNuNs2braSPM5HtzGSvzUlSosKRCjUcZTa3djFUFE/flHS1ErezJGB6eodqdw86elOrVn1HtSI3QmTfPy6wI2qJzReUF5AYnuj1KDqFw4G+yIYhbhB8vRfzPQtRfBROOE6w6cgmQpVQrOVWqhxV+De4GV3q5FgfPQOLthCTOpXILw+RdsyHTaHrmSYfQqv1ITnWRNTtGnw223CbxvNhoqBsyAiqndX08pEMDBrE/pr9JPVLQmmUhO04BKNvobn0ANqDBxn4s5n8+c67UOo/QrzxhjrO3FwvWaQpIgyt9T3GL7qdctdpMkZltKt9QUocNSewlheoifmyPIQQxPaMpbSmlIM1B0mLSbt4zqKjkc7NhcLCa7b46oYhuUwoiuolZGWpqrk2m7queY2D9LTcPWQl/4AJNBZiY0WXqrntdnUTdMstao5k3Tp49lmVtp77hgGRkMig/C183fcmlB468gPSGJzWl7U7BE1NMGEC/GKBxHHCgRKioOBg3+tWdjui6WUtoK72LNP8dlIeYeInqzz0YUWQlaVeh3qvqn0hOqKz0FVbCKFeX34+xMZeRvV6V+OFPxqdlWscneyIhBBkJmTS0NyArdJGTknOhcM4ioIwmUiwWmm4/zYmTFiIEIJg/2D6GPpQcrwEo4+RT/Z+wv1Js9hZ+DSjSh3sHxFMZW0lGSeMuGuqmLsfsus+453b+7GpYhObI8dzy9zxzE5dSGKzE8PyN6nfvp5VAYf4s7aUlF4j0Gr1RPSNJr9fGa6taygarcH18Fjm7Abll7+jYeQw9DExiPh4dRHPyACTCV1BAXnhTSz95nWGhAzFoDO009sSOTkoVitz+rlYPvZwO+LArFGzSB+ZfmmxxrZGWkpYsOCaloPoTs/2Mah9QqIBN2q/kA1SyqLvaGzXNNp6IC2Lb7tcR0vL3cnR9D9oheQM8kqMXWrstGoVHDqk/tx9t7pmhodJdljtnPtLLic+2ELNiQaatX5sMyTRMNPCoxmCLcUQGQnHjko2pGfja7PiTjaRsHQum12JDHUXU1ndwExXNnudg7jdZyWh/zcf0sy8UGfhxSy1Ir6goHWT2bbq3uFp9NapxEkbA2A0CszmyyBnddVAXLd68z8eOJud2Cptlw5veRZMkZGB3mDA4ckvOJudSCR6nR6Xu5nl+S8ww/QYO6am0OwfxYHGSp6e8jQhJ9/h3F/+h7O+jcwqtNMsy3hhgo6IgEjyTpXwkKsOY5OATZvQ9Y9lcIGNv2pj6b17Jw3jEvn3uC+QCZLcEYIJQyZz4tgWZhTADv1ZnP/IhsREJpSXqyrXRiMyM5MX4k7yp80fEOQfhP3UcU7Yj/PJ/r9jPWJlYu8xzNy4GZ+YOMzl5ST+5mm1OySQMaqbOY7riO14SUPi0c56DZjC+dVjUgjxNfCglPKA5/hBUsq9V3yk1yA0GtWYdLqBbmm5a7Xim2ZiTqbCQ85LR2Ja1sjJk9UUxbx5qvxJ7Nps7lDyML5fSn7tRExnV2MNu5/7Ykvwn64WLaalqe9NHOzA9zUrzeHR6DYVoFtWT7Isoth3ND30O9hbN5hhmt0EBwch4mJpyrOyw5WBwWCksBDuuAP8/duv6VKqm7I28l+t93QHAyAsFiwW0f1WCV01EJdiK9zA946O1FODzuBNPJ+3kAqBVJR22lx3DroTrdCi+Bi4J6+aqacNHDn0EeNnPYzteAmmqFRCjX1h4UJ2715H/w/WcsZPi2WLxMffj72DjpDW/ya1x4lO0pCciO+mYkhKpLfNhhIZR58dh3D2OUlk+BBq6msoPXsI8wAzrvENOFdncXr0YN436Rkz6WmMnlbBjiYHJbX7iOoRxaQ1+7mp0pddpxezIVlHbM84lu97B6G4mbj1EAN/Pgtjr1Akat7IoDN4fzsv0jnyPFwqqXoN4FKijYGo0idBwO+AT4DDnpdjgLuAJ4BNQogRqO14/wFcxSbp3y8umOvo8OULIbq0aW67RprN0KMH5GY7qH/Uiv+AWPjyIGPr1uNqhrF1efhPmqmKKQrIzIT6eijeohDQx8SgSiskJOL34dsMqHcSqS3lbzEPE9ZYwhf6xTyQocevpBCd2cSIOoX1W1RDodGo6u8ta3penmorWjz8JUs63NP28w2AMBq77yS0uXhpMuGQCors5Lm5Dh6sHzu6WtnegpYEfVSPKFZuW8lXh78itlcsg/0iuP9MMTV9A0itEAwYNhtn4qPqIgzUL3sJuWs7pwZE0GN/OVWRvXmgPoKISX8loE8YgEqd9VSjz05ZQPP0dLQFWyiKgOjwIew9tY/HR2Qyw/QYQqNBn2Bg70i8tOK2/eYVH4XUqFSE3cGkynKqgwxo1n9ORcQA9lbvw0fjw+H7b6WoqpTn7k1HQWWbFZQX4JIutEKLS7rQaXTdo/Je42zHS3kkv0PtiZ4gpSzr8Npe4GkhxHtAIfARMBScRXMlAAAgAElEQVT4Hgs2rjFcxpff2RopAhQMN3usy8MPE1pURGPE7YjDpZCe4b3JHQ6ViRUVJfgKCz//QwYhQW647R1O1QhqGgRfpc0m3+dRktIU9BbAOR2hKCySAgS8/TacOwcfftjeoLX1SKDD+n05HkJnuZAWOmh6Btm5CtYF4sIRrmv8wbqBVuqpvdF+SRaX4qOQEpHCukPrkFKqjarOlvHU1L8SYv8I18Y8dBOS1Q1KCz2ythb9m28zovQssr6OqsQh+Oo1bIrS0njoYyx95rUyyHrGqKGu2lMYffTI++6nz84N9NP05FeVSUyy7SL/y8dYPlaLKSqVzAmLeKgTr6HFQN414Oe89amJ+ENnyIuU+AX24ciZA4wNH0vZuXJSB6Z5e5JYj1gJDwhn9TeruXPQnXyy9xPuG3rfFS1a/L5xKYmUu4E/d2JEvJBSHgKeAsaiGpNbr9zwrm9cSKvxIhqOnR+HKoBof3opcuEiSEvjcH45q46YyV5lREr12NxctQXuayskugYHwTEKokcADQ/NZK/vMHYlzaTeJ4AnnzOqxYOaVlkGjUZlhUVGqkn+TZtUVtbSpepCPm9eq7LvggVqJMs7/rYyKF1JfLeEwubP73Ai9VwOYcRaKG4oqfxA0FUBR4FAp9UR2yuWsrNlpHrCVxqLBZ9x4xElJZCT0+5+EW43xmaBMaA3zT5a5kw4zeqJvSk4YlX7vDdITBEprZ/dMwSZmkrzsQoG/HwWz93+HDdX+tEUEYawFhLvG0ZBeQFVzqp29R9tC7cF0Pftv/Oz2r7UDI2l7IHbOHDmIEOChuCn8+OZW5/xehot136s9hjj+o2jsrZS/W2v/M6rza8mLuWRRAO2LpzHBkgp5fRvP6QfBi6UN+74944U2rb1KQ0NqpRJUhL4+go2bVKT9enTLPxlQwZ94xTKrJBxtx0Uhbw8QYBRMrM+m5uLC2h8NhG/Xy9Cv2geu5nOq28rUAP/eMfOo4vbh4SkW/K3FQ4qjihUVAhmzmwdl5QqlRm7A2uB2ojLaoWMdIlRtPEq2klfX4R8dYlcyI0UyA8LbcNcF8oLOJocWCusxPdSPZGnJz9FKEY1Ket0qoyWjveL0YicNQvXK6+Aj47CWC1B/Yey99Q+FsbdiuLp8z5zXALpj76E0UPRzU6U2HpIhvdvYGHPEDCZOPz3lVij4NNjXxHbO44n1j7h7dBoPWIlMTyRReMWoRECTpxQiTQJU+h/+CCNfcdSdfIwNc7T3DXoLkKVUO81tlx7+oh0crfnkl+ez8Soie16u/8QcClD4gB6d+E8vYAz3344Pxy0rJVhYe3v/bYFeytXqkV7aWmthsZuV/9WXa2GkiIjVaMSFAS33eapbE8XJKYZ1Za9rmyUJ9QV1zzRwtG9DsY2FRDduxr9yy+AL4jFi3lwjpF/bZI8eDabPi9ZadCY8FtkQSJw2CXa5dkMfMHK7wab+FtPCxkZrXIn2csk+tezMUkrc+JMLD+UyfgRDgxvroJNncljqO+x5TlINLdKp3hxCUtxIwXyw0FbiY6LhXDaJecjUghd9TGi5f7IzGx3v0iDAUejHYPWn/wjG/ExnsE1Lomz96YQfngLt41byMJhs5FLF7BFd4LG1S+ydyTMmbjYY7AKqZZnWbc5Cylg9sxH+LPxX/TrewvRNfuRUhJmDGND+QakW3Ku8RxZRVkICYu2+SE8PXZEeTmu5GQ0b+fy/KEmSvpr+elDd553bUIIhBAUVhQS1yvOq5f1QzEicOnQ1mbUZlWXwgzPsT9KtAtVef5j8Jc0N6u9b5qb1WI/aF1DW4rG4+Jawzct4akDB2DrVtWIHDkCAwaoCfCDB72tD9RI0jMOzDpV9A6rFV2Dg/ABCoYJCUSe2AKNjTSvegdZa8dohFvGO+iz14pvXDS+xWpvkf/f3rmHR1XfCf/zTQLBmYlyUSCgCaCAuOKFRC6TNugK1tobXXV1JRYUzXBppN1W1n27fV6ffd93t6LbVigpQVHYgmtb23qrvYBVopmAJki9c1MSLJGbiswEQkJ+7x+/M8nMZCY5k5lMTsjv8zx55nbmzHcm55zv73uvWK34l/kHef2nVexuymdAjZ9rpgbbDIRgEGorg1zR6Oe9xnxmtFZx97EHubz8bg49uA6Vl6e/wMGDbS6HYEArnsXvLCZ7fYW2ZsKx4QoTiVkHaehDhKq7O3TDjeHbDa3cy79Sju/iEq1EQhZIY2Pb8aJKS6nYvobFv1/M6i3/RcbWbQQvGMkx/0uc/cgv+M4vdlP2xkDE7ealUU387e1qdoxzseVwTZtCK8gtYOeRnUw8dyK1B2pZu+Mx3ju5n837XuTq/KsREZ569ylQMHXUVN47/B4Thk3g7Q+20vzSZk6dn4vKzEQ98AAbJreS+3YdOwZ+woSdR/jhc/8cs/NvovNZ+hpdKZKfAv8gIg+JyMDoF0VkoIg8BMwBfpKMICIyVEQ2ichu63ZInO3+KCKficjzyXxeqohw969WKOvBqZ9VkJmhuOkm3deqsVFvH7qGVlToXoh1dTBlilY0waC2Qq67DsaOURROCvDl6xUjRsAdd2j3cOi6KwKeEbqYi7o6mgq8vLLdzfgJwhPZC2jNG8tRNZR9+2DtWi3onXcoThXM4NTeOl457SXQ6iJ7fQV37lzGJ4dPc8WQfTSM8XLrAndEX7CCYjc7XF4mueqgqYkJL1UwLPMYx48rWnbu1Zry3nvb4h1ugnjxU6fy8eLHTTDyBwsE9H2jKc5oYrYxjxEfCw1fArS7x+OJGPSkXC4CzUGU200wrCV99adv8u5F53D0/Vpq3McY9tZeXmrdy/vPP07gs0Osn5bNhoUz+OnkINMGX4pqbQWgbGoZZdPKGHbWMApHFbK9YTuzxs5i7OCxzLl4Dkopbpx0I5mSSUZGBue6zuWTxqPcsqOFT96ppe43j1E5uoXAEDevfPIGzVMLGRfIYufEYeSOvChmy/YIRZnGCYfpolNFopT6M/BvwHeBj0Rko4j8P+tvI/CR9dr/trZNhvuAF5VS44EXrcexeBB7VlJaCHf311YGaanUD7Jr/cwsDNLQoPtRhXtvRHT/KZ9Pxz9CMUSXS58/++sVD02oYG32Yn55bQU/L9fTBHNyYjRAtFZq2WU+vEVCXR0UXJ1D8+0L2DlgMm8Xzqey1k3TygpOL1pCfb3w8o2rWJvpI3i4ES9+6sln6PAsHp/0IC13+vDkSORHLBRu3uRjwtPLGeDO5kT+xQw5vIuPr76VrId/rDVlqKNkUM92nzDfy1cm1zFhvtea9U7nQXZDn8Hu1L2Yq/Co+JgKBDpaLWHHdbgFUlFbgSvL1bbPwtFX8dKsiziHs5i3QzHqYJCLA9lsvSADXC6Kzy3AM3g4axoKmf3j3/HUd66jomY1IsLSaUv5+Vd/TtnUMoryiqj/vJ7i/GKe2fkM+z77kNd3vURB7hS2f7ydL134JbJPNJPt38YLeSdpPH8kGyZrOb15Rfy2+Fz2/Pt3abnrTuo+r49rcXQ2UbKvY6uNvIhcg64XKQbOsp4+AVQCDyql/pK0ICI7gauVUg1WEeTLSqmJcba9Gvi+Uuqrdvbdk23kI4LnMxQ+qWjz7apSH8FGievnj2gnv09R/qBuaRI8FMS9bLF2WdmY+x4uSzCoFVLFasWvHg9yIsPNgluDzHttMQMuzGfX5joeGltOUDxkZugYixc/p6d5I5RIzEC59WVVlZ+myQVkf69MZ37FyyqI3kmC8+wNziPRqXsd2phHZZsE7pjL4heWtM12L/9KeUQsJXr2e/lXyttmk7iyXKz/03Jmfet+jpyTRe5xxQM/vJaJU6/Htz0D/H6arriUjNo3eKHpbfI/F8rn/x0/uemRiM9Qra0EPzuEcrlY8sIS/qHyCEN3vM9VNy5l/fRsKusquezpam6rbeazpmO8NutiWu5egK9wIdDe6j78/pmiLOy2kU9oHomIZALD0BlwR5RSp7svYod9f6aUGhz2+FOlVDz31tU4RJFA1DWTqAtoJ+lLbeeUFTQvztItoykt1SaKVZgXuE1fnCOyqCyF0RijWj58nsmePTB9muKcJysoaq3kojuKOfRNH/cuE8aM0Qps2qVBtr3txlsk4R8du4Yj1vex20DR9Mjq88S6sCdcBxF2vCigoqaibYysr1A3bwu/OHemuNTp0zTPvZXMbTVIYSGN//0o7pYMZMmSthNATZ/Ork1P4r8AmhbMi5ynrrQ7uuXVSjKLvshjk04y4f4VZI8dz1UtI5DycgKnAhz41hzePSvIpGMDGfXEc+ScO+qMURadYVeR2Bq1G0IpdVopdUgpdbA7SkRENovI2zH+vpHovmx8VqmI1IhIzeHDh1O9+6jPal9YB4KCcodd8Ttx5bRZ8FFB81BwUa0qZ3Wrj9nXCbNn6120turbRYvgllt0fUfbrq34g9ul8Hp15+Dp07XrbOhQxeEjilOndMylqEgbBQUFOrAf+ujwivbwGo5QaKNVCQE8qPBuOXYj44nWmxgcR0qCxlHHS/gY2YgAfc1qCATwTSmNG1uQjAwGVjxKps9HRnY2nvX/Ay4XJ6dOQW3eDPv2wcCB5K77Ddcv/y2l0YooEGDXc+v4/cm32P38elpbW3l1dCtH3t9O5egWcLvJGTqS8V+dz8WNZ1F94UCe2PdsuwB2i8LiYMdNaNeV2JuktfuvUmpWvNdE5KCI5Ia5tg4l+VlrgDWgLZJk9mXv82Istm30jhIB93A3TQVesmstiySU/SQeKl/RekUp3apkzpz2JKlqv+KaqUGqXnVTMhc8G8MH4egUXpcLHlsRZOjKagZNuoiMbdUQvB2fz0PJXIVrQwW7P6zitb0FjL7jHoYPz+iQmRsxEfE0ZGXFroGxhalI79PYqQlJhOgxst+c9E0dTD87j+y162kJvMKALxTjibXwCB2YlZU6pXHGDFRVFWsvOcm2IVu595wW8q+8hn3Pr2dh6+OcGJTJvMvnsTDMJaUGKPwXwBUfCK+MPc2mw9W8783hmUIP485XFLY06rnzd5bw43MqGTniQuo+qqbk8tvxDHAnZWHbcRMm6krsLRKySHqYZ4F51v15wDO9KEvChOaT5Obq22CQ9lxfK/skVmVdays8vEK4+3Ufa69cpVcdVum426Xa5oSEZk0NH66tiL17FN/LqWDea4uZ11SBWwW0Kywvn+ZKbUp4PDpteME9bgrLvHiO1rHxQy8VG7QcHgmS4a9iwtCj3HZkJb5TK8mgFd/cAOWrVNt5EdKHo3IVb1UHGDlCsW6d9sCZmHn/I5VB42gLJzQX/eODe/VgqTHjIkzjiNV5MIjy+zmVNxq1Zw88+iin33uXLQdfwz1kBL857whbq3/Nb4Z8zGEaaWxupLKukuNNx3l428Msen4RG97aSNOd8yif/3cE5t/GNWP+Hne2B8nJodiaGaKtJZgyvjgymB69UAxrwWDHioiZ1Rb13njbOA0nzSP5EfArEVkA1AM3A4hIIbBQKXWX9fgV4GLAIyIfAQuUUn/qJZnbcLn0av2pp/TcEJeLiMo65XJbI3cjQwsrV4ZmmghbtwnzMqoZcGE+yu8nOKdEWw4levvQ6r+sDDJPBBn7kJ+GnHwurfcDc1FeL7vW+fHjpWmDG581Zl0yhNMLfDy0zaqGrxZKbgdP2FAVNX4i1NbAihXI9u14QrGaYCNulxvvDBi4roKv4GfXy14qM3xceKG9+SoGQzxiWTi+Ah/ByXNxf76xvSjR7e6wOi+98m5eGd3CoC2/YnLLSc66dDIZBw9yaN87/PbUHgZdms09tyzgDw2VnEUrmRmZfDHvizy24zFWblvJxHMn4t/vZ9UNqzjZ2kTtgVqKLijizyV/RgBPs6BaW1n5+s/0HPbzvay6YVW7Eo1TWNuZFRGefBDdITmktCK+45TSDts4kYSC7X2Vng62Q3uAOzcXGhoiE5LijeU9flxfq48d03PUy76tWHqWNpUrW7yszdQpvbEs5uOfK355bQUFTX52uLzcvEkHKb9bGtTKol5iytAhuep0K1W3rkTV1iIFBRQNqkHGjGkvcNm+XWeg3TaXloVLyBqXT/PeOtZPLeeVNzz2A/IGQ6JEHUfRgf7ls5ez7M/3Mn7ASK5d/mum/U1oKriCvClbUCKcPH2SG8bfwLVjr+W2ybfpqF4wyJItyzhy4ig7j+zEV+BjYeFCvv2Hb7cnENywCs/jG1F+P3/JPUFpbi0Tz7uYc13ndkwuiHGsh+TMOzuPvZ/uZc3X1pCTnRNTwUBkpldnWWq9kQ3WI8F2Q3xCi5OGho5erOixvCtXauvl0Ud1hfvRo9rKuGepHnEbeEAH2fPyJW7TQk+O0HyHj4cnlHPidt3q5CyXcOl0D3X1EimDUkgwgK9UdYhzB09ksGbQPbx8czlrssv4fHIRKhSFD+tvJAIDir1IfR0DZ3q5a6k7dszc1IoYUkVUUD6mGyyviN0tB3nzv5aR8WoVLatWkjPobFpp5TzXeTx8/cP4Cn2cnZ1Dzron8Hz3X1jw2mnOGXg2U3Kn8ObBN9n41ka853vZ99k+puROwdWk2kbqDtxWy+U5F7HzyE4KcgsiLAKlVFuhZPhJEOpkvPnDzXz42YdsfHNjXDdVtJswVjJDX6g/MRZJCom3EFcKHn64fSzvsGEwebK+zk6YAOecA488ogsOQ9fhdev0e+fN05lZ8eKMW7bo1zIztXLKyNA6YMECq4CRzlNuwy2VlhbIzFDMLAyyoMyFPBKVBwyoQJAgbtweiW1sHD+utx03TqeNmVoRg0061JzY2CZ6xK3y+9kyqpmfXXGKvx93LYuuWqT3ZbkMVF4eu97YxP+9ZRS7mg4we9xs6j+v52df/hmP73jccmHNwFcr2jMwuoVHCzMoGF2omzZaLeyVUh3SlsNlPt50HN/zPsYNHkf95/VtloWdwLmd3yFd2LVInBQj6fPES0gSiRzLO2WKvp040XJplRHR2yp8QmJJSdh1P0xTBYPS1vzxqafg61+HZ59R/NPXg/zySTevv67H3frmBiP6Fqm5JQTF0z7rxArjzJmju5zk5wt/ec3DLY2QE9U5USmo2OjpvMZkwwYt+AcfwPz5pnWvwRZ2s5NCq/MOjwM62UTy85lZV0fhsp/gHtLehTfkMmh5tRL/BUL+qEvYva+BvZ/uZeaYmYhI+2jgj6opuWMVnpISil0uCmLMJTnedJy1b6zlRPMJPvj0A+ZeNpccq7sw6FYvxfnFbRMfQwt2Oxlv0d+xL2BcW2kiNJa3vFzfFhXpjr733NOuZEJzRUI1IMXFYYopymUUqhVpaNDB/SOHFf86rILZTy9mzqEKxo1V2i1Ge+aY8uqMrZDXqbW1ve3ViBF6sz/9SWdSbtig56CEuxY6SVKhbYPqaq0Fx47V+cHdXFElmZ5v6A2S+KcFTwWo3bWF/LPzupedFJYhKV4vnnAlAiggcMdcMstX07RgHvXH9zP/8vms+doafAU+PAM9kS6lgbpNvWRkdHArKaV4bMdj7PtsH5+e/DRmZlYoaWDVDatQKJa8sISK2goAx7upuoOxSNJIm8WiFL65QUrmtruIwl1MM2boIVIRNRpRV3Ep0Rldc+fq90owiHuZn+Zr8hlZ6eehD0rwzvTg9rRnjgWVnjoYUgQnT8L2WkVxQZA7y9w0NQlHjmhLacsWbYzktC+ycLu1bJWVWslFGBvhWtDv173xPZ5uxd1NAXwfpDv/tLAWDe7HN/L95z7Ef8GHjF4wL/HspLAMyeiDrUMmVIGPkstv72AV2K2PCTYH2d6wncJRhbx/5H1uvfTWmBZEePv4UFxkzsVzIuaVnCkYiySNKAWB47olgyxZjGdjhY5hYGO1H6cmZeNG+Pa3YePTbqTIS/bHulHijyvczJ1rvdfSYG6PtO2ioABqaxQ3Hq1g4srFfP5QBdu2KiZOhJoabZVs3NhxcRlyh8UMsC9Zou+vWqUr85Fuxd27/C0MziPRf1q4hb1yJVJVxYQrZ1ESGKfbyMe70HZm9cTpsBAd5G60igw7VMnbDGqHAuLnuc/jO9O/w9JpS+O+Jzx43tLawr1/vjdmm3lb38/BGEWSJkLnzXdLg+xapwsHw0+4kJ7Yt08HzZcta7/4qlZF4GAQdXdpRHuRiHO3WgjO1W1VArf52LBRWLxYB/mt7tkRHUrKymBmYZChO/24Jubz8W/9NOwJcuiQbuQbGqIVfj0IfV74DJWIF/LztWvL0jTdVQg26jgNTiPRf1ogoE3bvDwdMCwoQOrrGfCFYt1GPhbdzAjsrK2LUopA03HU8eMx9xersDC8Jfw909oD8LEIbbt89nIyJZMxg8fEd9314YxH49rqIaJdOm0TEy9w4//Qy7gP/Awobj/hRHRNyezZcP/97Rffubcpti+sIGObn9ZpXoo3tAcho+uhXG6hYo2nrWPE0KE6Uwx0FldosRY6Txfc46ZJvGRUV/HkoQLOGuZi30646iodo4m+Hrhc7VnBEa/FKczq7sjcTrwUBqeSyD8tVlJGaWnsDqTh2Gg5FFu02G1ddObVarLXrse7HyZ8bT4S5pJrbW1l5WsrdSZXVAJAIgFxEWG4azgFowp00WNeUWzXXTe/nxMwiqQHiOUudrl0eu1TvxGmTfUxb3UJ5LSfNErprruhflahhR3BIBnb/LTk5pO1zU/wUAmekfrgij53Q8fhuHGweze8/z5cfDE8+SRs2xY50hd0xfugslKUaqJwTy27atcgV/kYNEh44AHrGG5thcOHUOcNZ80jGdTUaGVSWhp2vse5iISU45w5urVLIgrBtOTqg9j9p4UnZezdq5MyMjK6fm8iK5OolVysC3+wOUjt7koWf9DIe2crxr1ayQDr4q2UYsVrK1ixdQUXDbuIqvqqtjnrHT+q83RdpRRrtq9pi6uUTimN7Qrr7srLARjXVg8Qy6XT2KhrPW66CTKzhMaMSF9u6D1jxujtli/X12bPCDet07xkNdTROs2LcrkjLN5wt3DoOKyvhzvvhKVLYbDVmL+DOypEYyOyvZZJ1+czd6yf0YODFBXB00/DkkWt7J5egvJ6ab75FvyvnGbMGF3sHpr42Bkh5bhsmb7tQ5a6oScJP1CtpAxbhPtmOwvm23QRuQe4KRhfzI5xLiadcJP1hfYMkmBzkJq/1eAa6KJ6fzVNLU24slwxPirOOOEwwmM0tQ21NLbEOXnsfj8HYhSJTRKJgcVyF7vdOuU31sTE0HtmzNDzQ7xenY4b6pNVvMHHFa+W8+4XfCz5tsQ9N8KPw4ULtSJZs0YXNcZyVYULK/V1XLzAy0/W6CB9dTVcct4hznlvK4oMBmz6I77gQ+x/9zgzpquOGVuhE3fFiragjN0YSR+NLxq6SzIXzDgBdQiLZ1g1JV0deCKCr3AhNz+8iQlPbopwa7kHuCkcXUhjcyNTR08lOys7pgKw01QxVOm+55M9zDh/RucZaZ18PydjXFs2SDSzMZ67uCsXcoeMKMs8F7cbyfFQvRXy8xS1W4IE57ojRuKG7yOUYkwwSI7bxcKSRm4viVONHiasuN14rMJDrxf8rw7n8wkFDN/9R8jL48Idv+UutYPT2TNhoc7KCgbBrayixyNHtCJRCpYuxe2WLi11k+rbT4njButuVXfIMqiqr6Igdwr3zJhBRnV1ly4iEcGTnQPZHZ8vu6qMqvoqahtqGeEZ0dEiUQp3k8J7/gz8H1V32lRR0O414cw8uI1FYoPuZB/FWliEPxe9Cu+QERWIUYA4QzFucwXf/3Ax7o2dZHWEWwglJcjiRRGpxl0J27ZgXJ3BRa89ifzwh7RMmszxgNB8/oVkbPMTOBhsF2+DGzWlQJfpT5yoo/HBoK2Fp0n17eeEnQh23ETxCDYHqaqv4uiJo6x87WesvPwk6oEHooJ5iXHi9AkGZQ3i5ktuJlMyIy0S6xyTJUvw1QrlN6yKW40fbA7i/8jPhUMuxP+Rc1vBJ4NRJDZIdTpqLBduh88gqgCxMYivJEjJOD8TZuVrCyDeVbctRSxXR9lHjUr4Kt2mW7Iy4d57yXrsEQ7MnkfWx/W0TtM/QkTq8Z1lOqd42LAI311XlrpJ9e2HhJRHaNyndSIETwW6PXvDleVi8vDJ7Dz8Ppe7x3H2+idpufd7bcG57kwZdA9wU5RXRMPxA8w8twC3ZZEopQh8ehBlnQDi9+NpFlu1JE5uBZ8MpmmjTVLZGT3Ucj4/X19AQ30NIz4jVrNFsOcH6tCJMVNf3JP0G6lWRfBQEPdw/SN0ECV6Xr3d/Zqu8/2H8GOzoEBXv44Zo1v4rFpFxc6NCU8DDFkyr+57hS/+6T0mv/8J4z4VRnzjNmT//qT2G2g6TtajjzHote2I14sqLaVi+xr89VUseP00xX/L0lNNuzi3nNSIMRHsNm00iqQXUAoqVitqK4MUFLvxLYzTSTfWFdbuVTes/USX+fkJyh76eOhcFKMgzmy6dXGMXkVNmYLavp2maQVkLyrThawJ7jM0w2P8wFyufvDXXDn167grtyJjx8LMmQTumMviF5ZEzPjoqgYkpJxqd23h+xs/ZMKVs5D6egI/Xc7iLcv0vj7bR/nVD+IZMuKMPcDNPBIHIyh8UkG5LMYn9mMXcZ/r7L2h/PwUKZFwlxzE33UfLtI12KDb8YwoX6YqK2PtXVMoza2hYvsaIPGmhiHX0e6mA7TOmI7740+Q+fO1W8vnwx3dkNGaRNiZqyuUjTVyxIX4L4CWfR+A14t78PD2feUV4T6DlUgiGIukNwgEUIsX05ybz4CGOqSHZnYkaxFEvz+eSy4WiWxr6HvEmuRnu/V52IEVaA52fz8RuwybSxLDAg+3noAuW9ZHNHo8f4bu/2WtmnrUTeUwM95YJA5GudxUtnjZ9lQdlS26yDDlnxG7tKNb74+bENCJ2CaIfmaTVAA5zKpOVSC6reFiHAs8vCGjndqP8H5avsKFSExgMxcAABAkSURBVE5OWFZjD00s7MNmvLFIeoFAABYvUowfFWT3ATflP5eUr9ZDFsGRI+3Ds5Yutb/IsZUQ0MW+HLa4MqSYVK3M0x2ItjtEK+040Iw3FomDcbvBWyTsbvDgLZIeWa273TopJqq0IzEZY1gUiRTe9tEiXYNNUrUyT+UKXynF8abjHG86jgpNbotaLEdYG05RItCnzXhjkSRJd1fd6Vitt7Zqt1Ztbfeyf41FYehLhOaor/vrOlCKH+0dx8wDA2yl5zoGh510fc4iEZGhIrJJRHZbt0NibHOFiFSLyDsi8qaI3NIbsoZI2KUZVsWbjtV6aLzv8uVw222Jv99YFIa+RLA5SGV9JcFTQVQgQEb1VprPz01Ny4R0NYSzedJ1p8CyJ3GMIgHuA15USo0HXrQeR9MIfEsp9XfA9cBPRWRwOoSLdRwl1N6jFwJpoe673/wmXHcdrF7dp+J3BkNCuAe4Kc4rxj3QjXg8tM6YzoCPGpJ3EzksCJ5MK5mewkmK5BvAeuv+emBO9AZKqV1Kqd3W/QPAIeC8nhYs3nGUkEuzE63TU4udYFAPoQu1sQ/dj/X9TPddQ19Hd/P1sen2TWz61mZm/sdGpLwcVVpKoDnY/QtuTzeEizoB7da4dKeVTE/hJEUyQinVAGDdDu9sYxGZCgwE9sZ5vVREakSk5vDhw0kJFu84Sqgbdhyt05OLHbcbiq0RCy5X+/1wHLbYMhiSQkTIyc4hJzsHychAud1UbF+T3Oq9J4PgUSegam3t0tpwYu+utAbbRWQzMDLGSz8A1iulBodt+6lSqkOcxHotF3gZmKeU2trV5yYbbE9Zq/MYgbSezvgLLXYgtuvVgRmHBkPKSKpwMpyeCoJHnYARLVg6kTddKdN2g+1pnUeilJoV7zUROSgiuUqpBktRHIqz3dnA74F/s6NEUkG8+SLd2lHUVTredM1UHbcikJMT/3UnTPd0WKKK4QwitHoP1Yx0e/Ue49xNycU86gQMtWDpSt5EZsanA8ek/4rIg8BRpdSPROQ+YKhSalnUNgOBPwDPKaV+anffTitIjCb6QpqUBdSNq3JvXsjNYCtDV9iZiW7ndVeWi8aWxpSs4lNa1Bh1AjqpU3CfS/8FfgTMFpHdwGzrMSJSKCKPWtv8I1AMzBeRHdbfFb0jbuqIzvjrdmwvgYBHeHyvN9N8zWArQ2d0laFkJ4NJrFYsa+LFSrqRbZLSgHeHwXI91IKlB3GMIlFKHVVKXauUGm/dfmI9X6OUusu6v0EpNUApdUXY347elTz1dDu2Z/Oq7KQAex8u5jWkga4u2HYv6HG36+bJ4MSAd29iZrY7kG7HZGwGPKL1TUlJ7wXYUxZ/MpyRdBXjcGe5KB42hcojtbqte5wLetz9dPNkCLVZKbmspFvz5Z3iukoVjomR9CROj5GkFBsBDxOXMPQl4l54rQNZ+f1tg7EkI76TJeZ+0nwyOLZhZBzMhMQw+pUisYnJlDI4nS5X7qnKXU/jyZCydOQ00ReD7YY0YvpoGZyMrTYgqQqwpfFkOFNjK8YiMRgMjsP2yr0PmtZ9KUZiLBIHEC+rMNneVqY3luFMx/bKvS+Y1lEnbF9M7+0KY5H0EPFieMnG9hJ9fx9csBkMQN9aucelj2e2GIukl4lX0pFsAV4i73dSvYjBkCi9vnJPhenfTypujSLpIeLFAZONDyby/n5yDBsMqSdVq7B+UnFrXFs9SDy3UrLuJrvv7+NWtcHQe6SyLXYf9i87svtvvyDsoBGRmMdejEaiCWH3/aZq3GDoJqlsi53sCd8HMIoklTjQBOgHx7DBkFLagvylpYhZhdnCxEhSiQlKGAyOoauRtfHe47R56H0Bo0hSic3AWigZpLXV1IMYDCkhxtzz7iiEti7BZ+eRvXY9LYtKYcUKfbIa4mJcW6nERlAi5P2qqoLTpyEryzFeMIOh10iqZiSGSzm6bXzJZSW2elqFCiFrd22hZL8iSx3TikQpWLrUnKRxMBZJqumi0jbk/Ro1CrZtg9xc4wUz9G+SdifFcCl3t6dVqD38T25cw4TZ/4Ts3AkTJ0JtrTlJO8FYJGkm5P2qqoJp06Ch4YxOLzcYuqS71kMbMTKskpkXIiJ4snPgnnv0E7W1UFRkTtJOMHUkvUAoQ9jlgsbGBJNC+nBOusEQi5TM6Oip86Kfn29mHkkYTlMk3caB6cUGQyo4I/pqnYGYXltnIia92HCG0ut9tQxJYRRJX6Kf9O0xGOLRndoQQ89jgu19CdPzxNCP6WvzzvsTjrFIRGSoiGwSkd3W7ZAY2+SLSK2I7BCRd0RkYW/I2qv0hUE+BkMPEJ3dFWw2rl2n4BhFAtwHvKiUGg+8aD2OpgHwKqWuAKYB94nIqDTKaDAYeokzdd75mYBjsrZEZCdwtVKqQURygZeVUhM72X4Y8AYwXSl1oLN9nzFZWwZDP8dkd6WXvpi1NUIp1QBg3Q6PtZGIXCAibwL7gQfiKRERKRWRGhGpOXz4cI8JbTAY0ofJ7nImaQ22i8hmYGSMl35gdx9Kqf3AZZZL62kReUopdTDGdmuANaAtkm6KbDAYDIYuSKsiUUrNiveaiBwUkdww19ahLvZ1QETeAb4IPJViUQ0Gg8FgEye5tp4F5ln35wHPRG8gIueLyFnW/SFAEbAzbRIaDAbHYWpLeh8nKZIfAbNFZDcw23qMiBSKyKPWNpOAbSLyV2AL8JBS6q1ekdZgMPQ6ZhCVM3BMQaJS6ihwbYzna4C7rPubgMvSLJrBYHAoSXcONqQEJ1kkBoPBkBCmtsQZOKaOpCcxdSQGw5mLqS3pOezWkTjGtWUwGAzdIVRbYug9jGvLYDAYDElhFInBYDAYksIoEoPBYDAkhVEkBoPBYEgKo0gMBoPBkBRGkRgMBoMhKYwiMRgMBkNS9IuCRBE5DNT14EecCxzpwf0ni5Plc7Js4Gz5nCwbOFs+J8sGzpEvXyl1Xlcb9QtF0tOISI2d6s/ewsnyOVk2cLZ8TpYNnC2fk2UD58sXjXFtGQwGgyEpjCIxGAwGQ1IYRZIa1vS2AF3gZPmcLBs4Wz4nywbOls/JsoHz5YvAxEgMBoPBkBTGIjEYDAZDUhhFYjAYDIakMIqkG4jIUBHZJCK7rdshMba5QkSqReQdEXlTRG7pYZmuF5GdIrJHRO6L8Xq2iPzSen2biIzpSXm6Id8/i8i71m/1oojkO0W2sO1uEhElImlNy7Qjn4j8o/X7vSMiTzhJPhHJE5GXROQN6/97Qxple0xEDonI23FeFxFZYcn+pohMcZBscy2Z3hQRv4hcni7ZEkYpZf4S/AOWA/dZ9+8DHoixzQRgvHV/FNAADO4heTKBvcA4YCDwV+CSqG0WA6ut+7cCv0zj72VHvmsAl3V/UbrksyObtV0OUAlsBQod9tuNB94AhliPhztMvjXAIuv+JcC+NMpXDEwB3o7z+g3AHwABpgPbHCSbN+x/+uV0ypbon7FIusc3gPXW/fXAnOgNlFK7lFK7rfsHgENAlxWi3WQqsEcp9YFS6hTwpCVjPJmfAq6V9M0l7VI+pdRLSqlG6+FW4HynyGbxf9ALiJNpkiuEHfnuBlYppT4FUEodcph8Cjjbun8OcCBdwimlKoFPOtnkG8B/K81WYLCI5DpBNqWUP/Q/Jb3nRMIYRdI9RiilGgCs2+GdbSwiU9Grtb09JM9oYH/Y44+s52Juo5RqAY4Bw3pInmjsyBfOAvQqMR10KZuIXAlcoJR6Pk0yhWPnt5sATBCRKhHZKiLXp006e/LdD5SIyEfAC0BZekSzRaLHZm+RznMiYczM9jiIyGZgZIyXfpDgfnKBXwDzlFKtqZAt1sfEeC46r9vONj2F7c8WkRKgEJjZoxKFfWSM59pkE5EM4CfA/DTJE42d3y4L7d66Gr1qfUVELlVKfdbDsoE9+f4JWKeU+i8RmQH8wpKvp86HROjN88IWInINWpF8obdliYdRJHFQSs2K95qIHBSRXKVUg6UoYroSRORs4PfAv1lmc0/xEXBB2OPz6eg+CG3zkYhkoV0MnZn8qcSOfIjILLSinqmUanKIbDnApcDLlidwJPCsiHxdKVXjAPlC22xVSjUDH4rITrRied0h8i0ArgdQSlWLyCB0U8J0uuDiYevY7C1E5DLgUeDLSqmjvS1PPIxrq3s8C8yz7s8DnoneQEQGAr9D+19/3cPyvA6MF5Gx1ufeaskYTrjMNwF/UVYULw10KZ/lPqoAvp5mH3+nsimljimlzlVKjVFKjUH7qtOlRLqUz+JpdLICInIu2tX1gYPkqweuteSbBAwCDqdJvq54FviWlb01HTgWclv3NiKSB/wWuF0ptau35emU3o7298U/dGzhRWC3dTvUer4QeNS6XwI0AzvC/q7oQZluAHah4zA/sJ77d/RFD/TJ+2tgD/AaMC7Nv1lX8m0GDob9Vs86RbaobV8mjVlbNn87AX4MvAu8BdzqMPkuAarQGV07gOvSKNv/oDMmm9HWxwJgIbAw7LdbZcn+Vjr/tzZkexT4NOycqEnn/zWRP9MixWAwGAxJYVxbBoPBYEgKo0gMBoPBkBRGkRgMBoMhKYwiMRgMBkNSGEViMBgMhqQwisRgiIOIzLe6/V5kc/vnRGRlT8tlQ46zRKRBRG7ubVkM/QOjSAyGFCAixcBs4Ee9LYtS6gS6weR/isiA3pbHcOZjFInBkBruBZ5TSv2ttwWxWIdu/fHNXpbD0A8wisRgSBIRGYWeF/FE1PPniUiFiOwSkUYR2S8iT4hIl91lReR+EelQLSwi60RkX1fvV7r9+J+Au2x/EYOhmxhFYjAkz2z0gKdXo54fip5f8q/opoX3opspVlmNC3uaSmBmmj7L0I8x3X8NhuSZDhxQSkU0IlRK7QSWhh6LSCa651Q92oL5XQ/L9QZ6Ds4UwN/Dn2XoxxiLxGBInlHE6WYrIotE5K8iEgBa0EoEYGIa5ArJNCoNn2XoxxhFYjAkzyCgw/wUESkDytGdjf8BPZZ2eth7epoT1u1ZafgsQz/GuLYMhuQ5CoyN8fytwItKqe+FnhCRWNvF4qS1/UClZ6GHSGQ88lDr9kgC7zEYEsZYJAZD8rwPXGBNngzHhZ41Ec4dNvdZZ91eGnpCRAYD3gTkCimtnQm8x2BIGKNIDIbkqUS7qi6Lev6PwJdE5H+JyCwR+Q+0lRKBiMwUkRYR+VbY038AjgGPiMhXReRGdDpvIMb794jIizHkmgb8TSmVrmmJhn6KUSQGQ/K8gp7z/bWo5/8dPT74u+gMrcuAL8V4v6DTh9vOR6XUZ8BXgVbgV8B/AiuBl2K8P8t6fzRfAZ5M4HsYDN3CTEg0GFKAiNwPzAUmKAecVCIyDZ3yO0k5fd63oc9jFInBkAJE5BxgD7BIKfWUA+T5HfCpUurO3pbFcOZjsrYMhhSglDomIrfTninVa1iV7G8Aj/S2LIb+gbFIDAaDwZAUJthuMBgMhqQwisRgMBgMSWEUicFgMBiSwigSg8FgMCSFUSQGg8FgSIr/D/1cr4S7LiSaAAAAAElFTkSuQmCC\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -619,7 +642,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 38, "metadata": {}, "outputs": [], "source": [ @@ -655,7 +678,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 39, "metadata": {}, "outputs": [], "source": [ @@ -668,7 +691,7 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 40, "metadata": {}, "outputs": [], "source": [ @@ -677,7 +700,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 41, "metadata": {}, "outputs": [], "source": [ @@ -692,12 +715,12 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 42, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -735,7 +758,7 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 43, "metadata": {}, "outputs": [], "source": [ @@ -753,7 +776,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 44, "metadata": {}, "outputs": [], "source": [ @@ -767,7 +790,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 45, "metadata": {}, "outputs": [], "source": [ @@ -780,7 +803,7 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 46, "metadata": {}, "outputs": [], "source": [ @@ -789,7 +812,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 47, "metadata": {}, "outputs": [], "source": [ @@ -805,12 +828,12 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 48, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/qiskit/providers/aer/backends/pulse_simulator.py b/qiskit/providers/aer/backends/pulse_simulator.py index b5dada7cd2..e6a49ca900 100644 --- a/qiskit/providers/aer/backends/pulse_simulator.py +++ b/qiskit/providers/aer/backends/pulse_simulator.py @@ -93,7 +93,7 @@ def get_dressed_energies(self, qobj): """Digest the pulse qobj and return the eigenenergies of the Hamiltonian""" openpulse_system = digest_pulse_obj(qobj.to_dict()) - return openpulse_system.evals + return openpulse_system.evals, openpulse_system.estates def _validate(self, qobj, backend_options, noise_model): """Validate the pulse object. Make sure a diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index ae1ee1a8fe..0eeafc04a7 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -171,6 +171,7 @@ def digest_pulse_obj(qobj): out.h_diag = np.ascontiguousarray(h_diag.real) out.evals = evals + out.estates = estates # Set initial state out.initial_state = 0 * op.basis(len(evals), 1) diff --git a/qiskit/providers/aer/openpulse/solver/opsolve.py b/qiskit/providers/aer/openpulse/solver/opsolve.py index 6f2526040f..82788ad83a 100644 --- a/qiskit/providers/aer/openpulse/solver/opsolve.py +++ b/qiskit/providers/aer/openpulse/solver/opsolve.py @@ -173,7 +173,15 @@ def run(self): 'meas_return': m_ret, 'data': {}} - memory = exp_results[idx_exp] + if self.op_system.can_sample: + memory = exp_results[idx_exp][0] + results['data']['statevector'] = [] + for coef in exp_results[idx_exp][1]: + results['data']['statevector'].append([np.real(coef), + np.imag(coef)]) + results['header']['ode_t'] = exp_results[idx_exp][2] + else: + memory = exp_results[idx_exp] # meas_level 2 return the shots if m_lev == 2: @@ -182,8 +190,7 @@ def run(self): # integer # e.g. [1,0] -> 2 int_mem = memory.dot(np.power(2.0, - np.arange(memory.shape[1] - 1, - -1, -1))).astype(int) + np.arange(memory.shape[1]))).astype(int) # if the memory flag is set return each shot if self.op_system.global_data['memory']: diff --git a/qiskit/providers/aer/openpulse/solver/unitary.py b/qiskit/providers/aer/openpulse/solver/unitary.py index 6139cb1a46..9766559f58 100644 --- a/qiskit/providers/aer/openpulse/solver/unitary.py +++ b/qiskit/providers/aer/openpulse/solver/unitary.py @@ -98,4 +98,4 @@ def unitary_evolution(exp, global_data, ode_options): probs = occ_probabilities(qubits, psi, global_data['measurement_ops']) rand_vals = rng.rand(memory_slots.shape[0] * shots) write_shots_memory(memory, memory_slots, probs, rand_vals) - return memory + return [memory, psi, ODE.t] From 3e5fc867c4b1d341e8583b4b5d6fd8d255347de8 Mon Sep 17 00:00:00 2001 From: Juan Gomez Date: Mon, 4 Nov 2019 12:51:55 +0100 Subject: [PATCH 05/24] Fixing linter for OP --- qiskit/providers/aer/openpulse/qobj/opparse.py | 4 ++-- qiskit/providers/aer/openpulse/solver/monte_carlo.py | 3 ++- 2 files changed, 4 insertions(+), 3 deletions(-) diff --git a/qiskit/providers/aer/openpulse/qobj/opparse.py b/qiskit/providers/aer/openpulse/qobj/opparse.py index 53bee5c34e..c2b9419343 100644 --- a/qiskit/providers/aer/openpulse/qobj/opparse.py +++ b/qiskit/providers/aer/openpulse/qobj/opparse.py @@ -113,8 +113,8 @@ def _expand_sum(self): while any(ham_list): ham = ham_list.pop(0) - p_sums = [p for p in sum_str.finditer(ham)] - p_brks = [p for p in brk_str.finditer(ham)] + p_sums = list(sum_str.finditer(ham)) + p_brks = list(brk_str.finditer(ham)) if len(p_sums) != len(p_brks): raise Exception('Missing correct number of brackets in %s' % ham) diff --git a/qiskit/providers/aer/openpulse/solver/monte_carlo.py b/qiskit/providers/aer/openpulse/solver/monte_carlo.py index 679fef050b..fc6983922e 100644 --- a/qiskit/providers/aer/openpulse/solver/monte_carlo.py +++ b/qiskit/providers/aer/openpulse/solver/monte_carlo.py @@ -125,7 +125,8 @@ def monte_carlo(seed, exp, global_data, ode_options): if (abs(rand_vals[0] - norm2_guess) < ode_options.norm_tol * rand_vals[0]): break - elif norm2_guess < rand_vals[0]: + + if norm2_guess < rand_vals[0]: # t_guess is still > t_jump t_final = t_guess norm2_psi = norm2_guess From 99fa25b03a7a0024bc8fbe0fd92cce80a5f0571f Mon Sep 17 00:00:00 2001 From: Zachary Schoenfeld <15254979+zachschoenfeld33@users.noreply.github.com> Date: Fri, 8 Nov 2019 04:35:10 -0500 Subject: [PATCH 06/24] Pulse sim tests (#379) Add Pulse Simulator tests --- .gitignore | 1 + CHANGELOG.md | 2 +- qiskit/providers/aer/openpulse/readme.md | 41 +- test/terra/backends/test_pulse_simulator.py | 814 ++++++++++++++++++++ 4 files changed, 851 insertions(+), 7 deletions(-) create mode 100644 test/terra/backends/test_pulse_simulator.py diff --git a/.gitignore b/.gitignore index 66d02cb01b..d63da1eb63 100644 --- a/.gitignore +++ b/.gitignore @@ -11,6 +11,7 @@ *.o out/* *.so +rhs*_op.pyx *.pyc *_skbuild* *_cmake_test_compile* diff --git a/CHANGELOG.md b/CHANGELOG.md index 291931db46..6182bc16cc 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -20,7 +20,7 @@ Changelog](http://keepachangelog.com/en/1.0.0/). Added ----- - +- Added high level pulse simulator tests (\#379) Changed ------- diff --git a/qiskit/providers/aer/openpulse/readme.md b/qiskit/providers/aer/openpulse/readme.md index 87c74c5ed3..8b02dabd9b 100644 --- a/qiskit/providers/aer/openpulse/readme.md +++ b/qiskit/providers/aer/openpulse/readme.md @@ -3,8 +3,23 @@ This simulates job using the open pulse format (see the spec). ## Example +The Hamiltonian `H=-w_0 * \sigma_z/2 + w_1 * cos(w t + \phi) * \sigma_x/2` may be specified as: +``` +hamiltonian = {} +hamiltonian['h_str'] = [] -XXX +#Q0 terms +hamiltonian['h_str'].append('-0.5*w0*Z0') +hamiltonian['h_str'].append('0.5*w1*X0||D0') + +hamiltonian['vars'] = {'w0': (add w0 val here), 'w1': (add w1 value here)} + +# set the qubit dimension to 2 +hamiltonian['qub'] = {'0': 2} +``` +This Hamiltonian has a closed form in the rotating frame specified in the solving section. + +Note: Variable names must be lowercase (uppercase is reserved for operators). ## Hamiltonian @@ -15,10 +30,10 @@ the dynamics based on the pulse schedule. There are two allowed components to a simulation, *qubits* and *oscillators*. *Qubits* are the objects that will be measured at the end of the simulation. The operators for qubits are defined as Pauli's but if the number of levels -is defined by be greater than 2 these will be internally converted to +is defined to be greater than 2 these will be internally converted to creation and annhilation operators. -The Hamiltonian is a dictionary comparised of +The Hamiltonian is a dictionary comprised of - `h_str`: Definition of the Hamiltonian in terms of operators, drives and coefficients - `vars`: Numeric values for the variables in the Hamiltonian @@ -42,12 +57,21 @@ indicates one of the time-dependent drive channels (e.g. `D2` or `U10`). Additionally, there is a sum form `_SUM[i,n1,n2,F[{i}]]` where {i} is replaced in each loop by the value. +Available operators are: +{'X': sigmax, 'Y': sigmay, 'Z': sigmaz, + 'Sp': creation (sigma plus), 'Sm': destruction (sigma minus), 'I': identity, + 'O': number, 'P': projection, 'A': destruction, 'C': creation, 'N': number op} + + The following functions are also available: + {'cos': cos, 'sin': sin, 'exp': exp, + 'sqrt': sqrt, 'conj': complex conjugate, 'dag': dagger (Hermitian conjugate)} + ## Solving The solver takes the Hamiltonian (`H(t=0)`) and sets all drive/control channels to zero. -Consider `H_d` to be the diagonal elements of `H(t=0)`, then the transformation applied is -`U=e^{-i H_d t/hbar}`. For all drive/control channels, the LO is applied so -`d(t) -> D(t)e^{-i w t}`. If the drive is associated with some operator *B* then +Consider `H_d` to be the diagonal elements of `H(t=0)`, then the transformation applied to the statevector `\psi` is +`U=e^{-i H_d t/hbar}` (`\psi \rightarrow U \psi). For all drive/control channels, the LO is applied so +`d(t) -> D(t)e^{-i w t}`. The LO frequency `w` may be set in the pulse. If the drive is associated with some operator *B* then the upper triangular part of *B* is multiplied by `d(t)` and the lower triangular part by `d*(t)`. This ensures the Hamiltonian is Hermitian and also that in the transformed frame that a resonant pulse is close to DC. @@ -57,3 +81,8 @@ frame that a resonant pulse is close to DC. The measurement operators are the projections onto the 1 excitation subsystem for qubit `l` where qubit `l` is defined by diagonalizing `H(t=0)` (i.e. the dressed basis). +There are three measurement levels that return the data. +Measurement level `0` gives the raw data. +Measurement level `1` gives complex numbers (IQ values). +Measurement level `2` gives the discriminated states, `|0>` and `|1>`. + diff --git a/test/terra/backends/test_pulse_simulator.py b/test/terra/backends/test_pulse_simulator.py new file mode 100644 index 0000000000..2adac011b3 --- /dev/null +++ b/test/terra/backends/test_pulse_simulator.py @@ -0,0 +1,814 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +PulseSimulator Integration Tests +""" + +import unittest +from test.terra import common + +import numpy as np +from scipy.linalg import expm +from scipy.special import erf + +import qiskit +import qiskit.pulse as pulse + +from qiskit.compiler import assemble + +from qiskit.test.mock.fake_openpulse_2q import FakeOpenPulse2Q +from qiskit.pulse.commands import SamplePulse, FrameChange, PersistentValue + +class TestPulseSimulator(common.QiskitAerTestCase): + r"""PulseSimulator tests. + + Mathematical expressions are formulated in latex in docstrings for this class. + + # pylint: disable=anomalous backslash in string + Uses single qubit Hamiltonian `H = -\frac{1}{2} \omega_0 \sigma_z + \frac{1}{2} \omega_a + e^{i(\omega_{d0} t+\phi)} \sigma_x`. We make sure H is Hermitian by taking the complex conjugate + of the lower triangular piece (as done by the simulator). To find the closed form, we move + to a rotating frame via the unitary `Urot = e^{-i \omega t \sigma_z/2} + (\ket{psi_{rot}}=Urot \ket{psi_{rot}})`. In this frame, the Hamiltonian becomes + `Hrot = \frac{1}{2} \omega_a (\cos(\phi) \sigma_x - \sin(\phi) \sigma_y) + + \frac{\omega_{d0}-\omega_0}{2} \sigma_z`. + """ + def setUp(self): + """ Set configuration settings for pulse simulator """ + #Get a pulse configuration from the mock real device + self.backend_mock = FakeOpenPulse2Q() + self.back_config = self.backend_mock.configuration().to_dict() + self.system = pulse.PulseChannelSpec.from_backend(self.backend_mock) + self.defaults = self.backend_mock.defaults() + + # define the qubits + self.qubit_0 = 0 + self.freq_qubit_0 = self.defaults.qubit_freq_est[self.qubit_0] + + self.qubit_1 = 1 + self.freq_qubit_1 = self.defaults.qubit_freq_est[self.qubit_1] + + # 1q measurement map (so can measure the qubits seperately) + self.meas_map_1q = [[self.qubit_0], [self.qubit_1]] + # 2q measurement map + self.meas_map_2q = [[self.qubit_0, self.qubit_1]] + + # define the pulse time (# of samples) + self.drive_samples = 100 + + # Define acquisition + acq_cmd = pulse.Acquire(duration=self.drive_samples) + self.acq_0 = acq_cmd(self.system.acquires[self.qubit_0], + self.system.memoryslots[self.qubit_0]) + self.acq_01 = acq_cmd(self.system.acquires, self.system.memoryslots) + + #Get pulse simulator backend + self.backend_sim = qiskit.Aer.get_backend('pulse_simulator') + + def single_pulse_schedule(self, phi, shape="square", gauss_sigma=0): + """Creates schedule for single pulse test + Args: + phi (float): drive phase (phi in Hamiltonian) + shape (str): shape of the pulse; defaults to square pulse + gauss_sigma (float): std dev for gaussian pulse if shape=="gaussian" + Returns: + schedule (pulse schedule): schedule for this test + """ + # define default square drive pulse (add phase only; omega_a included in Hamiltonian) + const_pulse = np.ones(self.drive_samples) + phase = np.exp(1j*phi) + drive_pulse = SamplePulse(phase*const_pulse, name='drive_pulse') + + # create simple Gaussian drive if set this shape + if shape == "gaussian": + times = 1.0*np.arange(self.drive_samples) + gaussian = np.exp(-times**2/2/gauss_sigma**2) + drive_pulse = SamplePulse(gaussian, name='drive_pulse') + + # add commands to schedule + schedule = pulse.Schedule(name='drive_pulse') + schedule |= drive_pulse(self.system.qubits[self.qubit_0].drive) + + schedule |= self.acq_0 << schedule.duration + + return schedule + + + def frame_change_schedule(self, phi, fc_phi, dur_drive1, dur_drive2): + """Creates schedule for frame change test. Does a pulse w/ phase phi of duration dur_drive1, + then frame change of phase fc_phi, then another pulse of phase phi of duration dur_drive2. + The different durations for the pulses allow manipulation of rotation angles on Bloch sphere + Args: + phi (float): drive phase (phi in Hamiltonian) + fc_phi (float): phase for frame change + dur_drive1 (int): duration of first pulse + dur_drive2 (int): duration of second pulse + + Returns: + schedule (pulse schedule): schedule for frame change test + """ + # drive pulse (just phase; omega_a included in Hamiltonian) + phase = np.exp(1j*phi) + drive_pulse_1 = SamplePulse(phase*np.ones(dur_drive1), name='drive_pulse_1') + drive_pulse_2 = SamplePulse(phase*np.ones(dur_drive2), name='drive_pulse_2') + + # frame change + fc_pulse = FrameChange(phase=fc_phi, name='fc') + + # add commands to schedule + schedule = pulse.Schedule(name='fc_schedule') + schedule |= drive_pulse_1(self.system.qubits[self.qubit_0].drive) + schedule += fc_pulse(self.system.qubits[self.qubit_0].drive) + schedule += drive_pulse_2(self.system.qubits[self.qubit_0].drive) + schedule |= self.acq_0 << schedule.duration + + return schedule + + def persistent_value_schedule(self, omega_a_pv): + """Creates schedule for persistent value experiment. Creates pv pulse w/ drive amplitude + omega_a_pv. It does this by setting the omega_a term in the Hamiltonian = 1. Sets length of + the pv pulse = self.drive_samples. The product omega_a_pv*self.drive_samples, then, controls + the resulting state. + Args: + omega_a_pv (float): drive amplitude from the pv pulse + + Returns: + schedule (pulse schedule): schedule for pv experiment + """ + # pv pulse + pv_pulse = PersistentValue(value=omega_a_pv, name='pv') + + # add commands to schedule + schedule = pulse.Schedule(name='pv_schedule') + schedule |= pv_pulse(self.system.qubits[self.qubit_0].drive) + schedule |= self.acq_0 << self.drive_samples + + return schedule + + def schedule_2q(self): + """Creates schedule for testing two qubit interaction. Specifically, do a pi pulse on qub 0 + so it starts in the `1` state (drive channel) and then apply constant pulses to each + qubit (on control channel 1). This will allow us to test a swap gate. + Returns: + schedule (pulse schedule): schedule for 2q experiment + """ + # set up const pulse + const_pulse = SamplePulse(np.ones(self.drive_samples), name='const_pulse') + + # set u channel + uchannel = 1 # gives omega1-omega0 (we will set equal, so don't need negation) + + # add commands to schedule + schedule = pulse.Schedule(name='2q_schedule') + schedule |= const_pulse(self.system.qubits[self.qubit_0].drive) # pi pulse drive + schedule += const_pulse(self.system.controls[uchannel]) << schedule.duration # u chan pulse + schedule |= self.acq_01 << schedule.duration + + return schedule + + def create_ham_1q(self, omega_0, omega_a, qub_dim=2): + """Create single qubit Hamiltonian as given in class docstring + Args: + omega_0 (float): qubit 0 frequency + omega_a (float): drive amplitude + qub_dim (int): dimension of qubit subspace + Returns: + hamiltonian (dict): dictionary representation of single qubit hamiltonian + """ + + # Create the hamiltonian + hamiltonian = {} + hamiltonian['h_str'] = [] + + # Q0 terms + hamiltonian['h_str'].append('-0.5*omega0*Z0') + hamiltonian['h_str'].append('0.5*omegaa*X0||D0') + + # Q1 terms + # none + + # Set variables in ham + hamiltonian['vars'] = {'omega0': omega_0, 'omegaa': omega_a} + + # set the qubit dimension to qub_dim + hamiltonian['qub'] = {'0': qub_dim} + + return hamiltonian + + def create_ham_2q(self, omega_0, omega_a, omega_i, qub_dim=2): + """Create two qubit Hamiltonian as given in comment of interaction test + Args: + omega_0 (float): Q0 frequency + omega_a (float): Q0 drive amplitude + omega_i (float): interaction amplitude + qub_dim (int): dimension of qubit subspace (same for both qubits) + Returns: + hamiltonian (dict): dictionary representation of two qubit hamiltonian + """ + + # Create the hamiltonian + hamiltonian = {} + hamiltonian['h_str'] = [] + + # Q0 single qubit term (used to pi pulse Q0) + hamiltonian['h_str'].append('-0.5*omega0*Z0') + hamiltonian['h_str'].append('0.5*omegaa*X0||D0') + + # interaction term (uses U channels to get exponential piece) + hamiltonian['h_str'].append('omegai*Sp0*Sm1||U1') + hamiltonian['h_str'].append('omegai*Sm0*Sp1||U1') # U1 gives diff omega_d1-omega_d0 + + + # Set variables in ham + hamiltonian['vars'] = {'omega0': omega_0, 'omegaa': omega_a, 'omegai': omega_i} + + # set the qubit dimensions to qub_dim + hamiltonian['qub'] = {'0': qub_dim, '1': qub_dim} + + return hamiltonian + + def qobj_params_1q(self, omega_d0): + """Set params needed to create qobj for 1q tests + Args: + omega_d0 (float): qubit 0 drive (lo) frequency + Returns: + dict: contains qubit_list, memory_slots, qubit_lo_freq, meas_map for 1q qobj + """ + qubit_list = [self.qubit_0] + memory_slots = 1 + qubit_lo_freq = [omega_d0/(2*np.pi)] + meas_map = self.meas_map_1q + + return (qubit_list, memory_slots, qubit_lo_freq, meas_map) + + def qobj_params_2q(self, omega_d0, omega_d1): + """Set params needed to create qobj for 2q tests + Args: + omega_d0 (float): qubit 0 drive (lo) frequency + omega_d1 (float): qubit 1 drive (lo) frequency + Returns: + dict: contains qubit_list, memory_slots, qubit_lo_freq, meas_map for 2q qobj + """ + qubit_list = [self.qubit_0, self.qubit_1] + memory_slots = 2 + qubit_lo_freq = [omega_d0/(2*np.pi), omega_d1/(2*np.pi)] + meas_map = self.meas_map_2q + + return (qubit_list, memory_slots, qubit_lo_freq, meas_map) + + def create_qobj(self, shots, meas_level, schedule, hamiltonian, qobj_params): + """Creates qobj for the specified pulse experiment. Uses Hamiltonian from class docstring + (except for 2q tests, which use Hamiltonian specified in comment of that test section). + Args: + shots (int): number of times to perform experiment + meas_level (int): level of data to return + schedule (Schedule): pulse schedule for the qobj + hamiltonian (dict): dictionary representation of the Hamiltonian + qobj_params (tuple): tuple of qubit_list, memory_slots, qubit_lo_freq, meas_map + Returns: + Qobj: qobj representing this pulse experiment + """ + + # update the back_end + self.back_config['hamiltonian'] = hamiltonian + self.back_config['noise'] = {} + self.back_config['dt'] = 1.0 # makes time = self.drive_samples + + self.back_config['ode_options'] = {} # optionally set ode settings + + # set qobj params + qubit_list = qobj_params[0] + memory_slots = qobj_params[1] + qubit_lo_freq = qobj_params[2] + meas_map = qobj_params[3] + + self.back_config['qubit_list'] = qubit_list + + # construct the qobj + qobj = assemble([schedule], self.backend_mock, + meas_level=meas_level, meas_return='single', + meas_map=meas_map, qubit_lo_freq=qubit_lo_freq, + memory_slots=memory_slots, shots=shots, sim_config=self.back_config) + + return qobj + + #### SINGLE QUBIT TESTS ######################################################################## + + # --------------------------------------------------------------------- + # Test gates (using meas level 2 and square drive) + # --------------------------------------------------------------------- + + def test_x_gate(self): + """Test x gate. Set omega_d0=omega_0 (drive on resonance), phi=0, omega_a = pi/time + """ + + # set variables + + # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance + omega_0 = 2*np.pi*self.freq_qubit_0 + omega_d0 = omega_0 + + # Require omega_a*time = pi to implement pi pulse (x gate) + # num of samples gives time + omega_a = np.pi/self.drive_samples + + phi = 0 + + x_schedule = self.single_pulse_schedule(phi) + x_hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) + x_qobj_params = self.qobj_params_1q(omega_d0=omega_d0) + + x_qobj = self.create_qobj(shots=256, meas_level=2, schedule=x_schedule, + hamiltonian=x_hamiltonian, qobj_params=x_qobj_params) + result = self.backend_sim.run(x_qobj).result() + counts = result.get_counts() + exp_counts = {'1':256} + + self.assertDictAlmostEqual(counts, exp_counts) + + def test_hadamard_gate(self): + """Test Hadamard. Is a rotation of pi/2 about the y-axis. Set omega_d0=omega_0 + (drive on resonance), phi=-pi/2, omega_a = pi/2/time + """ + + # set variables + shots = 100000 # large number of shots so get good proportions + + # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance + omega_0 = 2*np.pi*self.freq_qubit_0 + omega_d0 = omega_0 + + # Require omega_a*time = pi/2 to implement pi/2 rotation pulse + # num of samples gives time + omega_a = np.pi/2/self.drive_samples + + phi = -np.pi/2 + + had_schedule = self.single_pulse_schedule(phi) + had_hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) + had_qobj_params = self.qobj_params_1q(omega_d0=omega_d0) + + had_qobj = self.create_qobj(shots=shots, meas_level=2, schedule=had_schedule, + hamiltonian=had_hamiltonian, qobj_params=had_qobj_params) + + result = self.backend_sim.run(had_qobj).result() + counts = result.get_counts() + + # compare prop + prop = {} + for key in counts.keys(): + prop[key] = counts[key]/shots + + exp_prop = {'0':0.5, '1':0.5} + + self.assertDictAlmostEqual(prop, exp_prop, delta=0.01) + + def _analytic_prop_1q_gates(self, omega_0, omega_a, omega_d0, phi): + """Compute proportion for 0 and 1 states analytically for single qubit gates. + Args: + omega_0 (float): Q0 freq + omega_a (float): Q0 drive amplitude + omega_d0 (flaot): Q0 drive frequency + phi (float): drive phase + Returns: + exp_prop (dict): expected value of 0 and 1 proportions from analytic computation + """ + time = self.drive_samples + # write Hrot analytically + h_rot = np.array([[(omega_d0-omega_0)/2, np.exp(1j*phi)*omega_a/2], + [np.exp(-1j*phi)*omega_a/2, -(omega_d0-omega_0)/2]]) + # exponentiate + u_rot = expm(-1j*h_rot*time) + state0 = np.array([1, 0]) + + # compute analytic prob (proportion) of 0 state + mat_elem0 = np.vdot(state0, np.dot(u_rot, state0)) + prop0 = np.abs(mat_elem0)**2 + + # return expected proportion + exp_prop = {'0': prop0, '1': 1-prop0} + return exp_prop + + def test_arbitrary_gate(self): + """Test a few examples w/ arbitary drive, phase and amplitude. """ + shots = 10000 # large number of shots so get good proportions + num_tests = 3 + # set variables for each test + omega_0 = 2*np.pi*self.freq_qubit_0 + omega_d0_vals = [omega_0+1, omega_0+0.02, omega_0+0.005] + omega_a_vals = [2*np.pi/3/self.drive_samples, 7*np.pi/5/self.drive_samples, 0.1] + phi_vals = [5*np.pi/7, 19*np.pi/14, np.pi/4] + + for i in range(num_tests): + with self.subTest(i=i): + schedule = self.single_pulse_schedule(phi_vals[i]) + hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_vals[i]) + qobj_params = self.qobj_params_1q(omega_d0=omega_d0_vals[i]) + + qobj = self.create_qobj(shots=shots, meas_level=2, schedule=schedule, + hamiltonian=hamiltonian, qobj_params=qobj_params) + + # Run qobj and compare prop to expected result + result = self.backend_sim.run(qobj).result() + counts = result.get_counts() + + prop = {} + for key in counts.keys(): + prop[key] = counts[key]/shots + + exp_prop = self._analytic_prop_1q_gates(omega_0=omega_0, omega_a=omega_a_vals[i], + omega_d0=omega_d0_vals[i], phi=phi_vals[i]) + + self.assertDictAlmostEqual(prop, exp_prop, delta=0.01) + + # --------------------------------------------------------------------- + # Test meas level 1 (using square drive) + # --------------------------------------------------------------------- + + def test_meas_level_1(self): + """Test measurement level 1. """ + + shots = 10000 # run large number of shots for good proportions + # perform hadamard setup (so get some 0's and some 1's), but use meas_level = 1 + + # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance + omega_0 = 2*np.pi*self.freq_qubit_0 + omega_d0 = omega_0 + + # Require omega_a*time = pi/2 to implement pi/2 rotation pulse + # num of samples gives time + omega_a = np.pi/2/self.drive_samples + + phi = -np.pi/2 + + schedule = self.single_pulse_schedule(phi) + hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) + qobj_params = self.qobj_params_1q(omega_d0=omega_d0) + + qobj = self.create_qobj(shots=shots, meas_level=1, schedule=schedule, + hamiltonian=hamiltonian, qobj_params=qobj_params) + result = self.backend_sim.run(qobj).result() + + # Verify that (about) half the IQ vals have abs val 1 and half have abs val 0 + # (use prop for easier comparison) + mem = np.abs(result.get_memory()[:, self.qubit_0]) + + iq_prop = {'0': 0, '1': 0} + for i in mem: + if i == 0: + iq_prop['0'] += 1/shots + else: + iq_prop['1'] += 1/shots + + exp_prop = {'0': 0.5, '1': 0.5} + + self.assertDictAlmostEqual(iq_prop, exp_prop, delta=0.01) + + # --------------------------------------------------------------------- + # Test Gaussian drive (using meas_level=2) + # --------------------------------------------------------------------- + + def _analytic_gaussian_statevector(self, gauss_sigma, omega_a): + r"""Computes analytic statevector for gaussian drive. Solving the Schrodinger equation in + the rotating frame leads to the analytic solution `(\cos(x), -i\sin(x)) with + `x = \frac{1}{2}\sqrt{\frac{\pi}{2}}\sigma\omega_a erf(\frac{t}{\sqrt{2}\sigma}). + Args: + gauss_sigma (float): std dev for the gaussian drive + omega_a (float): Q0 drive amplitude + Returns: + exp_statevector (list): analytic form of the statevector computed for gaussian drive + (Returned in the rotating frame) + """ + time = self.drive_samples + arg = 1/2*np.sqrt(np.pi/2)*gauss_sigma*omega_a*erf(time/np.sqrt(2)/gauss_sigma) + exp_statevector = [np.cos(arg), -1j*np.sin(arg)] + return exp_statevector + + def test_gaussian_drive(self): + """Test gaussian drive pulse using meas_level_2. Set omega_d0=omega_0 (drive on resonance), + phi=0, omega_a = pi/time + """ + + # set variables + + # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance + omega_0 = 2*np.pi*self.freq_qubit_0 + omega_d0 = omega_0 + + # Require omega_a*time = pi to implement pi pulse (x gate) + # num of samples gives time + omega_a = np.pi/self.drive_samples + + phi = 0 + + # Test gaussian drive results for a few different sigma + gauss_sigmas = {self.drive_samples/6, self.drive_samples/3, self.drive_samples} + for gauss_sigma in gauss_sigmas: + with self.subTest(gauss_sigma=gauss_sigma): + schedule = self.single_pulse_schedule(phi=phi, shape="gaussian", + gauss_sigma=gauss_sigma) + hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) + qobj_params = self.qobj_params_1q(omega_d0=omega_d0) + + qobj = self.create_qobj(shots=1000, meas_level=2, schedule=schedule, + hamiltonian=hamiltonian, qobj_params=qobj_params) + result = self.backend_sim.run(qobj).result() + statevector = result.get_statevector() + exp_statevector = self._analytic_gaussian_statevector(gauss_sigma=gauss_sigma, + omega_a=omega_a) + # compare statevectors element-wise (comparision only accurate to 1 dec place) + for i, _ in enumerate(statevector): + self.assertAlmostEqual(statevector[i], exp_statevector[i], places=1) + + # --------------------------------------------------------------------- + # Test FrameChange and PersistentValue commands + # --------------------------------------------------------------------- + + def _analytic_prop_fc(self, phi_net): + """Compute analytic proportion of 0 and 1 from a given frame change. Analytically can show + that the 0 prop is given by `cos(phi_net/2)^2` + Args: + phi_net (float): net rotation on Bloch sphere due to the frame change schedule + Returns: + exp_prop (dict): expected proportion of 0, 1 counts as computed analytically + """ + prop0 = np.cos(phi_net/2)**2 + exp_prop = {'0': prop0, '1': 1-prop0} + return exp_prop + + def test_frame_change(self): + """Test frame change command. """ + shots = 10000 + # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance + omega_0 = 2*np.pi*self.freq_qubit_0 + omega_d0 = omega_0 + + # set phi = 0 + phi = 0 + + dur_drive1 = self.drive_samples # first pulse duration + fc_phi = np.pi + + # Test frame change where no shift in state results + # specfically: do pi/2 pulse, then pi frame change, then another pi/2 pulse. + # Verify left in |0> state + dur_drive2_no_shift = dur_drive1 # same duration for both pulses + omega_a_no_shift = np.pi/2/dur_drive1 # pi/2 pulse amplitude + schedule_no_shift = self.frame_change_schedule(phi=phi, fc_phi=fc_phi, + dur_drive1=dur_drive1, + dur_drive2=dur_drive2_no_shift) + hamiltonian_no_shift = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_no_shift) + qobj_params_no_shift = self.qobj_params_1q(omega_d0=omega_d0) + + qobj_no_shift = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_no_shift, + hamiltonian=hamiltonian_no_shift, + qobj_params=qobj_params_no_shift) + + result_no_shift = self.backend_sim.run(qobj_no_shift).result() + counts_no_shift = result_no_shift.get_counts() + exp_result_no_shift = {'0':shots} + + self.assertDictAlmostEqual(counts_no_shift, exp_result_no_shift) + + # Test frame change where a shift does result + # specifically: do pi/4 pulse, then pi phase change, then do pi/8 pulse. + # check that a net rotation of pi/4-pi/8 has occured on the Bloch sphere + dur_drive2_shift = dur_drive1//2 # half time for second pulse (halves angle) + omega_a_shift = np.pi/4/dur_drive1 # pi/4 pulse amplitude + + + schedule_shift = self.frame_change_schedule(phi=phi, fc_phi=fc_phi, dur_drive1=dur_drive1, + dur_drive2=dur_drive2_shift) + hamiltonian_shift = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_shift) + qobj_params_shift = self.qobj_params_1q(omega_d0=omega_d0) + + qobj_shift = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_shift, + hamiltonian=hamiltonian_shift, qobj_params=qobj_params_shift) + + result_shift = self.backend_sim.run(qobj_shift).result() + counts_shift = result_shift.get_counts() + + # verify props + prop_shift = {} + for key in counts_shift.keys(): + prop_shift[key] = counts_shift[key]/shots + + # net angle is given by pi/4-pi/8 + exp_prop_shift = self._analytic_prop_fc(np.pi/4-np.pi/8) + self.assertDictAlmostEqual(prop_shift, exp_prop_shift, delta=0.01) + + def test_persistent_value(self): + """Test persistent value command. """ + + shots = 256 + # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance + omega_0 = 2*np.pi*self.freq_qubit_0 + omega_d0 = omega_0 + + # Set omega_a = 1 and do pi pulse w/ omega_a_pv. Verify result is the |1> state + omega_a = 1 + omega_a_pv = np.pi/self.drive_samples # pi pulse + + schedule = self.persistent_value_schedule(omega_a_pv) + hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) + qobj_params = self.qobj_params_1q(omega_d0=omega_d0) + + pv_qobj = self.create_qobj(shots=shots, meas_level=2, schedule=schedule, + hamiltonian=hamiltonian, qobj_params=qobj_params) + + result = self.backend_sim.run(pv_qobj).result() + counts = result.get_counts() + exp_result = {'1':shots} + + self.assertDictAlmostEqual(counts, exp_result) + + # --------------------------------------------------------------------- + # Test higher energy levels (take 3 level system for simplicity, + # use square drive) + # `\sigma_x \rightarrow a+\dagger{a}`, + # `\sigma_y \rightarrow -\imag (a-\dagger{a})`, etc + # --------------------------------------------------------------------- + + def _analytic_statevector_three_level(self, omega_a): + r"""Returns analytically computed statevector for 3 level system with our Hamiltonian. Is + given by `(\frac{1}{3} (2+\cos(\frac{\sqrt{3}}{2} \omega_a t)), + -\frac{i}{\sqrt{3}} \sin(\frac{\sqrt{3}}{2} \omega_a t), + -\frac{2\sqrt{2}}{3} \sin(\frac{\sqrt{3}}{4} \omega_a t)^2)`. + Args: + omega_a (float): Q0 drive amplitude + Returns: + exp_statevector (list): analytically computed statevector with Hamiltonian from above + (Returned in the rotating frame) + """ + time = self.drive_samples + arg1 = np.sqrt(3)*omega_a*time/2 # cos arg for first component + arg2 = arg1 # sin arg for first component + arg3 = arg1/2 # sin arg for 3rd component + exp_statevector = [(2+np.cos(arg1))/3, -1j*np.sin(arg2)/np.sqrt(3), + -2*np.sqrt(2)*np.sin(arg3)**2/3] + + return exp_statevector + + def test_three_level(self): + r"""Test 3 level system. Compare statevectors as counts only use bitstrings. Analytic form + given in _analytic_statevector_3level function docstring. + """ + + shots = 1000 + # set omega_0,omega_d0 (use qubit frequency) -> drive on resonance + omega_0 = 2*np.pi*self.freq_qubit_0 + omega_d0 = omega_0 + + # set phi = 0 for simplicity + phi = 0 + + # Test pi pulse + omega_a_pi = np.pi/self.drive_samples + + schedule_pi = self.single_pulse_schedule(phi) + # set qub_dim=3 in hamiltonian + hamiltonian_pi = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_pi, qub_dim=3) + qobj_params_pi = self.qobj_params_1q(omega_d0=omega_d0) + + qobj_pi = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_pi, + hamiltonian=hamiltonian_pi, qobj_params=qobj_params_pi) + + result_pi = self.backend_sim.run(qobj_pi).result() + statevector_pi = result_pi.get_statevector() + + exp_statevector_pi = self._analytic_statevector_three_level(omega_a_pi) + + # compare vectors element-wise + for i, _ in enumerate(statevector_pi): + self.assertAlmostEqual(statevector_pi[i], exp_statevector_pi[i], places=4) + + # Test 2*pi pulse + omega_a_2pi = 2*np.pi/self.drive_samples + + schedule_2pi = self.single_pulse_schedule(phi) + # set qub_dim=3 in hamiltonian + hamiltonian_2pi = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_2pi, qub_dim=3) + qobj_params_2pi = self.qobj_params_1q(omega_d0=omega_d0) + + qobj_2pi = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_2pi, + hamiltonian=hamiltonian_2pi, qobj_params=qobj_params_2pi) + + result_2pi = self.backend_sim.run(qobj_2pi).result() + statevector_2pi = result_2pi.get_statevector() + + exp_statevector_2pi = self._analytic_statevector_three_level(omega_a_2pi) + + # compare vectors element-wise + for i, _ in enumerate(statevector_2pi): + self.assertAlmostEqual(statevector_2pi[i], exp_statevector_2pi[i], places=4) + + #### TWO QUBIT TESTS ########################################################################### + + # ---------------------------------------------------------------------------------------------- + # Test qubit interaction (use 2 qubits for simplicity) + # For these tests, we use a different 2-qubit Hamiltonian that tests both + # interaction and control (U) channels. In the lab frame, it is given + # by `H = -\frac{1}{2} \omega_0 \sigma_z^0 + \frac{1}{2} \omega_a e^{i \omega_{d0} t} \sigma_x^0 + # `+ \omega_i (e^{i (\omega_{d0}-\omega_{d1}) t} \sigma_{p0} \otimes \sigma_{m1} + ` + # `+ e^{-i (\omega_{d0}-\omega_{d1}) t} \sigma_{m0} \otimes \sigma_{p1})`. First 2 terms allow + # us to excite the 0 qubit. Latter 2 terms define the interaction. + # ---------------------------------------------------------------------------------------------- + + def test_interaction(self): + r"""Test 2 qubit interaction via swap gates.""" + + shots = 100000 + + # Do a standard SWAP gate + + # Interaction amp (any non-zero creates the swap gate) + omega_i_swap = np.pi/2/self.drive_samples + # set omega_d0=omega_0 (resonance) + omega_0 = 2*np.pi*self.freq_qubit_0 + omega_d0 = omega_0 + + # For swapping, set omega_d1 = 0 (drive on Q0 resonance) + omega_d1_swap = 0 + + # do pi pulse on Q0 and verify state swaps from '01' to '10' (reverse bit order) + + # Q0 drive amp -> pi pulse + omega_a_pi_swap = np.pi/self.drive_samples + + schedule_pi_swap = self.schedule_2q() + hamiltonian_pi_swap = self.create_ham_2q(omega_0=omega_0, omega_a=omega_a_pi_swap, + omega_i=omega_i_swap) + qobj_params_pi_swap = self.qobj_params_2q(omega_d0=omega_d0, omega_d1=omega_d1_swap) + + qobj_pi_swap = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_pi_swap, + hamiltonian=hamiltonian_pi_swap, + qobj_params=qobj_params_pi_swap) + + result_pi_swap = self.backend_sim.run(qobj_pi_swap).result() + counts_pi_swap = result_pi_swap.get_counts() + + exp_counts_pi_swap = {'10': shots} # reverse bit order (qiskit convention) + self.assertDictAlmostEqual(counts_pi_swap, exp_counts_pi_swap, delta=2) + + # do pi/2 pulse on Q0 and verify half the counts are '00' and half are swapped state '10' + + # Q0 drive amp -> pi/2 pulse + omega_a_pi2_swap = np.pi/2/self.drive_samples + + schedule_pi2_swap = self.schedule_2q() + hamiltonian_pi2_swap = self.create_ham_2q(omega_0=omega_0, omega_a=omega_a_pi2_swap, + omega_i=omega_i_swap) + qobj_params_pi2_swap = self.qobj_params_2q(omega_d0=omega_d0, omega_d1=omega_d1_swap) + + qobj_pi2_swap = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_pi2_swap, + hamiltonian=hamiltonian_pi2_swap, + qobj_params=qobj_params_pi2_swap) + + result_pi2_swap = self.backend_sim.run(qobj_pi2_swap).result() + counts_pi2_swap = result_pi2_swap.get_counts() + + # compare proportions for improved accuracy + prop_pi2_swap = {} + for key in counts_pi2_swap.keys(): + prop_pi2_swap[key] = counts_pi2_swap[key]/shots + + exp_prop_pi2_swap = {'00':0.5, '10':0.5} # reverse bit order + + self.assertDictAlmostEqual(prop_pi2_swap, exp_prop_pi2_swap, delta=0.01) + + # Test that no SWAP occurs when omega_i=0 (no interaction) + omega_i_no_swap = 0 + + # Set arbitrary params for omega_d0, omega_d1 + omega_d1_no_swap = omega_d0 + + # Q0 drive amp -> pi pulse + omega_a_no_swap = np.pi/self.drive_samples + + schedule_no_swap = self.schedule_2q() + hamiltonian_no_swap = self.create_ham_2q(omega_0=omega_0, omega_a=omega_a_no_swap, + omega_i=omega_i_no_swap) + qobj_params_no_swap = self.qobj_params_2q(omega_d0=omega_d0, omega_d1=omega_d1_no_swap) + + qobj_no_swap = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_no_swap, + hamiltonian=hamiltonian_no_swap, + qobj_params=qobj_params_no_swap) + + result_no_swap = self.backend_sim.run(qobj_no_swap).result() + counts_no_swap = result_no_swap.get_counts() + + exp_counts_no_swap = {'01': shots} # non-swapped state (reverse bit order) + self.assertDictAlmostEqual(counts_no_swap, exp_counts_no_swap) + +if __name__ == '__main__': + unittest.main() From 35e2ce526c0e5f7a4d232ea991cbf6148a3d3120 Mon Sep 17 00:00:00 2001 From: Zachary Schoenfeld <15254979+zachschoenfeld33@users.noreply.github.com> Date: Thu, 14 Nov 2019 11:43:41 -0500 Subject: [PATCH 07/24] Comment abt meas level 1 (#447) --- test/terra/backends/test_pulse_simulator.py | 3 +++ 1 file changed, 3 insertions(+) diff --git a/test/terra/backends/test_pulse_simulator.py b/test/terra/backends/test_pulse_simulator.py index 2adac011b3..6259bf0e42 100644 --- a/test/terra/backends/test_pulse_simulator.py +++ b/test/terra/backends/test_pulse_simulator.py @@ -433,6 +433,9 @@ def test_arbitrary_gate(self): # --------------------------------------------------------------------- # Test meas level 1 (using square drive) + # Note: the simulator generates approximate IQ data with the proper + # data structure; it should not, however, be compared with an actual + # device. # --------------------------------------------------------------------- def test_meas_level_1(self): From 725da05a5953e006970a3517a5d4463cc5ddc09a Mon Sep 17 00:00:00 2001 From: Paul Nation Date: Sun, 17 Nov 2019 08:09:06 -0500 Subject: [PATCH 08/24] Fix indexing error in FC (#451) --- qiskit/providers/aer/openpulse/cy/channel_value.pyx | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/qiskit/providers/aer/openpulse/cy/channel_value.pyx b/qiskit/providers/aer/openpulse/cy/channel_value.pyx index 54c268ec56..0872144012 100644 --- a/qiskit/providers/aer/openpulse/cy/channel_value.pyx +++ b/qiskit/providers/aer/openpulse/cy/channel_value.pyx @@ -87,7 +87,7 @@ cdef complex chan_value(double t, break # Compute the frame change up to time t if out != 0: - num_times = fc_array.shape[0] + num_times = fc_array.shape[0] // 3 for kk in range(num_times): if t >= fc_array[3*kk]: do_fc = 1 @@ -104,4 +104,4 @@ cdef complex chan_value(double t, if phase != 0: out *= exp(1j*phase) out *= exp(-1j*2*M_PI*freq_ch*t) - return out \ No newline at end of file + return out From a91f113200ed7e6bcf500b98679acf0b333775bc Mon Sep 17 00:00:00 2001 From: "Christopher J. Wood" Date: Sun, 17 Nov 2019 19:05:32 -0500 Subject: [PATCH 09/24] Add backend_options to PulseSimulator.run (#435) * Add backend_options to PulseSimulator.run * Update pulse simulator example notebook * Update pulse tests --- example/pulse_sim.ipynb | 165 +++--- .../providers/aer/backends/pulse_simulator.py | 49 +- qiskit/providers/aer/openpulse/qobj/digest.py | 34 +- test/terra/backends/test_pulse_simulator.py | 524 +++++++++++------- 4 files changed, 456 insertions(+), 316 deletions(-) diff --git a/example/pulse_sim.ipynb b/example/pulse_sim.ipynb index 5b3f80a789..db629c5537 100644 --- a/example/pulse_sim.ipynb +++ b/example/pulse_sim.ipynb @@ -45,7 +45,7 @@ "source": [ "#Get a pulse configuration from the fake backend\n", "backend_real = FakeOpenPulse2Q()\n", - "back_config = backend_real.configuration().to_dict()\n", + "configuration = backend_real.configuration()\n", "system = pulse.PulseChannelSpec.from_backend(backend_real)" ] }, @@ -198,35 +198,44 @@ " 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33}\n", "\n", "#set the qubit dimensions to 3\n", - "hamiltonian['qub'] = {'0': 3, '1': 3}\n", - "\n", - "#update the back_end\n", - "back_config['hamiltonian'] = hamiltonian\n", - "back_config['noise'] = {}\n", - "back_config['dt'] = 1.0" + "hamiltonian['qub'] = {'0': 3, '1': 3}" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Add Solver Settings" + "### Setup backend_options for simulation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Any solver settings also does into the back_config" + "First copy the real-device configuration to our backend options, then override the Hamiltonian with our custom Hamiltonian, and add any additional solver options." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/cjwood/git/qiskit/qiskit-terra/qiskit/providers/models/backendconfiguration.py:348: UserWarning: The time delta is now returned in units of [s] rather than [ns].\n", + " warnings.warn(\"The time delta is now returned in units of [s] rather than [ns].\")\n", + "/Users/cjwood/git/qiskit/qiskit-terra/qiskit/providers/models/backendconfiguration.py:354: UserWarning: The time delta is now returned in units of [s] rather than [ns].\n", + " warnings.warn(\"The time delta is now returned in units of [s] rather than [ns].\")\n" + ] + } + ], "source": [ - "back_config['ode_options'] = {}" + "backend_options = configuration.to_dict()\n", + "backend_options['hamiltonian'] = hamiltonian\n", + "backend_options['dt'] = 1.0\n", + "backend_options['ode_options'] = {}" ] }, { @@ -249,8 +258,8 @@ "metadata": {}, "outputs": [], "source": [ - "back_config['qubit_list'] = [0,1]\n", - "#back_config['qubit_list'] = None" + "backend_options['qubit_list'] = [0, 1]\n", + "#backend_options['qubit_list'] = None" ] }, { @@ -269,28 +278,29 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "rabi_qobj = assemble(schedules, backend_real, \n", - " meas_level=1, meas_return='avg', \n", - " memory_slots=2,\n", - " shots=shots, sim_config = back_config)" + "rabi_qobj_no_lo = assemble(schedules, backend_real, \n", + " meas_level=1, meas_return='avg', \n", + " memory_slots=2,\n", + " shots=shots)" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ - "evals, estates = backend_sim.get_dressed_energies(rabi_qobj)" + "evals, estates = backend_sim.get_dressed_energies(rabi_qobj_no_lo,\n", + " backend_options=backend_options)" ] }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -300,7 +310,7 @@ " 14.76614835, 9.86913744, 14.87385165, 19.54 ])" ] }, - "execution_count": 24, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -311,15 +321,16 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ + "qubit_lo_freq = [evals[1]/2/np.pi, evals[3]/2/np.pi]\n", + "\n", "rabi_qobj = assemble(schedules, backend_real, \n", " meas_level=1, meas_return='avg', \n", - " memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi,\n", - " evals[3]/2/np.pi],\n", - " shots=shots, sim_config = back_config)" + " memory_slots=2, qubit_lo_freq=qubit_lo_freq,\n", + " shots=shots)" ] }, { @@ -331,7 +342,7 @@ }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 12, "metadata": {}, "outputs": [], "source": [ @@ -342,16 +353,16 @@ }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ - "sim_result = backend_sim.run(rabi_qobj).result()" + "sim_result = backend_sim.run(rabi_qobj, backend_options=backend_options).result()" ] }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 14, "metadata": {}, "outputs": [ { @@ -360,7 +371,7 @@ "128.0" ] }, - "execution_count": 28, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" } @@ -372,7 +383,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 15, "metadata": {}, "outputs": [ { @@ -382,7 +393,7 @@ " 0.+0.j])" ] }, - "execution_count": 29, + "execution_count": 15, "metadata": {}, "output_type": "execute_result" } @@ -401,7 +412,7 @@ }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -416,19 +427,19 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Pi Amplitude 0.313255\n" + "Pi Amplitude 0.315858\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -477,7 +488,7 @@ }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -521,24 +532,23 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ "readout_qobj = assemble(excited_exp_schedules, backend_real, \n", " meas_level=1, meas_return='single', \n", - " memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi,\n", - " evals[3]/2/np.pi],\n", - " shots=shots, sim_config = back_config)" + " memory_slots=2, qubit_lo_freq=qubit_lo_freq,\n", + " shots=shots)" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "sim_result = backend_sim.run(readout_qobj).result()" + "sim_result = backend_sim.run(readout_qobj, backend_options=backend_options).result()" ] }, { @@ -550,7 +560,7 @@ }, { "cell_type": "code", - "execution_count": 35, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ @@ -568,7 +578,7 @@ }, { "cell_type": "code", - "execution_count": 36, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -580,7 +590,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 23, "metadata": {}, "outputs": [ { @@ -589,13 +599,13 @@ "Text(0, 0.5, 'Q (a.u.)')" ] }, - "execution_count": 37, + "execution_count": 23, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -642,7 +652,7 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -678,29 +688,28 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ "cr_rabi_qobj = assemble(schedules, backend_real, \n", " meas_level=1, meas_return='avg', \n", - " memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi,\n", - " evals[3]/2/np.pi],\n", - " shots=shots, sim_config = back_config)" + " memory_slots=2, qubit_lo_freq=qubit_lo_freq,\n", + " shots=shots)" ] }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ - "sim_result = backend_sim.run(cr_rabi_qobj).result()" + "sim_result = backend_sim.run(cr_rabi_qobj, backend_options=backend_options).result()" ] }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 27, "metadata": {}, "outputs": [], "source": [ @@ -715,12 +724,12 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 28, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -758,7 +767,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 29, "metadata": {}, "outputs": [], "source": [ @@ -776,43 +785,40 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 30, "metadata": {}, "outputs": [], "source": [ "# Add noise to the Hamiltonian on qubit '0'\n", - "back_config['noise'] = {\"qubit\": \n", - " {\"0\": \n", - " {\"Sm\": 0.006\n", - " }}}\n", - "#back_config['noise'] = {}" + "noise_model = {\"qubit\": {\"0\": {\"Sm\": 0.006}}}" ] }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 31, "metadata": {}, "outputs": [], "source": [ "t1_qobj = assemble(T1_exps, backend_real, \n", " meas_level=1, meas_return='avg', \n", - " memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi,\n", - " evals[3]/2/np.pi],\n", - " shots=100, sim_config = back_config)" + " memory_slots=2, qubit_lo_freq=qubit_lo_freq,\n", + " shots=100)" ] }, { "cell_type": "code", - "execution_count": 46, + "execution_count": 32, "metadata": {}, "outputs": [], "source": [ - "sim_result_t1 = backend_sim.run(t1_qobj).result()" + "sim_result_t1 = backend_sim.run(t1_qobj,\n", + " backend_options=backend_options,\n", + " noise_model=noise_model).result()" ] }, { "cell_type": "code", - "execution_count": 47, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ @@ -828,12 +834,12 @@ }, { "cell_type": "code", - "execution_count": 48, + "execution_count": 34, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -861,13 +867,6 @@ "plt.title('T1 on Q0', fontsize=20)\n", "plt.grid(True)\n" ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] } ], "metadata": { @@ -886,7 +885,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.6.8" + "version": "3.7.4" } }, "nbformat": 4, diff --git a/qiskit/providers/aer/backends/pulse_simulator.py b/qiskit/providers/aer/backends/pulse_simulator.py index e6a49ca900..402c449857 100644 --- a/qiskit/providers/aer/backends/pulse_simulator.py +++ b/qiskit/providers/aer/backends/pulse_simulator.py @@ -36,7 +36,7 @@ class PulseSimulator(AerBackend): """ DEFAULT_CONFIGURATION = { 'backend_name': 'pulse_simulator', - 'backend_version': "0.0.1", + 'backend_version': __version__, 'n_qubits': 20, 'coupling_map': None, 'url': 'https://github.com/Qiskit/qiskit-aer', @@ -56,21 +56,30 @@ def __init__(self, configuration=None, provider=None): BackendConfiguration.from_dict(self.DEFAULT_CONFIGURATION), provider=provider) - def run(self, qobj, validate=False): + def run(self, qobj, + backend_options=None, + noise_model=None, + validate=False): """Run a qobj on the backend.""" # Submit job job_id = str(uuid.uuid4()) aer_job = AerJob(self, job_id, self._run_job, qobj, - None, None, validate) + backend_options, noise_model, validate) aer_job.submit() return aer_job - def _run_job(self, job_id, qobj, backend_options, noise_model, validate): + def _run_job(self, job_id, qobj, + backend_options, + noise_model, + validate): """Run a qobj job""" start = time.time() if validate: self._validate(qobj, backend_options, noise_model) - openpulse_system = digest_pulse_obj(qobj.to_dict()) + # Send to solver + qobj_dict = self._format_qobj_dict(qobj, backend_options, + noise_model) + openpulse_system = digest_pulse_obj(qobj_dict) results = opsolve(openpulse_system) end = time.time() return self._format_results(job_id, results, end - start, qobj.qobj_id) @@ -89,10 +98,36 @@ def _format_results(self, job_id, results, time_taken, qobj_id): output["time_taken"] = time_taken return Result.from_dict(output) - def get_dressed_energies(self, qobj): + def _format_qobj_dict(self, qobj, backend_options, noise_model): + """Add additional fields to qobj dictionary""" + # Convert qobj to dict and add additional fields + qobj_dict = qobj.to_dict() + if 'backend_options' not in qobj_dict['config']: + qobj_dict['config']['backend_options'] = {} + + # Temp backwards compatibility + if 'sim_config' in qobj_dict['config']: + for key, val in qobj_dict['config']['sim_config'].itmes(): + qobj_dict['config']['backend_options'][key] = val + qobj_dict['config'].pop('sim_config') + + # Add additional backend options + if backend_options is not None: + for key, val in backend_options.items(): + qobj_dict['config']['backend_options'][key] = val + # Add noise model + if noise_model is not None: + qobj_dict['config']['backend_options']['noise_model'] = noise_model + return qobj_dict + + def get_dressed_energies(self, qobj, + backend_options=None, + noise_model=None): """Digest the pulse qobj and return the eigenenergies of the Hamiltonian""" - openpulse_system = digest_pulse_obj(qobj.to_dict()) + qobj_dict = self._format_qobj_dict(qobj, backend_options, + noise_model) + openpulse_system = digest_pulse_obj(qobj_dict) return openpulse_system.evals, openpulse_system.estates def _validate(self, qobj, backend_options, noise_model): diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 0eeafc04a7..7037fcaf65 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -46,10 +46,17 @@ def digest_pulse_obj(qobj): # Output data object out = OPSystem() - # get the config settings from the qobj - config_dict_sim = qobj['config']['sim_config'] + # Get the config settings from the qobj config_dict = qobj['config'] + if 'backend_options' not in config_dict: + raise ValueError('Pulse Qobj must have "sim_config".') + config_dict_sim = config_dict['backend_options'] + noise_dict = config_dict_sim.get('noise_model', {}) + if 'hamiltonian' not in config_dict_sim: + raise ValueError('Qobj must have hamiltonian in config to simulate.') + hamiltonian = config_dict_sim['hamiltonian'] + # Get qubit number qubit_list = config_dict_sim.get('qubit_list', None) if qubit_list is None: qubit_list = list(range(config_dict_sim['n_qubits'])) @@ -109,28 +116,23 @@ def digest_pulse_obj(qobj): out.ode_options = OPoptions(**user_set_ode_options) # Step #1: Parse hamiltonian representation - if 'hamiltonian' not in config_keys_sim: - raise ValueError('Qobj must have hamiltonian in config to simulate.') - - ham = config_dict_sim['hamiltonian'] - - out.vars = OrderedDict(ham['vars']) + out.vars = OrderedDict(hamiltonian['vars']) out.global_data['vars'] = list(out.vars.values()) # Get qubit subspace dimensions - if 'qub' in ham.keys(): - dim_qub = ham['qub'] + if 'qub' in hamiltonian.keys(): + dim_qub = hamiltonian['qub'] _dim_qub = {} # Convert str keys to int keys - for key, val in ham['qub'].items(): + for key, val in hamiltonian['qub'].items(): _dim_qub[int(key)] = val dim_qub = _dim_qub else: dim_qub = {}.fromkeys(range(config_dict_sim['n_qubits']), 2) # Get oscillator subspace dimensions - if 'osc' in ham.keys(): - dim_osc = ham['osc'] + if 'osc' in hamiltonian.keys(): + dim_osc = hamiltonian['osc'] _dim_osc = {} # Convert str keys to int keys for key, val in dim_osc.items(): @@ -140,14 +142,14 @@ def digest_pulse_obj(qobj): dim_osc = {} # Parse the Hamiltonian - system = HamiltonianParser(h_str=ham['h_str'], + system = HamiltonianParser(h_str=hamiltonian['h_str'], dim_osc=dim_osc, dim_qub=dim_qub) system.parse(qubit_list) out.system = system.compiled - if 'noise' in config_dict_sim.keys(): - noise = NoiseParser(noise_dict=config_dict_sim['noise'], + if noise_dict: + noise = NoiseParser(noise_dict=noise_dict, dim_osc=dim_osc, dim_qub=dim_qub) noise.parse() diff --git a/test/terra/backends/test_pulse_simulator.py b/test/terra/backends/test_pulse_simulator.py index 6259bf0e42..4bdfbc44a1 100644 --- a/test/terra/backends/test_pulse_simulator.py +++ b/test/terra/backends/test_pulse_simulator.py @@ -9,7 +9,6 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. - """ PulseSimulator Integration Tests """ @@ -29,6 +28,7 @@ from qiskit.test.mock.fake_openpulse_2q import FakeOpenPulse2Q from qiskit.pulse.commands import SamplePulse, FrameChange, PersistentValue + class TestPulseSimulator(common.QiskitAerTestCase): r"""PulseSimulator tests. @@ -45,9 +45,8 @@ class TestPulseSimulator(common.QiskitAerTestCase): """ def setUp(self): """ Set configuration settings for pulse simulator """ - #Get a pulse configuration from the mock real device + # Get a pulse configuration from the mock real device self.backend_mock = FakeOpenPulse2Q() - self.back_config = self.backend_mock.configuration().to_dict() self.system = pulse.PulseChannelSpec.from_backend(self.backend_mock) self.defaults = self.backend_mock.defaults() @@ -72,7 +71,7 @@ def setUp(self): self.system.memoryslots[self.qubit_0]) self.acq_01 = acq_cmd(self.system.acquires, self.system.memoryslots) - #Get pulse simulator backend + # Get pulse simulator backend self.backend_sim = qiskit.Aer.get_backend('pulse_simulator') def single_pulse_schedule(self, phi, shape="square", gauss_sigma=0): @@ -86,13 +85,13 @@ def single_pulse_schedule(self, phi, shape="square", gauss_sigma=0): """ # define default square drive pulse (add phase only; omega_a included in Hamiltonian) const_pulse = np.ones(self.drive_samples) - phase = np.exp(1j*phi) - drive_pulse = SamplePulse(phase*const_pulse, name='drive_pulse') + phase = np.exp(1j * phi) + drive_pulse = SamplePulse(phase * const_pulse, name='drive_pulse') # create simple Gaussian drive if set this shape if shape == "gaussian": - times = 1.0*np.arange(self.drive_samples) - gaussian = np.exp(-times**2/2/gauss_sigma**2) + times = 1.0 * np.arange(self.drive_samples) + gaussian = np.exp(-times**2 / 2 / gauss_sigma**2) drive_pulse = SamplePulse(gaussian, name='drive_pulse') # add commands to schedule @@ -103,7 +102,6 @@ def single_pulse_schedule(self, phi, shape="square", gauss_sigma=0): return schedule - def frame_change_schedule(self, phi, fc_phi, dur_drive1, dur_drive2): """Creates schedule for frame change test. Does a pulse w/ phase phi of duration dur_drive1, then frame change of phase fc_phi, then another pulse of phase phi of duration dur_drive2. @@ -118,9 +116,11 @@ def frame_change_schedule(self, phi, fc_phi, dur_drive1, dur_drive2): schedule (pulse schedule): schedule for frame change test """ # drive pulse (just phase; omega_a included in Hamiltonian) - phase = np.exp(1j*phi) - drive_pulse_1 = SamplePulse(phase*np.ones(dur_drive1), name='drive_pulse_1') - drive_pulse_2 = SamplePulse(phase*np.ones(dur_drive2), name='drive_pulse_2') + phase = np.exp(1j * phi) + drive_pulse_1 = SamplePulse(phase * np.ones(dur_drive1), + name='drive_pulse_1') + drive_pulse_2 = SamplePulse(phase * np.ones(dur_drive2), + name='drive_pulse_2') # frame change fc_pulse = FrameChange(phase=fc_phi, name='fc') @@ -163,25 +163,30 @@ def schedule_2q(self): schedule (pulse schedule): schedule for 2q experiment """ # set up const pulse - const_pulse = SamplePulse(np.ones(self.drive_samples), name='const_pulse') + const_pulse = SamplePulse(np.ones(self.drive_samples), + name='const_pulse') # set u channel - uchannel = 1 # gives omega1-omega0 (we will set equal, so don't need negation) + uchannel = 1 # gives omega1-omega0 (we will set equal, so don't need negation) # add commands to schedule schedule = pulse.Schedule(name='2q_schedule') - schedule |= const_pulse(self.system.qubits[self.qubit_0].drive) # pi pulse drive - schedule += const_pulse(self.system.controls[uchannel]) << schedule.duration # u chan pulse + schedule |= const_pulse( + self.system.qubits[self.qubit_0].drive) # pi pulse drive + schedule += const_pulse(self.system.controls[uchannel] + ) << schedule.duration # u chan pulse schedule |= self.acq_01 << schedule.duration return schedule def create_ham_1q(self, omega_0, omega_a, qub_dim=2): """Create single qubit Hamiltonian as given in class docstring + Args: omega_0 (float): qubit 0 frequency omega_a (float): drive amplitude qub_dim (int): dimension of qubit subspace + Returns: hamiltonian (dict): dictionary representation of single qubit hamiltonian """ @@ -216,7 +221,7 @@ def create_ham_2q(self, omega_0, omega_a, omega_i, qub_dim=2): hamiltonian (dict): dictionary representation of two qubit hamiltonian """ - # Create the hamiltonian + # Create the hamiltonian hamiltonian = {} hamiltonian['h_str'] = [] @@ -226,30 +231,72 @@ def create_ham_2q(self, omega_0, omega_a, omega_i, qub_dim=2): # interaction term (uses U channels to get exponential piece) hamiltonian['h_str'].append('omegai*Sp0*Sm1||U1') - hamiltonian['h_str'].append('omegai*Sm0*Sp1||U1') # U1 gives diff omega_d1-omega_d0 - + hamiltonian['h_str'].append( + 'omegai*Sm0*Sp1||U1') # U1 gives diff omega_d1-omega_d0 # Set variables in ham - hamiltonian['vars'] = {'omega0': omega_0, 'omegaa': omega_a, 'omegai': omega_i} + hamiltonian['vars'] = { + 'omega0': omega_0, + 'omegaa': omega_a, + 'omegai': omega_i + } # set the qubit dimensions to qub_dim hamiltonian['qub'] = {'0': qub_dim, '1': qub_dim} return hamiltonian + def backend_options_1q(self, omega_0, omega_a, qub_dim=2): + """Creates backend_options dictionary for 1 qubit pulse simulation. + + Args: + omega_0 (float): qubit 0 frequency + omega_a (float): drive amplitude + qub_dim (int): dimension of qubit subspace + + Returns: + dict: backend_options dictionary. + """ + hamiltonian = self.create_ham_1q(omega_0, omega_a, qub_dim) + backend_options = self.backend_mock.configuration().to_dict() + backend_options['hamiltonian'] = hamiltonian + backend_options['qubit_list'] = [self.qubit_0] + backend_options['dt'] = 1.0 # makes time = self.drive_samples + backend_options['ode_options'] = {} # optionally set ode settings + return backend_options + + def backend_options_2q(self, omega_0, omega_a, omega_i, qub_dim=2): + """Creates backend_options dictionary for 1 qubit pulse simulation. + + Args: + omega_0 (float): Q0 frequency + omega_a (float): Q0 drive amplitude + omega_i (float): interaction amplitude + qub_dim (int): dimension of qubit subspace (same for both qubits) + + Returns: + dict: backend_options dictionary. + """ + hamiltonian = self.create_ham_2q(omega_0, omega_a, omega_i, qub_dim) + backend_options = self.backend_mock.configuration().to_dict() + backend_options['hamiltonian'] = hamiltonian + backend_options['qubit_list'] = [self.qubit_0, self.qubit_1] + backend_options['dt'] = 1.0 # makes time = self.drive_samples + backend_options['ode_options'] = {} # optionally set ode settings + return backend_options + def qobj_params_1q(self, omega_d0): """Set params needed to create qobj for 1q tests Args: omega_d0 (float): qubit 0 drive (lo) frequency Returns: - dict: contains qubit_list, memory_slots, qubit_lo_freq, meas_map for 1q qobj + dict: contains memory_slots, qubit_lo_freq, meas_map for 1q qobj """ - qubit_list = [self.qubit_0] memory_slots = 1 - qubit_lo_freq = [omega_d0/(2*np.pi)] + qubit_lo_freq = [omega_d0 / (2 * np.pi)] meas_map = self.meas_map_1q - return (qubit_list, memory_slots, qubit_lo_freq, meas_map) + return (memory_slots, qubit_lo_freq, meas_map) def qobj_params_2q(self, omega_d0, omega_d1): """Set params needed to create qobj for 2q tests @@ -257,82 +304,74 @@ def qobj_params_2q(self, omega_d0, omega_d1): omega_d0 (float): qubit 0 drive (lo) frequency omega_d1 (float): qubit 1 drive (lo) frequency Returns: - dict: contains qubit_list, memory_slots, qubit_lo_freq, meas_map for 2q qobj + dict: contains memory_slots, qubit_lo_freq, meas_map for 2q qobj """ - qubit_list = [self.qubit_0, self.qubit_1] memory_slots = 2 - qubit_lo_freq = [omega_d0/(2*np.pi), omega_d1/(2*np.pi)] + qubit_lo_freq = [omega_d0 / (2 * np.pi), omega_d1 / (2 * np.pi)] meas_map = self.meas_map_2q - return (qubit_list, memory_slots, qubit_lo_freq, meas_map) + return (memory_slots, qubit_lo_freq, meas_map) - def create_qobj(self, shots, meas_level, schedule, hamiltonian, qobj_params): + def create_qobj(self, shots, meas_level, schedule, qobj_params): """Creates qobj for the specified pulse experiment. Uses Hamiltonian from class docstring (except for 2q tests, which use Hamiltonian specified in comment of that test section). Args: shots (int): number of times to perform experiment meas_level (int): level of data to return schedule (Schedule): pulse schedule for the qobj - hamiltonian (dict): dictionary representation of the Hamiltonian - qobj_params (tuple): tuple of qubit_list, memory_slots, qubit_lo_freq, meas_map + qobj_params (tuple): tuple of memory_slots, qubit_lo_freq, meas_map Returns: Qobj: qobj representing this pulse experiment """ - - # update the back_end - self.back_config['hamiltonian'] = hamiltonian - self.back_config['noise'] = {} - self.back_config['dt'] = 1.0 # makes time = self.drive_samples - - self.back_config['ode_options'] = {} # optionally set ode settings - # set qobj params - qubit_list = qobj_params[0] - memory_slots = qobj_params[1] - qubit_lo_freq = qobj_params[2] - meas_map = qobj_params[3] - - self.back_config['qubit_list'] = qubit_list + memory_slots = qobj_params[0] + qubit_lo_freq = qobj_params[1] + meas_map = qobj_params[2] # construct the qobj - qobj = assemble([schedule], self.backend_mock, - meas_level=meas_level, meas_return='single', - meas_map=meas_map, qubit_lo_freq=qubit_lo_freq, - memory_slots=memory_slots, shots=shots, sim_config=self.back_config) + qobj = assemble([schedule], + self.backend_mock, + meas_level=meas_level, + meas_return='single', + meas_map=meas_map, + qubit_lo_freq=qubit_lo_freq, + memory_slots=memory_slots, + shots=shots) return qobj - #### SINGLE QUBIT TESTS ######################################################################## - # --------------------------------------------------------------------- - # Test gates (using meas level 2 and square drive) + # Test single qubit gates (using meas level 2 and square drive) # --------------------------------------------------------------------- def test_x_gate(self): - """Test x gate. Set omega_d0=omega_0 (drive on resonance), phi=0, omega_a = pi/time + """ + Test x gate. Set omega_d0=omega_0 (drive on resonance), phi=0, omega_a = pi/time """ # set variables # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2*np.pi*self.freq_qubit_0 + omega_0 = 2 * np.pi * self.freq_qubit_0 omega_d0 = omega_0 # Require omega_a*time = pi to implement pi pulse (x gate) # num of samples gives time - omega_a = np.pi/self.drive_samples + omega_a = np.pi / self.drive_samples phi = 0 x_schedule = self.single_pulse_schedule(phi) - x_hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) - x_qobj_params = self.qobj_params_1q(omega_d0=omega_d0) - - x_qobj = self.create_qobj(shots=256, meas_level=2, schedule=x_schedule, - hamiltonian=x_hamiltonian, qobj_params=x_qobj_params) - result = self.backend_sim.run(x_qobj).result() + x_qobj_params = self.qobj_params_1q(omega_d0) + x_qobj = self.create_qobj(shots=256, + meas_level=2, + schedule=x_schedule, + qobj_params=x_qobj_params) + x_backend_opts = self.backend_options_1q(omega_0, omega_a) + result = self.backend_sim.run(x_qobj, + backend_options=x_backend_opts).result() counts = result.get_counts() - exp_counts = {'1':256} + exp_counts = {'1': 256} self.assertDictAlmostEqual(counts, exp_counts) @@ -342,34 +381,36 @@ def test_hadamard_gate(self): """ # set variables - shots = 100000 # large number of shots so get good proportions + shots = 100000 # large number of shots so get good proportions # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2*np.pi*self.freq_qubit_0 + omega_0 = 2 * np.pi * self.freq_qubit_0 omega_d0 = omega_0 # Require omega_a*time = pi/2 to implement pi/2 rotation pulse # num of samples gives time - omega_a = np.pi/2/self.drive_samples + omega_a = np.pi / 2 / self.drive_samples - phi = -np.pi/2 + phi = -np.pi / 2 had_schedule = self.single_pulse_schedule(phi) - had_hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) had_qobj_params = self.qobj_params_1q(omega_d0=omega_d0) - had_qobj = self.create_qobj(shots=shots, meas_level=2, schedule=had_schedule, - hamiltonian=had_hamiltonian, qobj_params=had_qobj_params) - - result = self.backend_sim.run(had_qobj).result() + had_qobj = self.create_qobj(shots=shots, + meas_level=2, + schedule=had_schedule, + qobj_params=had_qobj_params) + had_backend_opts = self.backend_options_1q(omega_0, omega_a) + result = self.backend_sim.run( + had_qobj, backend_options=had_backend_opts).result() counts = result.get_counts() # compare prop prop = {} for key in counts.keys(): - prop[key] = counts[key]/shots + prop[key] = counts[key] / shots - exp_prop = {'0':0.5, '1':0.5} + exp_prop = {'0': 0.5, '1': 0.5} self.assertDictAlmostEqual(prop, exp_prop, delta=0.01) @@ -385,10 +426,12 @@ def _analytic_prop_1q_gates(self, omega_0, omega_a, omega_d0, phi): """ time = self.drive_samples # write Hrot analytically - h_rot = np.array([[(omega_d0-omega_0)/2, np.exp(1j*phi)*omega_a/2], - [np.exp(-1j*phi)*omega_a/2, -(omega_d0-omega_0)/2]]) + h_rot = np.array([[ + (omega_d0 - omega_0) / 2, + np.exp(1j * phi) * omega_a / 2 + ], [np.exp(-1j * phi) * omega_a / 2, -(omega_d0 - omega_0) / 2]]) # exponentiate - u_rot = expm(-1j*h_rot*time) + u_rot = expm(-1j * h_rot * time) state0 = np.array([1, 0]) # compute analytic prob (proportion) of 0 state @@ -396,38 +439,48 @@ def _analytic_prop_1q_gates(self, omega_0, omega_a, omega_d0, phi): prop0 = np.abs(mat_elem0)**2 # return expected proportion - exp_prop = {'0': prop0, '1': 1-prop0} + exp_prop = {'0': prop0, '1': 1 - prop0} return exp_prop def test_arbitrary_gate(self): """Test a few examples w/ arbitary drive, phase and amplitude. """ - shots = 10000 # large number of shots so get good proportions + shots = 10000 # large number of shots so get good proportions num_tests = 3 # set variables for each test - omega_0 = 2*np.pi*self.freq_qubit_0 - omega_d0_vals = [omega_0+1, omega_0+0.02, omega_0+0.005] - omega_a_vals = [2*np.pi/3/self.drive_samples, 7*np.pi/5/self.drive_samples, 0.1] - phi_vals = [5*np.pi/7, 19*np.pi/14, np.pi/4] + omega_0 = 2 * np.pi * self.freq_qubit_0 + omega_d0_vals = [omega_0 + 1, omega_0 + 0.02, omega_0 + 0.005] + omega_a_vals = [ + 2 * np.pi / 3 / self.drive_samples, + 7 * np.pi / 5 / self.drive_samples, 0.1 + ] + phi_vals = [5 * np.pi / 7, 19 * np.pi / 14, np.pi / 4] for i in range(num_tests): with self.subTest(i=i): schedule = self.single_pulse_schedule(phi_vals[i]) - hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_vals[i]) qobj_params = self.qobj_params_1q(omega_d0=omega_d0_vals[i]) - qobj = self.create_qobj(shots=shots, meas_level=2, schedule=schedule, - hamiltonian=hamiltonian, qobj_params=qobj_params) + qobj = self.create_qobj(shots=shots, + meas_level=2, + schedule=schedule, + qobj_params=qobj_params) # Run qobj and compare prop to expected result - result = self.backend_sim.run(qobj).result() + backend_options = self.backend_options_1q( + omega_0, omega_a_vals[i]) + result = self.backend_sim.run( + qobj, backend_options=backend_options).result() counts = result.get_counts() prop = {} for key in counts.keys(): - prop[key] = counts[key]/shots + prop[key] = counts[key] / shots - exp_prop = self._analytic_prop_1q_gates(omega_0=omega_0, omega_a=omega_a_vals[i], - omega_d0=omega_d0_vals[i], phi=phi_vals[i]) + exp_prop = self._analytic_prop_1q_gates( + omega_0=omega_0, + omega_a=omega_a_vals[i], + omega_d0=omega_d0_vals[i], + phi=phi_vals[i]) self.assertDictAlmostEqual(prop, exp_prop, delta=0.01) @@ -441,26 +494,29 @@ def test_arbitrary_gate(self): def test_meas_level_1(self): """Test measurement level 1. """ - shots = 10000 # run large number of shots for good proportions + shots = 10000 # run large number of shots for good proportions # perform hadamard setup (so get some 0's and some 1's), but use meas_level = 1 # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2*np.pi*self.freq_qubit_0 + omega_0 = 2 * np.pi * self.freq_qubit_0 omega_d0 = omega_0 # Require omega_a*time = pi/2 to implement pi/2 rotation pulse # num of samples gives time - omega_a = np.pi/2/self.drive_samples + omega_a = np.pi / 2 / self.drive_samples - phi = -np.pi/2 + phi = -np.pi / 2 schedule = self.single_pulse_schedule(phi) - hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) qobj_params = self.qobj_params_1q(omega_d0=omega_d0) - - qobj = self.create_qobj(shots=shots, meas_level=1, schedule=schedule, - hamiltonian=hamiltonian, qobj_params=qobj_params) - result = self.backend_sim.run(qobj).result() + qobj = self.create_qobj(shots=shots, + meas_level=1, + schedule=schedule, + qobj_params=qobj_params) + backend_options = self.backend_options_1q(omega_0=omega_0, + omega_a=omega_a) + result = self.backend_sim.run( + qobj, backend_options=backend_options).result() # Verify that (about) half the IQ vals have abs val 1 and half have abs val 0 # (use prop for easier comparison) @@ -469,9 +525,9 @@ def test_meas_level_1(self): iq_prop = {'0': 0, '1': 0} for i in mem: if i == 0: - iq_prop['0'] += 1/shots + iq_prop['0'] += 1 / shots else: - iq_prop['1'] += 1/shots + iq_prop['1'] += 1 / shots exp_prop = {'0': 0.5, '1': 0.5} @@ -493,8 +549,9 @@ def _analytic_gaussian_statevector(self, gauss_sigma, omega_a): (Returned in the rotating frame) """ time = self.drive_samples - arg = 1/2*np.sqrt(np.pi/2)*gauss_sigma*omega_a*erf(time/np.sqrt(2)/gauss_sigma) - exp_statevector = [np.cos(arg), -1j*np.sin(arg)] + arg = 1 / 2 * np.sqrt(np.pi / 2) * gauss_sigma * omega_a * erf( + time / np.sqrt(2) / gauss_sigma) + exp_statevector = [np.cos(arg), -1j * np.sin(arg)] return exp_statevector def test_gaussian_drive(self): @@ -505,33 +562,42 @@ def test_gaussian_drive(self): # set variables # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2*np.pi*self.freq_qubit_0 + omega_0 = 2 * np.pi * self.freq_qubit_0 omega_d0 = omega_0 # Require omega_a*time = pi to implement pi pulse (x gate) # num of samples gives time - omega_a = np.pi/self.drive_samples + omega_a = np.pi / self.drive_samples phi = 0 # Test gaussian drive results for a few different sigma - gauss_sigmas = {self.drive_samples/6, self.drive_samples/3, self.drive_samples} + gauss_sigmas = { + self.drive_samples / 6, self.drive_samples / 3, self.drive_samples + } for gauss_sigma in gauss_sigmas: with self.subTest(gauss_sigma=gauss_sigma): - schedule = self.single_pulse_schedule(phi=phi, shape="gaussian", + schedule = self.single_pulse_schedule(phi=phi, + shape="gaussian", gauss_sigma=gauss_sigma) - hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) qobj_params = self.qobj_params_1q(omega_d0=omega_d0) - qobj = self.create_qobj(shots=1000, meas_level=2, schedule=schedule, - hamiltonian=hamiltonian, qobj_params=qobj_params) - result = self.backend_sim.run(qobj).result() + qobj = self.create_qobj(shots=1000, + meas_level=2, + schedule=schedule, + qobj_params=qobj_params) + backend_options = self.backend_options_1q(omega_0=omega_0, + omega_a=omega_a) + result = self.backend_sim.run( + qobj, backend_options=backend_options).result() statevector = result.get_statevector() - exp_statevector = self._analytic_gaussian_statevector(gauss_sigma=gauss_sigma, - omega_a=omega_a) + exp_statevector = self._analytic_gaussian_statevector( + gauss_sigma=gauss_sigma, omega_a=omega_a) # compare statevectors element-wise (comparision only accurate to 1 dec place) for i, _ in enumerate(statevector): - self.assertAlmostEqual(statevector[i], exp_statevector[i], places=1) + self.assertAlmostEqual(statevector[i], + exp_statevector[i], + places=1) # --------------------------------------------------------------------- # Test FrameChange and PersistentValue commands @@ -545,69 +611,77 @@ def _analytic_prop_fc(self, phi_net): Returns: exp_prop (dict): expected proportion of 0, 1 counts as computed analytically """ - prop0 = np.cos(phi_net/2)**2 - exp_prop = {'0': prop0, '1': 1-prop0} + prop0 = np.cos(phi_net / 2)**2 + exp_prop = {'0': prop0, '1': 1 - prop0} return exp_prop def test_frame_change(self): """Test frame change command. """ shots = 10000 # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2*np.pi*self.freq_qubit_0 + omega_0 = 2 * np.pi * self.freq_qubit_0 omega_d0 = omega_0 # set phi = 0 phi = 0 - dur_drive1 = self.drive_samples # first pulse duration + dur_drive1 = self.drive_samples # first pulse duration fc_phi = np.pi # Test frame change where no shift in state results # specfically: do pi/2 pulse, then pi frame change, then another pi/2 pulse. # Verify left in |0> state - dur_drive2_no_shift = dur_drive1 # same duration for both pulses - omega_a_no_shift = np.pi/2/dur_drive1 # pi/2 pulse amplitude - schedule_no_shift = self.frame_change_schedule(phi=phi, fc_phi=fc_phi, - dur_drive1=dur_drive1, - dur_drive2=dur_drive2_no_shift) - hamiltonian_no_shift = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_no_shift) + dur_drive2_no_shift = dur_drive1 # same duration for both pulses + omega_a_no_shift = np.pi / 2 / dur_drive1 # pi/2 pulse amplitude + schedule_no_shift = self.frame_change_schedule( + phi=phi, + fc_phi=fc_phi, + dur_drive1=dur_drive1, + dur_drive2=dur_drive2_no_shift) qobj_params_no_shift = self.qobj_params_1q(omega_d0=omega_d0) - qobj_no_shift = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_no_shift, - hamiltonian=hamiltonian_no_shift, + qobj_no_shift = self.create_qobj(shots=shots, + meas_level=2, + schedule=schedule_no_shift, qobj_params=qobj_params_no_shift) - - result_no_shift = self.backend_sim.run(qobj_no_shift).result() + backend_options_no_shift = self.backend_options_1q( + omega_0, omega_a_no_shift) + result_no_shift = self.backend_sim.run( + qobj_no_shift, backend_options=backend_options_no_shift).result() counts_no_shift = result_no_shift.get_counts() - exp_result_no_shift = {'0':shots} + exp_result_no_shift = {'0': shots} self.assertDictAlmostEqual(counts_no_shift, exp_result_no_shift) # Test frame change where a shift does result # specifically: do pi/4 pulse, then pi phase change, then do pi/8 pulse. # check that a net rotation of pi/4-pi/8 has occured on the Bloch sphere - dur_drive2_shift = dur_drive1//2 # half time for second pulse (halves angle) - omega_a_shift = np.pi/4/dur_drive1 # pi/4 pulse amplitude + dur_drive2_shift = dur_drive1 // 2 # half time for second pulse (halves angle) + omega_a_shift = np.pi / 4 / dur_drive1 # pi/4 pulse amplitude + schedule_shift = self.frame_change_schedule( + phi=phi, + fc_phi=fc_phi, + dur_drive1=dur_drive1, + dur_drive2=dur_drive2_shift) - schedule_shift = self.frame_change_schedule(phi=phi, fc_phi=fc_phi, dur_drive1=dur_drive1, - dur_drive2=dur_drive2_shift) - hamiltonian_shift = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_shift) qobj_params_shift = self.qobj_params_1q(omega_d0=omega_d0) - - qobj_shift = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_shift, - hamiltonian=hamiltonian_shift, qobj_params=qobj_params_shift) - - result_shift = self.backend_sim.run(qobj_shift).result() + qobj_shift = self.create_qobj(shots=shots, + meas_level=2, + schedule=schedule_shift, + qobj_params=qobj_params_shift) + backend_options_shift = self.backend_options_1q(omega_0, omega_a_shift) + result_shift = self.backend_sim.run( + qobj_shift, backend_options=backend_options_shift).result() counts_shift = result_shift.get_counts() # verify props prop_shift = {} for key in counts_shift.keys(): - prop_shift[key] = counts_shift[key]/shots + prop_shift[key] = counts_shift[key] / shots # net angle is given by pi/4-pi/8 - exp_prop_shift = self._analytic_prop_fc(np.pi/4-np.pi/8) + exp_prop_shift = self._analytic_prop_fc(np.pi / 4 - np.pi / 8) self.assertDictAlmostEqual(prop_shift, exp_prop_shift, delta=0.01) def test_persistent_value(self): @@ -615,32 +689,34 @@ def test_persistent_value(self): shots = 256 # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2*np.pi*self.freq_qubit_0 + omega_0 = 2 * np.pi * self.freq_qubit_0 omega_d0 = omega_0 # Set omega_a = 1 and do pi pulse w/ omega_a_pv. Verify result is the |1> state omega_a = 1 - omega_a_pv = np.pi/self.drive_samples # pi pulse + omega_a_pv = np.pi / self.drive_samples # pi pulse schedule = self.persistent_value_schedule(omega_a_pv) - hamiltonian = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a) qobj_params = self.qobj_params_1q(omega_d0=omega_d0) - pv_qobj = self.create_qobj(shots=shots, meas_level=2, schedule=schedule, - hamiltonian=hamiltonian, qobj_params=qobj_params) - - result = self.backend_sim.run(pv_qobj).result() + pv_qobj = self.create_qobj(shots=shots, + meas_level=2, + schedule=schedule, + qobj_params=qobj_params) + backend_options = self.backend_options_1q(omega_0, omega_a) + result = self.backend_sim.run( + pv_qobj, backend_options=backend_options).result() counts = result.get_counts() - exp_result = {'1':shots} + exp_result = {'1': shots} self.assertDictAlmostEqual(counts, exp_result) - # --------------------------------------------------------------------- - # Test higher energy levels (take 3 level system for simplicity, + # --------------------------------------------------------------------- + # Test higher energy levels (take 3 level system for simplicity, # use square drive) - # `\sigma_x \rightarrow a+\dagger{a}`, - # `\sigma_y \rightarrow -\imag (a-\dagger{a})`, etc - # --------------------------------------------------------------------- + # `\sigma_x \rightarrow a+\dagger{a}`, + # `\sigma_y \rightarrow -\imag (a-\dagger{a})`, etc + # --------------------------------------------------------------------- def _analytic_statevector_three_level(self, omega_a): r"""Returns analytically computed statevector for 3 level system with our Hamiltonian. Is @@ -654,11 +730,12 @@ def _analytic_statevector_three_level(self, omega_a): (Returned in the rotating frame) """ time = self.drive_samples - arg1 = np.sqrt(3)*omega_a*time/2 # cos arg for first component - arg2 = arg1 # sin arg for first component - arg3 = arg1/2 # sin arg for 3rd component - exp_statevector = [(2+np.cos(arg1))/3, -1j*np.sin(arg2)/np.sqrt(3), - -2*np.sqrt(2)*np.sin(arg3)**2/3] + arg1 = np.sqrt(3) * omega_a * time / 2 # cos arg for first component + arg2 = arg1 # sin arg for first component + arg3 = arg1 / 2 # sin arg for 3rd component + exp_statevector = [(2 + np.cos(arg1)) / 3, + -1j * np.sin(arg2) / np.sqrt(3), + -2 * np.sqrt(2) * np.sin(arg3)**2 / 3] return exp_statevector @@ -668,54 +745,65 @@ def test_three_level(self): """ shots = 1000 - # set omega_0,omega_d0 (use qubit frequency) -> drive on resonance - omega_0 = 2*np.pi*self.freq_qubit_0 + # Set omega_0,omega_d0 (use qubit frequency) -> drive on resonance + omega_0 = 2 * np.pi * self.freq_qubit_0 omega_d0 = omega_0 - # set phi = 0 for simplicity + # Set phi = 0 for simplicity phi = 0 # Test pi pulse - omega_a_pi = np.pi/self.drive_samples + omega_a_pi = np.pi / self.drive_samples schedule_pi = self.single_pulse_schedule(phi) - # set qub_dim=3 in hamiltonian - hamiltonian_pi = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_pi, qub_dim=3) qobj_params_pi = self.qobj_params_1q(omega_d0=omega_d0) - qobj_pi = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_pi, - hamiltonian=hamiltonian_pi, qobj_params=qobj_params_pi) - - result_pi = self.backend_sim.run(qobj_pi).result() + qobj_pi = self.create_qobj(shots=shots, + meas_level=2, + schedule=schedule_pi, + qobj_params=qobj_params_pi) + + # Set qub_dim=3 in hamiltonian + backend_options_pi = self.backend_options_1q(omega_0, + omega_a_pi, + qub_dim=3) + result_pi = self.backend_sim.run( + qobj_pi, backend_options=backend_options_pi).result() statevector_pi = result_pi.get_statevector() exp_statevector_pi = self._analytic_statevector_three_level(omega_a_pi) # compare vectors element-wise for i, _ in enumerate(statevector_pi): - self.assertAlmostEqual(statevector_pi[i], exp_statevector_pi[i], places=4) + self.assertAlmostEqual(statevector_pi[i], + exp_statevector_pi[i], + places=4) # Test 2*pi pulse - omega_a_2pi = 2*np.pi/self.drive_samples + omega_a_2pi = 2 * np.pi / self.drive_samples schedule_2pi = self.single_pulse_schedule(phi) - # set qub_dim=3 in hamiltonian - hamiltonian_2pi = self.create_ham_1q(omega_0=omega_0, omega_a=omega_a_2pi, qub_dim=3) qobj_params_2pi = self.qobj_params_1q(omega_d0=omega_d0) - - qobj_2pi = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_2pi, - hamiltonian=hamiltonian_2pi, qobj_params=qobj_params_2pi) - - result_2pi = self.backend_sim.run(qobj_2pi).result() + qobj_2pi = self.create_qobj(shots=shots, + meas_level=2, + schedule=schedule_2pi, + qobj_params=qobj_params_2pi) + # set qub_dim=3 in hamiltonian + backend_options_2pi = self.backend_options_1q(omega_0, + omega_a_2pi, + qub_dim=3) + result_2pi = self.backend_sim.run( + qobj_2pi, backend_options=backend_options_2pi).result() statevector_2pi = result_2pi.get_statevector() - exp_statevector_2pi = self._analytic_statevector_three_level(omega_a_2pi) + exp_statevector_2pi = self._analytic_statevector_three_level( + omega_a_2pi) # compare vectors element-wise for i, _ in enumerate(statevector_2pi): - self.assertAlmostEqual(statevector_2pi[i], exp_statevector_2pi[i], places=4) - - #### TWO QUBIT TESTS ########################################################################### + self.assertAlmostEqual(statevector_2pi[i], + exp_statevector_2pi[i], + places=4) # ---------------------------------------------------------------------------------------------- # Test qubit interaction (use 2 qubits for simplicity) @@ -735,9 +823,9 @@ def test_interaction(self): # Do a standard SWAP gate # Interaction amp (any non-zero creates the swap gate) - omega_i_swap = np.pi/2/self.drive_samples + omega_i_swap = np.pi / 2 / self.drive_samples # set omega_d0=omega_0 (resonance) - omega_0 = 2*np.pi*self.freq_qubit_0 + omega_0 = 2 * np.pi * self.freq_qubit_0 omega_d0 = omega_0 # For swapping, set omega_d1 = 0 (drive on Q0 resonance) @@ -746,48 +834,58 @@ def test_interaction(self): # do pi pulse on Q0 and verify state swaps from '01' to '10' (reverse bit order) # Q0 drive amp -> pi pulse - omega_a_pi_swap = np.pi/self.drive_samples + omega_a_pi_swap = np.pi / self.drive_samples schedule_pi_swap = self.schedule_2q() - hamiltonian_pi_swap = self.create_ham_2q(omega_0=omega_0, omega_a=omega_a_pi_swap, - omega_i=omega_i_swap) - qobj_params_pi_swap = self.qobj_params_2q(omega_d0=omega_d0, omega_d1=omega_d1_swap) + qobj_params_pi_swap = self.qobj_params_2q(omega_d0=omega_d0, + omega_d1=omega_d1_swap) - qobj_pi_swap = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_pi_swap, - hamiltonian=hamiltonian_pi_swap, + qobj_pi_swap = self.create_qobj(shots=shots, + meas_level=2, + schedule=schedule_pi_swap, qobj_params=qobj_params_pi_swap) - result_pi_swap = self.backend_sim.run(qobj_pi_swap).result() + backend_options_pi_swap = self.backend_options_2q( + omega_0, omega_a_pi_swap, omega_i_swap) + result_pi_swap = self.backend_sim.run( + qobj_pi_swap, backend_options=backend_options_pi_swap).result() counts_pi_swap = result_pi_swap.get_counts() - exp_counts_pi_swap = {'10': shots} # reverse bit order (qiskit convention) + exp_counts_pi_swap = { + '10': shots + } # reverse bit order (qiskit convention) self.assertDictAlmostEqual(counts_pi_swap, exp_counts_pi_swap, delta=2) # do pi/2 pulse on Q0 and verify half the counts are '00' and half are swapped state '10' # Q0 drive amp -> pi/2 pulse - omega_a_pi2_swap = np.pi/2/self.drive_samples + omega_a_pi2_swap = np.pi / 2 / self.drive_samples schedule_pi2_swap = self.schedule_2q() - hamiltonian_pi2_swap = self.create_ham_2q(omega_0=omega_0, omega_a=omega_a_pi2_swap, - omega_i=omega_i_swap) - qobj_params_pi2_swap = self.qobj_params_2q(omega_d0=omega_d0, omega_d1=omega_d1_swap) + qobj_params_pi2_swap = self.qobj_params_2q(omega_d0=omega_d0, + omega_d1=omega_d1_swap) - qobj_pi2_swap = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_pi2_swap, - hamiltonian=hamiltonian_pi2_swap, + qobj_pi2_swap = self.create_qobj(shots=shots, + meas_level=2, + schedule=schedule_pi2_swap, qobj_params=qobj_params_pi2_swap) - result_pi2_swap = self.backend_sim.run(qobj_pi2_swap).result() + backend_options_pi2_swap = self.backend_options_2q( + omega_0, omega_a_pi2_swap, omega_i_swap) + result_pi2_swap = self.backend_sim.run( + qobj_pi2_swap, backend_options=backend_options_pi2_swap).result() counts_pi2_swap = result_pi2_swap.get_counts() # compare proportions for improved accuracy prop_pi2_swap = {} for key in counts_pi2_swap.keys(): - prop_pi2_swap[key] = counts_pi2_swap[key]/shots + prop_pi2_swap[key] = counts_pi2_swap[key] / shots - exp_prop_pi2_swap = {'00':0.5, '10':0.5} # reverse bit order + exp_prop_pi2_swap = {'00': 0.5, '10': 0.5} # reverse bit order - self.assertDictAlmostEqual(prop_pi2_swap, exp_prop_pi2_swap, delta=0.01) + self.assertDictAlmostEqual(prop_pi2_swap, + exp_prop_pi2_swap, + delta=0.01) # Test that no SWAP occurs when omega_i=0 (no interaction) omega_i_no_swap = 0 @@ -796,22 +894,28 @@ def test_interaction(self): omega_d1_no_swap = omega_d0 # Q0 drive amp -> pi pulse - omega_a_no_swap = np.pi/self.drive_samples + omega_a_no_swap = np.pi / self.drive_samples schedule_no_swap = self.schedule_2q() - hamiltonian_no_swap = self.create_ham_2q(omega_0=omega_0, omega_a=omega_a_no_swap, - omega_i=omega_i_no_swap) - qobj_params_no_swap = self.qobj_params_2q(omega_d0=omega_d0, omega_d1=omega_d1_no_swap) + qobj_params_no_swap = self.qobj_params_2q(omega_d0=omega_d0, + omega_d1=omega_d1_no_swap) - qobj_no_swap = self.create_qobj(shots=shots, meas_level=2, schedule=schedule_no_swap, - hamiltonian=hamiltonian_no_swap, + qobj_no_swap = self.create_qobj(shots=shots, + meas_level=2, + schedule=schedule_no_swap, qobj_params=qobj_params_no_swap) - - result_no_swap = self.backend_sim.run(qobj_no_swap).result() + backend_options_swap = self.backend_options_2q(omega_0, + omega_a_no_swap, + omega_i_no_swap) + result_no_swap = self.backend_sim.run( + qobj_no_swap, backend_options=backend_options_swap).result() counts_no_swap = result_no_swap.get_counts() - exp_counts_no_swap = {'01': shots} # non-swapped state (reverse bit order) + exp_counts_no_swap = { + '01': shots + } # non-swapped state (reverse bit order) self.assertDictAlmostEqual(counts_no_swap, exp_counts_no_swap) + if __name__ == '__main__': unittest.main() From 422356d58b8e26cc355e1ff3094aa9b55a1c9c0e Mon Sep 17 00:00:00 2001 From: Juan Gomez Date: Tue, 26 Nov 2019 17:07:50 +0100 Subject: [PATCH 10/24] Remove qutip_lite math.pyx module - The module seems to be conflicting while cython builds, with the standard math module, in some specific configurations. --- .../openpulse/qutip_lite/cy/CMakeLists.txt | 1 - .../aer/openpulse/qutip_lite/cy/math.pxd | 36 ----- .../aer/openpulse/qutip_lite/cy/math.pyx | 125 ------------------ .../providers/aer/openpulse/solver/codegen.py | 1 - setup.py | 2 +- 5 files changed, 1 insertion(+), 164 deletions(-) delete mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/math.pxd delete mode 100755 qiskit/providers/aer/openpulse/qutip_lite/cy/math.pyx diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/CMakeLists.txt b/qiskit/providers/aer/openpulse/qutip_lite/cy/CMakeLists.txt index 3ff321d402..347ea1b924 100644 --- a/qiskit/providers/aer/openpulse/qutip_lite/cy/CMakeLists.txt +++ b/qiskit/providers/aer/openpulse/qutip_lite/cy/CMakeLists.txt @@ -24,7 +24,6 @@ endif() set(CYTHON_INSTALL_DIR "qiskit/providers/aer/openpulse/qutip_lite/cy") add_cython_module(spconvert src/zspmv.cpp) -add_cython_module(math src/zspmv.cpp) add_cython_module(spmath src/zspmv.cpp) add_cython_module(sparse_utils src/zspmv.cpp) add_cython_module(spmatfuncs src/zspmv.cpp) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pxd b/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pxd deleted file mode 100755 index d75351dd13..0000000000 --- a/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pxd +++ /dev/null @@ -1,36 +0,0 @@ -#!python -#cython: language_level=3 -# This file is part of QuTiP: Quantum Toolbox in Python. -# -# Copyright (c) 2011 and later, The QuTiP Project. -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# 1. Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names -# of its contributors may be used to endorse or promote products derived -# from this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -############################################################################### - -cdef double complex erf(double complex Z) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pyx b/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pyx deleted file mode 100755 index 661cc2a219..0000000000 --- a/qiskit/providers/aer/openpulse/qutip_lite/cy/math.pyx +++ /dev/null @@ -1,125 +0,0 @@ -#!python -#cython: language_level=3 -# This file is part of QuTiP: Quantum Toolbox in Python. -# -# Copyright (c) 2011 and later, The QuTiP Project. -# All rights reserved. -# -# Redistribution and use in source and binary forms, with or without -# modification, are permitted provided that the following conditions are -# met: -# -# 1. Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimer. -# -# 2. Redistributions in binary form must reproduce the above copyright -# notice, this list of conditions and the following disclaimer in the -# documentation and/or other materials provided with the distribution. -# -# 3. Neither the name of the QuTiP: Quantum Toolbox in Python nor the names -# of its contributors may be used to endorse or promote products derived -# from this software without specific prior written permission. -# -# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS -# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT -# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A -# PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT -# HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, -# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT -# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, -# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY -# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT -# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE -# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. -############################################################################### -cimport cython -from libc.math cimport (fabs, sinh, cosh, exp, pi, sqrt, cos, sin, copysign) - -cdef extern from "" namespace "std" nogil: - double real(double complex x) - double imag(double complex x) - -# -# Shanjie Zhang and Jianming Jin -# -# Copyrighted but permission granted to use code in programs. -# Buy their book "Computation of Special Functions", 1996, John Wiley & Sons, Inc. - -@cython.cdivision(True) -@cython.boundscheck(False) -cdef double complex erf(double complex Z): - """ - Parameters - ---------- - Z : double complex - Input parameter. - X : double - Real part of Z. - Y : double - Imag part of Z. - - Returns - ------- - erf(z) : double complex - """ - - cdef double EPS = 1e-12 - cdef double X = real(Z) - cdef double Y = imag(Z) - cdef double X2 = X * X - - cdef double ER, R, W, C0, ER0, ERR, ERI, CS, SS, ER1, EI1, ER2, W1 - - cdef size_t K, N - - if X < 3.5: - ER = 1.0 - R = 1.0 - W = 0.0 - for K in range(1, 100): - R = R*X2/(K+0.5) - ER = ER+R - if (fabs(ER-W) < EPS*fabs(ER)): - break - W = ER - C0 = 2.0/sqrt(pi)*X*exp(-X2) - ER0 = C0*ER - else: - ER = 1.0 - R=1.0 - for K in range(1, 12): - R = -R*(K-0.5)/X2 - ER = ER+R - C0 = exp(-X2)/(X*sqrt(pi)) - ER0 = 1.0-C0*ER - - if Y == 0.0: - ERR = ER0 - ERI = 0.0 - else: - CS = cos(2.0*X*Y) - SS = sin(2.0*X*Y) - ER1 = exp(-X2)*(1.0-CS)/(2.0*pi*X) - EI1 = exp(-X2)*SS/(2.0*pi*X) - ER2 = 0.0 - W1 = 0.0 - - for N in range(1,100): - ER2 = ER2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X-2.0*X*cosh(N*Y)*CS+N*sinh(N*Y)*SS) - if (fabs((ER2-W1)/ER2) < EPS): - break - W1 = ER2 - - C0 = 2.0*exp(-X2)/pi - ERR = ER0+ER1+C0*ER2 - EI2 = 0.0 - W2 = 0.0 - - for N in range(1,100): - EI2 = EI2+exp(-.25*N*N)/(N*N+4.0*X2)*(2.0*X*cosh(N*Y)*SS+N*sinh(N*Y)*CS) - if (fabs((EI2-W2)/EI2) < EPS): - break - W2 = EI2 - ERI = EI1+C0*EI2 - - return ERR + 1j*ERI \ No newline at end of file diff --git a/qiskit/providers/aer/openpulse/solver/codegen.py b/qiskit/providers/aer/openpulse/solver/codegen.py index a044066071..19590f51f9 100644 --- a/qiskit/providers/aer/openpulse/solver/codegen.py +++ b/qiskit/providers/aer/openpulse/solver/codegen.py @@ -263,7 +263,6 @@ def cython_preamble(): double complex conj(double complex x) from qiskit.providers.aer.openpulse.qutip_lite.cy.spmatfuncs cimport spmvpy -from qiskit.providers.aer.openpulse.qutip_lite.cy.math cimport erf from libc.math cimport pi from qiskit.providers.aer.openpulse.cy.channel_value cimport chan_value diff --git a/setup.py b/setup.py index ced13bffd9..5681d25557 100644 --- a/setup.py +++ b/setup.py @@ -58,7 +58,7 @@ def find_qiskit_aer_packages(): # Add Cython OP extensions here OP_EXTS = ['channel_value', 'measure', 'memory', 'utils'] # Add qutip_lite extensions here - Q_EXTS = ['spmatfuncs', 'sparse_utils', 'spmath', 'math', 'spconvert'] + Q_EXTS = ['spmatfuncs', 'sparse_utils', 'spmath', 'spconvert'] # Extra link args link_flags = [] From 0e23019c2fcc37d64347c8cb6506c8fdcc5d2baf Mon Sep 17 00:00:00 2001 From: Daniel Puzzuoli Date: Mon, 2 Dec 2019 19:30:38 -0500 Subject: [PATCH 11/24] fixed pylint errors (#465) --- qiskit/providers/aer/backends/qasm_simulator.py | 1 + qiskit/providers/aer/backends/statevector_simulator.py | 2 -- qiskit/providers/aer/noise/utils/noise_transformation.py | 3 +-- 3 files changed, 2 insertions(+), 4 deletions(-) diff --git a/qiskit/providers/aer/backends/qasm_simulator.py b/qiskit/providers/aer/backends/qasm_simulator.py index 31ef88f3ac..ef7bc0833f 100644 --- a/qiskit/providers/aer/backends/qasm_simulator.py +++ b/qiskit/providers/aer/backends/qasm_simulator.py @@ -9,6 +9,7 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. + """ Qiskit Aer qasm simulator backend. """ diff --git a/qiskit/providers/aer/backends/statevector_simulator.py b/qiskit/providers/aer/backends/statevector_simulator.py index a7baad1482..92754ec080 100644 --- a/qiskit/providers/aer/backends/statevector_simulator.py +++ b/qiskit/providers/aer/backends/statevector_simulator.py @@ -10,8 +10,6 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -# pylint: disable=invalid-name - """ Qiskit Aer statevector simulator backend. """ diff --git a/qiskit/providers/aer/noise/utils/noise_transformation.py b/qiskit/providers/aer/noise/utils/noise_transformation.py index cf3ebe8031..562ddb3dbc 100644 --- a/qiskit/providers/aer/noise/utils/noise_transformation.py +++ b/qiskit/providers/aer/noise/utils/noise_transformation.py @@ -10,8 +10,6 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -# pylint: disable=import-outside-toplevel - """ Noise transformation module @@ -27,6 +25,7 @@ given noise channel into the closest one, Hilbert-Schmidt wise, that can be used in a Clifford simulator. """ +# pylint: disable=import-outside-toplevel import itertools import logging From 29a5a80cc8ee54076e4d6d253e748fe7505b83fc Mon Sep 17 00:00:00 2001 From: Daniel Puzzuoli Date: Fri, 6 Dec 2019 10:58:30 -0500 Subject: [PATCH 12/24] Calculate qubit_lo_freq from pulse hamiltonian (#459) * added check for backend_config['qubit_lo_freq'] in openpulse/qobj/digest.digest_pulse_qobj for computing qubit_lo_freq from the Hamiltonian itself * added class for tests of digest.py, along with a test for the option qubit_lo_freq from_hamiltonian * added pulse_sim_utils.py * moved compute_lo_freq_from_hamiltonian from pulse_simulator to pulse_sim_utils * moved PulseSimulator.get_dressed_energies to pulse_sim_utils --- example/pulse_sim.ipynb | 114 +++++++----- .../providers/aer/backends/pulse_simulator.py | 36 +--- qiskit/providers/aer/openpulse/qobj/digest.py | 157 +++++++++++++++- qiskit/providers/aer/utils/__init__.py | 1 + qiskit/providers/aer/utils/pulse_sim_utils.py | 33 ++++ test/terra/openpulse/test_pulse_digest.py | 175 ++++++++++++++++++ 6 files changed, 430 insertions(+), 86 deletions(-) create mode 100644 qiskit/providers/aer/utils/pulse_sim_utils.py create mode 100644 test/terra/openpulse/test_pulse_digest.py diff --git a/example/pulse_sim.ipynb b/example/pulse_sim.ipynb index db629c5537..56fb235816 100644 --- a/example/pulse_sim.ipynb +++ b/example/pulse_sim.ipynb @@ -41,7 +41,16 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dpuzzuoli/Documents/projects/qiskit-terra/qiskit/pulse/channels/pulse_channel_spec.py:87: DeprecationWarning: The PulseChannelSpec is deprecated. Use backend.configuration() instead. The supported methods require some migrations; check out the release notes for the complete details.\n", + " DeprecationWarning)\n" + ] + } + ], "source": [ "#Get a pulse configuration from the fake backend\n", "backend_real = FakeOpenPulse2Q()\n", @@ -219,18 +228,7 @@ "cell_type": "code", "execution_count": 6, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/cjwood/git/qiskit/qiskit-terra/qiskit/providers/models/backendconfiguration.py:348: UserWarning: The time delta is now returned in units of [s] rather than [ns].\n", - " warnings.warn(\"The time delta is now returned in units of [s] rather than [ns].\")\n", - "/Users/cjwood/git/qiskit/qiskit-terra/qiskit/providers/models/backendconfiguration.py:354: UserWarning: The time delta is now returned in units of [s] rather than [ns].\n", - " warnings.warn(\"The time delta is now returned in units of [s] rather than [ns].\")\n" - ] - } - ], + "outputs": [], "source": [ "backend_options = configuration.to_dict()\n", "backend_options['hamiltonian'] = hamiltonian\n", @@ -258,34 +256,39 @@ "metadata": {}, "outputs": [], "source": [ - "backend_options['qubit_list'] = [0, 1]\n", - "#backend_options['qubit_list'] = None" + "backend_options['qubit_list'] = [0, 1]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "### Assemble the qobj with the backend config file and the qubit_list" + "### Assemble the qobj with the backend config file and the qubit_list\n", + "\n", + "Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state." ] }, { - "cell_type": "markdown", + "cell_type": "code", + "execution_count": 8, "metadata": {}, + "outputs": [], "source": [ - "We have to do this step twice to get the dressed frequencies for setting the LO's. Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state." + "rabi_qobj = assemble(schedules, \n", + " backend_real, \n", + " meas_level=1, \n", + " meas_return='avg', \n", + " memory_slots=2,\n", + " shots=shots)" ] }, { - "cell_type": "code", - "execution_count": 8, + "cell_type": "markdown", "metadata": {}, - "outputs": [], "source": [ - "rabi_qobj_no_lo = assemble(schedules, backend_real, \n", - " meas_level=1, meas_return='avg', \n", - " memory_slots=2,\n", - " shots=shots)" + "### Set qubit lo freq\n", + "\n", + "To simulate, the frequency of the local oscillator for each qubit needs to be specified. Here, we set the qubit lo frequencies to be determined automatically from the the Hamiltonian:" ] }, { @@ -294,8 +297,14 @@ "metadata": {}, "outputs": [], "source": [ - "evals, estates = backend_sim.get_dressed_energies(rabi_qobj_no_lo,\n", - " backend_options=backend_options)" + "backend_options['qubit_lo_freq'] = 'from_hamiltonian'" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When this option is used, the frequencies are determined from the gap in energy between the ground state and the dressed state corresponding to the first excited state of each qubit. The effect of this setting may be seen using the utility functions:" ] }, { @@ -316,21 +325,38 @@ } ], "source": [ - "evals/2/np.pi" + "from qiskit.providers.aer.utils.pulse_sim_utils import get_dressed_energies, lo_from_hamiltonian\n", + "get_dressed_energies(rabi_qobj, backend_options)[0]/2/np.pi" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The dressed energy for qubit 0 is $4.9990098$, and for qubit 1 is $5.1009902$. The simulator will automatically pick these values out for the qubit lo frequencies due to the high overlap of the eigenstate with the first excited state of the corresponding qubit. The function `lo_from_hamiltonian` reports the oscillator frequences resulting from this choice:" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "text/plain": [ + "OrderedDict([('D0', 4.999009804864072),\n", + " ('U0', 4.999009804864072),\n", + " ('D1', 5.100990195135927),\n", + " ('U1', 0.10198039027185501)])" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + } + ], "source": [ - "qubit_lo_freq = [evals[1]/2/np.pi, evals[3]/2/np.pi]\n", - "\n", - "rabi_qobj = assemble(schedules, backend_real, \n", - " meas_level=1, meas_return='avg', \n", - " memory_slots=2, qubit_lo_freq=qubit_lo_freq,\n", - " shots=shots)" + "lo_from_hamiltonian(rabi_qobj, backend_options)" ] }, { @@ -434,12 +460,12 @@ "name": "stdout", "output_type": "stream", "text": [ - "Pi Amplitude 0.315858\n" + "Pi Amplitude 0.308705\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -538,7 +564,7 @@ "source": [ "readout_qobj = assemble(excited_exp_schedules, backend_real, \n", " meas_level=1, meas_return='single', \n", - " memory_slots=2, qubit_lo_freq=qubit_lo_freq,\n", + " memory_slots=2,\n", " shots=shots)" ] }, @@ -605,7 +631,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -656,7 +682,7 @@ "metadata": {}, "outputs": [], "source": [ - "#qubit to use for exeperiment\n", + "#qubit to use for experiment\n", "qubit = 0\n", "# exp configuration\n", "exps = 41\n", @@ -694,7 +720,7 @@ "source": [ "cr_rabi_qobj = assemble(schedules, backend_real, \n", " meas_level=1, meas_return='avg', \n", - " memory_slots=2, qubit_lo_freq=qubit_lo_freq,\n", + " memory_slots=2,\n", " shots=shots)" ] }, @@ -729,7 +755,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -801,7 +827,7 @@ "source": [ "t1_qobj = assemble(T1_exps, backend_real, \n", " meas_level=1, meas_return='avg', \n", - " memory_slots=2, qubit_lo_freq=qubit_lo_freq,\n", + " memory_slots=2,\n", " shots=100)" ] }, @@ -839,7 +865,7 @@ "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] diff --git a/qiskit/providers/aer/backends/pulse_simulator.py b/qiskit/providers/aer/backends/pulse_simulator.py index 402c449857..dae26da427 100644 --- a/qiskit/providers/aer/backends/pulse_simulator.py +++ b/qiskit/providers/aer/backends/pulse_simulator.py @@ -77,9 +77,7 @@ def _run_job(self, job_id, qobj, if validate: self._validate(qobj, backend_options, noise_model) # Send to solver - qobj_dict = self._format_qobj_dict(qobj, backend_options, - noise_model) - openpulse_system = digest_pulse_obj(qobj_dict) + openpulse_system = digest_pulse_obj(qobj, backend_options, noise_model) results = opsolve(openpulse_system) end = time.time() return self._format_results(job_id, results, end - start, qobj.qobj_id) @@ -98,38 +96,6 @@ def _format_results(self, job_id, results, time_taken, qobj_id): output["time_taken"] = time_taken return Result.from_dict(output) - def _format_qobj_dict(self, qobj, backend_options, noise_model): - """Add additional fields to qobj dictionary""" - # Convert qobj to dict and add additional fields - qobj_dict = qobj.to_dict() - if 'backend_options' not in qobj_dict['config']: - qobj_dict['config']['backend_options'] = {} - - # Temp backwards compatibility - if 'sim_config' in qobj_dict['config']: - for key, val in qobj_dict['config']['sim_config'].itmes(): - qobj_dict['config']['backend_options'][key] = val - qobj_dict['config'].pop('sim_config') - - # Add additional backend options - if backend_options is not None: - for key, val in backend_options.items(): - qobj_dict['config']['backend_options'][key] = val - # Add noise model - if noise_model is not None: - qobj_dict['config']['backend_options']['noise_model'] = noise_model - return qobj_dict - - def get_dressed_energies(self, qobj, - backend_options=None, - noise_model=None): - """Digest the pulse qobj and return the eigenenergies - of the Hamiltonian""" - qobj_dict = self._format_qobj_dict(qobj, backend_options, - noise_model) - openpulse_system = digest_pulse_obj(qobj_dict) - return openpulse_system.evals, openpulse_system.estates - def _validate(self, qobj, backend_options, noise_model): """Validate the pulse object. Make sure a config has been attached in the proper location""" diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 7037fcaf65..6480b48711 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -11,7 +11,7 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -# pylint: disable=eval-used, exec-used, invalid-name +# pylint: disable=eval-used, exec-used, invalid-name, consider-using-enumerate """A module of routines for digesting a PULSE qobj into something we can actually use. @@ -29,12 +29,14 @@ from . import op_qobj as op -def digest_pulse_obj(qobj): +def digest_pulse_obj(qobj_input, backend_options, noise_model): """Takes an input PULSE obj an disgests it into things we can actually make use of. Args: - qobj (Qobj): Qobj of PULSE type. + qobj_input (Qobj): Qobj of PULSE type. + backend_options (dict): backend simulation options + noise_model (dict): currently not supported Returns: OPSystem: The parsed qobj. @@ -46,6 +48,9 @@ def digest_pulse_obj(qobj): # Output data object out = OPSystem() + # take inputs and format into a single dictionary + qobj = _format_qobj_dict(qobj_input, backend_options, noise_model) + # Get the config settings from the qobj config_dict = qobj['config'] if 'backend_options' not in config_dict: @@ -183,15 +188,34 @@ def digest_pulse_obj(qobj): # Setup freqs for the channels out.freqs = OrderedDict() + + # determine whether to compute qubit_lo_freq from hamiltonian + qubit_lo_from_ham = (('qubit_lo_freq' in config_dict_sim) and + (config_dict_sim['qubit_lo_freq'] == 'from_hamiltonian') and + (len(dim_osc) == 0)) or not config_dict['qubit_lo_freq'] + + # set frequencies based on qubit_lo_from_ham value + q_lo_freq = None + if qubit_lo_from_ham: + q_lo_freq = np.zeros(len(dim_qub)) + min_eval = np.min(evals) + for q_idx in range(len(dim_qub)): + single_excite = _first_excited_state(q_idx, dim_qub) + dressed_eval = _eval_for_max_espace_overlap(single_excite, evals, estates) + q_lo_freq[q_idx] = (dressed_eval - min_eval) / (2 * np.pi) + else: + q_lo_freq = config_dict['qubit_lo_freq'] + + # set freqs for key in out.channels.keys(): chidx = int(key[1:]) if key[0] == 'D': - out.freqs[key] = config_dict['qubit_lo_freq'][chidx] + out.freqs[key] = q_lo_freq[chidx] elif key[0] == 'U': out.freqs[key] = 0 for u_lo_idx in config_dict_sim['u_channel_lo'][chidx]: - if u_lo_idx['q'] < len(config_dict['qubit_lo_freq']): - qfreq = config_dict['qubit_lo_freq'][u_lo_idx['q']] + if u_lo_idx['q'] < len(q_lo_freq): + qfreq = q_lo_freq[u_lo_idx['q']] qscale = u_lo_idx['scale'][0] out.freqs[key] += qfreq * qscale else: @@ -254,8 +278,30 @@ def digest_pulse_obj(qobj): return out -def get_diag_hamiltonian(parsed_ham, ham_vars, channels): +def _format_qobj_dict(qobj, backend_options, noise_model): + """Add additional fields to qobj dictionary""" + # Convert qobj to dict and add additional fields + qobj_dict = qobj.to_dict() + if 'backend_options' not in qobj_dict['config']: + qobj_dict['config']['backend_options'] = {} + + # Temp backwards compatibility + if 'sim_config' in qobj_dict['config']: + for key, val in qobj_dict['config']['sim_config'].items(): + qobj_dict['config']['backend_options'][key] = val + qobj_dict['config'].pop('sim_config') + + # Add additional backend options + if backend_options is not None: + for key, val in backend_options.items(): + qobj_dict['config']['backend_options'][key] = val + # Add noise model + if noise_model is not None: + qobj_dict['config']['backend_options']['noise_model'] = noise_model + return qobj_dict + +def get_diag_hamiltonian(parsed_ham, ham_vars, channels): """ Get the diagonal elements of the hamiltonian and get the dressed frequencies and eigenstates @@ -575,3 +621,100 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, structs['can_sample'] = False return structs + + +def _first_excited_state(qubit_idx, dim_qub): + """ + Returns the vector corresponding to all qubits in the 0 state, except for + qubit_idx in the 1 state. + + Assumption: the keys in dim_qub consist exactly of the str version of the int + in range(len(dim_qub)). They don't need to be in order, but they + need to be of this format + + Parameters: + qubit_idx (int): the qubit to be in the 1 state + + dim_qub (dict): a dictionary with keys being qubit index as a string, and + value being the dimension of the qubit + + Returns: + vector: the state with qubit_idx in state 1, and the rest in state 0 + """ + vector = np.array([1.]) + + # iterate through qubits, tensoring on the state + for idx in range(len(dim_qub)): + new_vec = np.zeros(dim_qub[idx]) + if idx == qubit_idx: + new_vec[1] = 1 + else: + new_vec[0] = 1 + + vector = np.kron(new_vec, vector) + + return vector + + +def _eval_for_max_espace_overlap(u, evals, evecs, decimals=14): + """ Given an eigenvalue decomposition evals, evecs, as output from + get_diag_hamiltonian, returns the eigenvalue from evals corresponding + to the eigenspace that the vector vec has the maximum overlap with. + + Parameters: + u (numpy.array): the vector of interest + + evals (numpy.array): list of eigenvalues + + evecs (numpy.array): eigenvectors corresponding to evals + + decimals (int): rounding option, to try to handle numerical + error if two evals should be the same but are + slightly different + + Returns: + eval: eigenvalue corresponding to eigenspace for which vec has + maximal overlap + + Raises: + """ + + # get unique evals (with rounding for numerical error) + rounded_evals = evals.copy().round(decimals=decimals) + unique_evals = np.unique(rounded_evals) + + # compute overlaps to unique evals + overlaps = np.zeros(len(unique_evals)) + for idx, val in enumerate(unique_evals): + overlaps[idx] = _proj_norm(evecs[:, val == rounded_evals], u) + + # return eval with largest overlap + return unique_evals[np.argmax(overlaps)] + + +def _proj_norm(A, b): + """ + Given a matrix A and vector b, computes the norm of the projection of + b onto the column space of A using least squares. + + Note: A can also be specified as a 1d numpy.array, in which case it will + convert it into a matrix with one column + + Parameters: + A (numpy.array): 2d array, a matrix + + b (numpy.array): 1d array, a vector + + Returns: + norm: the norm of the projection + + Raises: + """ + + # if specified as a single vector, turn it into a column vector + if A.ndim == 1: + A = np.array([A]).T + + x = la.lstsq(A, b, rcond=None)[0] + + return la.norm(A@x) diff --git a/qiskit/providers/aer/utils/__init__.py b/qiskit/providers/aer/utils/__init__.py index 133948e85b..8f1024d3bd 100644 --- a/qiskit/providers/aer/utils/__init__.py +++ b/qiskit/providers/aer/utils/__init__.py @@ -14,3 +14,4 @@ from . import qobj_utils from . import helpers +from . import pulse_sim_utils diff --git a/qiskit/providers/aer/utils/pulse_sim_utils.py b/qiskit/providers/aer/utils/pulse_sim_utils.py new file mode 100644 index 0000000000..a60dab4650 --- /dev/null +++ b/qiskit/providers/aer/utils/pulse_sim_utils.py @@ -0,0 +1,33 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +""" +Helper functions for the pulse simulator +""" + +from ..openpulse.qobj.digest import digest_pulse_obj + + +def lo_from_hamiltonian(qobj=None, backend_options=None, noise_model=None): + """Digest the pulse qobj and determine the qubit_lo_freq from the hamiltonian""" + be_options_copy = backend_options.copy() + be_options_copy['qubit_lo_freq'] = 'from_hamiltonian' + openpulse_system = digest_pulse_obj(qobj, be_options_copy, noise_model) + + return openpulse_system.freqs + + +def get_dressed_energies(qobj, backend_options=None, noise_model=None): + """Digest the pulse qobj and return the eigenenergies + of the Hamiltonian""" + openpulse_system = digest_pulse_obj(qobj, backend_options, noise_model) + return openpulse_system.evals, openpulse_system.estates diff --git a/test/terra/openpulse/test_pulse_digest.py b/test/terra/openpulse/test_pulse_digest.py new file mode 100644 index 0000000000..162a99c729 --- /dev/null +++ b/test/terra/openpulse/test_pulse_digest.py @@ -0,0 +1,175 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Tests for option handling in digest.py +""" + +import unittest +from test.terra.common import QiskitAerTestCase +import qiskit +import qiskit.pulse as pulse +from qiskit.pulse import pulse_lib +from qiskit.compiler import assemble +from qiskit.providers.aer.backends.pulse_simulator import digest_pulse_obj +from qiskit.test.mock.fake_openpulse_2q import FakeOpenPulse2Q + + +class BaseTestDigest(QiskitAerTestCase): + """Testing of functions in providers.aer.openpulse.qobj.digest.""" + + def setUp(self): + self.backend = FakeOpenPulse2Q() + self.config = self.backend.configuration() + self.system = pulse.PulseChannelSpec.from_backend(self.backend) + self.backend_sim = qiskit.Aer.get_backend('pulse_simulator') + + +class TestDigestHamiltonian(BaseTestDigest): + r"""Tests for Hamiltonian options and processing.""" + + def test_qubit_lo_from_hamiltonian(self): + """Test backend_options['qubit_lo_freq'] = 'from_hamiltonian'.""" + + # set up inputs to _get_pulse_digest + # Note: for this test the only relevant parameter input to assemble() is self.backend, + # but the others args still need to be valid to assemble correctly + sched_list = [self._valid_2q_schedule()] + qobj = assemble(sched_list, + self.backend, + meas_level=1, + meas_return='avg', + memory_slots=2, + shots=1) + + # set backend_options + backend_options = self.config.to_dict() + backend_options['hamiltonian'] = _create_2q_ham() + backend_options['qubit_list'] = [0, 1] + default_qubit_lo_freq = getattr(self.backend.defaults(), 'qubit_freq_est') + default_u_lo_freq = self._compute_u_lo_freqs(default_qubit_lo_freq) + + # test output of default qubit_lo_freq + openpulse_system = digest_pulse_obj(qobj, backend_options=backend_options, noise_model=None) + self.assertAlmostEqual(openpulse_system.freqs['D0'], default_qubit_lo_freq[0]) + self.assertAlmostEqual(openpulse_system.freqs['D1'], default_qubit_lo_freq[1]) + self.assertAlmostEqual(openpulse_system.freqs['U0'], default_u_lo_freq[0]) + self.assertAlmostEqual(openpulse_system.freqs['U1'], default_u_lo_freq[1]) + + # test auto determination frequencies from_hamiltonian + # (these values were computed by hand) + backend_options['qubit_lo_freq'] = 'from_hamiltonian' + openpulse_system = digest_pulse_obj(qobj, backend_options=backend_options, noise_model=None) + self.assertAlmostEqual(openpulse_system.freqs['D0'], 4.999009804864) + self.assertAlmostEqual(openpulse_system.freqs['D1'], 5.100990195135) + self.assertAlmostEqual(openpulse_system.freqs['U0'], 4.999009804864) + self.assertAlmostEqual(openpulse_system.freqs['U1'], 0.101980390271) + + # test again with different parameters + backend_options['hamiltonian'] = _create_2q_ham(v0=5.1, v1=4.9, j=0.02) + openpulse_system = digest_pulse_obj(qobj, backend_options=backend_options, noise_model=None) + self.assertAlmostEqual(openpulse_system.freqs['D0'], 5.101980390271) + self.assertAlmostEqual(openpulse_system.freqs['D1'], 4.898019609728) + self.assertAlmostEqual(openpulse_system.freqs['U0'], 5.101980390271) + self.assertAlmostEqual(openpulse_system.freqs['U1'], -0.203960780543) + + # test defaults again, but with non-default hamiltonian + del backend_options['qubit_lo_freq'] + openpulse_system = digest_pulse_obj(qobj, backend_options=backend_options, noise_model=None) + self.assertAlmostEqual(openpulse_system.freqs['D0'], default_qubit_lo_freq[0]) + self.assertAlmostEqual(openpulse_system.freqs['D1'], default_qubit_lo_freq[1]) + self.assertAlmostEqual(openpulse_system.freqs['U0'], default_u_lo_freq[0]) + self.assertAlmostEqual(openpulse_system.freqs['U1'], default_u_lo_freq[1]) + + def _compute_u_lo_freqs(self, qubit_lo_freq): + """ + Given qubit_lo_freq, return the computed u_channel_lo. + """ + u_lo_freqs = [] + for scales in self.config.to_dict()['u_channel_lo']: + u_lo_freq = 0 + for u_lo_idx in scales: + qfreq = qubit_lo_freq[u_lo_idx['q']] + qscale = u_lo_idx['scale'][0] + u_lo_freq += qfreq * qscale + u_lo_freqs.append(u_lo_freq) + return u_lo_freqs + + def _valid_2q_schedule(self): + """ Helper method to make a valid 2 qubit schedule + Returns: + schedule (pulse schedule): schedule for 2q experiment + """ + rabi_pulse = pulse_lib.gaussian(duration=128, + amp=0.5, + sigma=16, + name='rabi_pulse') + meas_pulse = pulse_lib.gaussian_square(duration=1200, + amp=0.025, + sigma=4, + risefall=25, + name='meas_pulse') + acq_cmd = pulse.Acquire(duration=10) + + # create measurement schedule + measure_and_acquire = \ + meas_pulse(self.system.qubits[0].measure) | acq_cmd(self.system.acquires, + self.system.memoryslots) + + # add commands to schedule + schedule = pulse.Schedule(name='rabi_exp') + + schedule += rabi_pulse(self.system.qubits[0].drive) + schedule += measure_and_acquire << schedule.duration + + return schedule + + +def _create_2q_ham(v0=5.0, + v1=5.1, + j=0.01, + r=0.02, + alpha0=-0.33, + alpha1=-0.33, + qub_dim=3): + """Create standard 2 qubit Hamiltonian, with various parameters. + The defaults are those present in self.config.hamiltonian. + Returns: + hamiltonian (dict): dictionary representation of two qubit hamiltonian + """ + + hamiltonian = {} + hamiltonian['h_str'] = [] + # Q0 terms + hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0') + hamiltonian['h_str'].append('np.pi*alpha0*O0*O0') + hamiltonian['h_str'].append('2*np.pi*r*X0||D0') + hamiltonian['h_str'].append('2*np.pi*r*X0||U1') + hamiltonian['h_str'].append('2*np.pi*r*X1||U0') + + # Q1 terms + hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1') + hamiltonian['h_str'].append('np.pi*alpha1*O1*O1') + hamiltonian['h_str'].append('2*np.pi*r*X1||D1') + + # Exchange coupling betwene Q0 and Q1 + hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)') + hamiltonian['vars'] = {'v0': v0, 'v1': v1, 'j': j, + 'r': r, 'alpha0': alpha0, 'alpha1': alpha1} + + # set the qubit dimensions to 3 + hamiltonian['qub'] = {'0': qub_dim, '1': qub_dim} + + return hamiltonian + + +if __name__ == '__main__': + unittest.main() From 69b0d78bfde63186ea57abb787149cf6151e21e2 Mon Sep 17 00:00:00 2001 From: Daniel Puzzuoli Date: Fri, 6 Dec 2019 12:34:37 -0500 Subject: [PATCH 13/24] added warnings in digest_pulse_obj for unsupported features -rerun --- qiskit/providers/aer/openpulse/qobj/digest.py | 26 +++++++++++++++++++ 1 file changed, 26 insertions(+) diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 6480b48711..9d1b0879a7 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -17,6 +17,7 @@ into something we can actually use. """ +from warnings import warn from collections import OrderedDict import numpy as np import numpy.linalg as la @@ -61,6 +62,15 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): raise ValueError('Qobj must have hamiltonian in config to simulate.') hamiltonian = config_dict_sim['hamiltonian'] + # Warnings for untested features + warning_str = '{} are an untested feature, and therefore may not behave as expected.' + if 'osc' in hamiltonian.keys(): + warn(warning_str.format('Oscillator-type systems')) + if noise_model is not None: + warn(warning_str.format('Noise models')) + if _contains_pv_instruction(qobj['experiments']): + warn(warning_str.format('PersistentValue instructions')) + # Get qubit number qubit_list = config_dict_sim.get('qubit_list', None) if qubit_list is None: @@ -301,6 +311,22 @@ def _format_qobj_dict(qobj, backend_options, noise_model): return qobj_dict +def _contains_pv_instruction(experiments): + """ Return True if the list of experiments from the output of _format_qobj_dict contains + a PersistentValue instruction + Parameters: + experiments (list): list of schedules + Returns: + True or False: whether or not the schedules contain a PersistentValue command + Raises: + """ + for exp in experiments: + for inst in exp['instructions']: + if inst['name'] == 'pv': + return True + return False + + def get_diag_hamiltonian(parsed_ham, ham_vars, channels): """ Get the diagonal elements of the hamiltonian and get the dressed frequencies and eigenstates From dda0304daf703aa1b83c8d12b69f54e173c2fa8e Mon Sep 17 00:00:00 2001 From: Daniel Puzzuoli Date: Sun, 8 Dec 2019 13:46:08 -0500 Subject: [PATCH 14/24] Fix pulse schedule `dt` parameter not being applied in pulse simulator (#473) * fixed handling of time in digest.experiment_to_structs by changing all appearances of inst['t0'] to inst['t0']*dt * Added test test_dt_scaling_x_gate to TestPulseSimulator This tests that dt is being used correctly. The structure of the test is the same as test_x_gate; but runs the test multiple times with different dt values, along with the other parameters scaled accordingly, so that all of the simulations have different dt values but should have the same result. This test fails on the original code this branch was created from, but passes on the current branch. --- qiskit/providers/aer/openpulse/qobj/digest.py | 32 ++++++++-------- test/terra/backends/test_pulse_simulator.py | 37 +++++++++++++++++++ 2 files changed, 53 insertions(+), 16 deletions(-) diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 9d1b0879a7..532911ad87 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -528,7 +528,7 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, # If last pulse on channel was a PV then need to set # its final time to be start time of current pulse if pv_needs_tf[ham_chans[chan_name]]: - structs['channels'][chan_name][0][-3] = inst['t0'] + structs['channels'][chan_name][0][-3] = inst['t0'] * dt pv_needs_tf[ham_chans[chan_name]] = 0 # Get condtional info @@ -543,16 +543,16 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, if pv[0] == inst['val']: index = pv[1] break - structs['channels'][chan_name][0].extend([inst['t0'], None, index, cond]) + structs['channels'][chan_name][0].extend([inst['t0'] * dt, None, index, cond]) pv_needs_tf[ham_chans[chan_name]] = 1 # Frame changes elif inst['name'] == 'fc': - structs['channels'][chan_name][1].extend([inst['t0'], inst['phase'], cond]) + structs['channels'][chan_name][1].extend([inst['t0'] * dt, inst['phase'], cond]) # A standard pulse else: - start = inst['t0'] + start = inst['t0'] * dt pulse_int = pulse_to_int[inst['name']] pulse_width = (pulse_inds[pulse_int + 1] - pulse_inds[pulse_int]) * dt stop = start + pulse_width @@ -577,7 +577,7 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, qlist2.append(qb) mlist2.append(inst['memory_slot'][qind]) - acq_vals = [inst['t0'], + acq_vals = [inst['t0'] * dt, np.asarray(qlist2, dtype=np.uint32), np.asarray(mlist2, dtype=np.uint32) ] @@ -589,15 +589,15 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, structs['acquire'].append(acq_vals) # update max_time - max_time = max(max_time, inst['t0'] + dt * inst['duration']) + max_time = max(max_time, (inst['t0'] + inst['duration']) * dt) # Add time to tlist - if inst['t0'] not in structs['tlist']: - structs['tlist'].append(inst['t0']) + if inst['t0'] * dt not in structs['tlist']: + structs['tlist'].append(inst['t0'] * dt) # conditionals elif inst['name'] == 'bfunc': - bfun_vals = [inst['t0'], inst['mask'], inst['relation'], + bfun_vals = [inst['t0'] * dt, inst['mask'], inst['relation'], inst['val'], inst['register']] if 'memory' in inst.keys(): bfun_vals.append(inst['memory']) @@ -607,24 +607,24 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, structs['cond'].append(acq_vals) # update max_time - max_time = max(max_time, inst['t0']) + max_time = max(max_time, inst['t0'] * dt) # Add time to tlist - if inst['t0'] not in structs['tlist']: - structs['tlist'].append(inst['t0']) + if inst['t0'] * dt not in structs['tlist']: + structs['tlist'].append(inst['t0'] * dt) # snapshots elif inst['name'] == 'snapshot': if inst['type'] != 'state': raise TypeError("Snapshots must be of type 'state'") - structs['snapshot'].append([inst['t0'], inst['label']]) + structs['snapshot'].append([inst['t0'] * dt, inst['label']]) # Add time to tlist - if inst['t0'] not in structs['tlist']: - structs['tlist'].append(inst['t0']) + if inst['t0'] * dt not in structs['tlist']: + structs['tlist'].append(inst['t0'] * dt) # update max_time - max_time = max(max_time, inst['t0']) + max_time = max(max_time, inst['t0'] * dt) # If any PVs still need time then they are at the end # and should just go til final time diff --git a/test/terra/backends/test_pulse_simulator.py b/test/terra/backends/test_pulse_simulator.py index 4bdfbc44a1..eca3aab8ab 100644 --- a/test/terra/backends/test_pulse_simulator.py +++ b/test/terra/backends/test_pulse_simulator.py @@ -344,6 +344,43 @@ def create_qobj(self, shots, meas_level, schedule, qobj_params): # Test single qubit gates (using meas level 2 and square drive) # --------------------------------------------------------------------- + def test_dt_scaling_x_gate(self): + """ + Test that dt is being used correctly by the simulator + """ + + # do the same thing as test_x_gate, but scale dt and all frequency parameters + # define test case for a single scaling + def scale_test(scale): + # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance + omega_0 = 2 * np.pi * self.freq_qubit_0/scale + omega_d0 = omega_0 + + # Require omega_a*time = pi to implement pi pulse (x gate) + # num of samples gives time + omega_a = np.pi / self.drive_samples/scale + + phi = 0 + + x_schedule = self.single_pulse_schedule(phi) + x_qobj_params = self.qobj_params_1q(omega_d0) + x_qobj = self.create_qobj(shots=256, + meas_level=2, + schedule=x_schedule, + qobj_params=x_qobj_params) + x_backend_opts = self.backend_options_1q(omega_0, omega_a) + x_backend_opts['dt'] = x_backend_opts['dt']*scale + result = self.backend_sim.run(x_qobj, + backend_options=x_backend_opts).result() + counts = result.get_counts() + exp_counts = {'1': 256} + + self.assertDictAlmostEqual(counts, exp_counts) + # set scales and run tests + scales = [2.,1.3453, 0.1234, 10.**5,10**-5] + for scale in scales: + scale_test(scale) + def test_x_gate(self): """ Test x gate. Set omega_d0=omega_0 (drive on resonance), phi=0, omega_a = pi/time From f1da1b4e20525bd7945d5c9cbf8c240155ee81ea Mon Sep 17 00:00:00 2001 From: Daniel Puzzuoli Date: Mon, 9 Dec 2019 10:04:38 -0500 Subject: [PATCH 15/24] Moved warnings for unsupported features in digest.py to the function 'unsupported_warnings' --- qiskit/providers/aer/openpulse/qobj/digest.py | 32 +++++++++++++------ 1 file changed, 23 insertions(+), 9 deletions(-) diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 532911ad87..9e2b85f931 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -52,6 +52,9 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): # take inputs and format into a single dictionary qobj = _format_qobj_dict(qobj_input, backend_options, noise_model) + # post warnings for unsupported features + _unsupported_warnings(qobj) + # Get the config settings from the qobj config_dict = qobj['config'] if 'backend_options' not in config_dict: @@ -62,15 +65,6 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): raise ValueError('Qobj must have hamiltonian in config to simulate.') hamiltonian = config_dict_sim['hamiltonian'] - # Warnings for untested features - warning_str = '{} are an untested feature, and therefore may not behave as expected.' - if 'osc' in hamiltonian.keys(): - warn(warning_str.format('Oscillator-type systems')) - if noise_model is not None: - warn(warning_str.format('Noise models')) - if _contains_pv_instruction(qobj['experiments']): - warn(warning_str.format('PersistentValue instructions')) - # Get qubit number qubit_list = config_dict_sim.get('qubit_list', None) if qubit_list is None: @@ -311,9 +305,29 @@ def _format_qobj_dict(qobj, backend_options, noise_model): return qobj_dict +def _unsupported_warnings(qobj_dict): + """ Warns the user about untested/unsupported features. + + Parameters: + qobj_dict (dict): Formatted qobj_dict from _format_qobj_dict + Returns: + Raises: + """ + + # Warnings that don't stop execution + warning_str = '{} are an untested feature, and therefore may not behave as expected.' + if 'osc' in qobj_dict['config']['backend_options']['hamiltonian'].keys(): + warn(warning_str.format('Oscillator-type systems')) + if 'noise_model' in qobj_dict['config']['backend_options']: + warn(warning_str.format('Noise models')) + if _contains_pv_instruction(qobj_dict['experiments']): + warn(warning_str.format('PersistentValue instructions')) + + def _contains_pv_instruction(experiments): """ Return True if the list of experiments from the output of _format_qobj_dict contains a PersistentValue instruction + Parameters: experiments (list): list of schedules Returns: From 0b45f12986555f4adbe3d2e7ad90d60b863f7d10 Mon Sep 17 00:00:00 2001 From: Daniel Puzzuoli Date: Mon, 9 Dec 2019 16:53:44 -0500 Subject: [PATCH 16/24] Issue 478 pulsesim test errors (#479) - Changed 'seed' in digest_pulse_obj to be drawn from config_dict_sim instead of config_dict config_dict_sim pertains to aspects of the simulation, so it is a more natural place for this option to be drawn from. - Corrected change in digest.py from last commit for drawing 'seed' from config_dict_sim. - Updated functions backend_options_1q and backend_options_2q in TestPulseSimulator to also set a 'seed' to make tests deterministic. Ran tests a few times and verified that the random results of simulations (e.g. counts) became deterministic. - Corrected the skipping of 'test_persistent_value' to be done with the '@unittest.skip' decorator. --- qiskit/providers/aer/openpulse/qobj/digest.py | 4 ++-- test/terra/backends/test_pulse_simulator.py | 3 +++ 2 files changed, 5 insertions(+), 2 deletions(-) diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 9e2b85f931..978bdb43d2 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -89,8 +89,8 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): out.global_data['meas_return'] = config_dict['meas_return'] out.global_data['seed'] = None - if 'seed' in config_keys: - out.global_data['seed'] = int(config_dict['seed']) + if 'seed' in config_keys_sim: + out.global_data['seed'] = int(config_dict_sim['seed']) if 'memory_slots' in config_keys: out.global_data['memory_slots'] = config_dict['memory_slots'] diff --git a/test/terra/backends/test_pulse_simulator.py b/test/terra/backends/test_pulse_simulator.py index eca3aab8ab..114cc47e16 100644 --- a/test/terra/backends/test_pulse_simulator.py +++ b/test/terra/backends/test_pulse_simulator.py @@ -263,6 +263,7 @@ def backend_options_1q(self, omega_0, omega_a, qub_dim=2): backend_options['qubit_list'] = [self.qubit_0] backend_options['dt'] = 1.0 # makes time = self.drive_samples backend_options['ode_options'] = {} # optionally set ode settings + backend_options['seed'] = 90841 return backend_options def backend_options_2q(self, omega_0, omega_a, omega_i, qub_dim=2): @@ -283,6 +284,7 @@ def backend_options_2q(self, omega_0, omega_a, omega_i, qub_dim=2): backend_options['qubit_list'] = [self.qubit_0, self.qubit_1] backend_options['dt'] = 1.0 # makes time = self.drive_samples backend_options['ode_options'] = {} # optionally set ode settings + backend_options['seed'] = 12387 return backend_options def qobj_params_1q(self, omega_d0): @@ -721,6 +723,7 @@ def test_frame_change(self): exp_prop_shift = self._analytic_prop_fc(np.pi / 4 - np.pi / 8) self.assertDictAlmostEqual(prop_shift, exp_prop_shift, delta=0.01) + @unittest.skip("PerisitentValue pulses are currently not supported.") def test_persistent_value(self): """Test persistent value command. """ From c5fb127c1c6b4b96093fb3c7b5c6eb5fb4101465 Mon Sep 17 00:00:00 2001 From: "Christopher J. Wood" Date: Thu, 12 Dec 2019 21:13:06 -0500 Subject: [PATCH 17/24] Add HamiltonianModel class for configuring PulseSimulator (#493) * Add HamiltonianModel class for pulse simulator * update digest to use HamiltonianModel * change statevector pulse tests to use state_fidelity --- .../aer/openpulse/hamiltonian_model.py | 310 ++++++++++++++ qiskit/providers/aer/openpulse/qobj/digest.py | 402 +++--------------- .../providers/aer/openpulse/qobj/op_system.py | 2 + test/terra/backends/test_pulse_simulator.py | 38 +- test/terra/openpulse/__init__.py | 32 ++ test/terra/openpulse/test_pulse_digest.py | 45 +- 6 files changed, 449 insertions(+), 380 deletions(-) create mode 100644 qiskit/providers/aer/openpulse/hamiltonian_model.py create mode 100644 test/terra/openpulse/__init__.py diff --git a/qiskit/providers/aer/openpulse/hamiltonian_model.py b/qiskit/providers/aer/openpulse/hamiltonian_model.py new file mode 100644 index 0000000000..e207f88248 --- /dev/null +++ b/qiskit/providers/aer/openpulse/hamiltonian_model.py @@ -0,0 +1,310 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=eval-used, exec-used, invalid-name + +"HamiltonianModel class for system specification for the PulseSimulator" + +from collections import OrderedDict +import numpy as np +import numpy.linalg as la +from .qobj.opparse import HamiltonianParser + + +class HamiltonianModel(): + """Hamiltonian model for pulse simulator.""" + def __init__(self, hamiltonian, qubits=None): + """Initialize a Hamiltonian model. + + Args: + hamiltonian (dict): Hamiltonian dictionary. + qubits (list or None): List of qubits to extract from the hamiltonian. + + Raises: + ValueError: if arguments are invalid. + """ + # Initialize internal variables + # The system Hamiltonian in numerical format + self._system = None + # System variables + self._vars = None + # Channels in the Hamiltonian string + # These tell the order in which the channels are evaluated in + # the RHS solver. + self._channels = None + # Diagonal elements of the hamiltonian + self._h_diag = None + # Eigenvalues of the time-independent hamiltonian + self._evals = None + # Eigenstates of the time-indepedent hamiltonian + self._estates = None + # Qubit subspace dimensinos + self._dim_qub = {} + # Oscillator subspace dimensions + self._dim_osc = {} + + # Parse Hamiltonian + # TODO: determine n_qubits from hamiltonian if qubits is None + n_qubits = len(qubits) if qubits else None + if not n_qubits: + raise ValueError("TODO: Need to infer n_qubits from " + "Hamiltonian if qubits list is not specified") + + self._vars = OrderedDict(hamiltonian['vars']) + + # Get qubit subspace dimensions + if 'qub' in hamiltonian: + self._dim_qub = { + int(key): val + for key, val in hamiltonian['qub'].items() + } + else: + self._dim_qub = {}.fromkeys(range(n_qubits), 2) + + # Get oscillator subspace dimensions + if 'osc' in hamiltonian: + self._dim_osc = { + int(key): val + for key, val in hamiltonian['osc'].items() + } + + # Step 1: Parse the Hamiltonian + system = HamiltonianParser(h_str=hamiltonian['h_str'], + dim_osc=self._dim_osc, + dim_qub=self._dim_qub) + system.parse(qubits) + self._system = system.compiled + + # Step #2: Determine Hamiltonian channels + self._calculate_hamiltonian_channels() + + # Step 3: Calculate diagonal hamiltonian + self._calculate_drift_hamiltonian() + + def calculate_frequencies(self, qubit_lo_freq=None, u_channel_lo=None): + """Calulate frequencies for the Hamiltonian. + + Args: + qubit_lo_freq (list or None): list of qubit linear + oscillator drive frequencies. If None these will be calcualted + automatically from hamiltonian (Default: None). + u_channel_lo (list or None): list of u channel parameters (Default: None). + + Returns: + OrderedDict: a dictionary of channel frequencies. + + Raises: + ValueError: If channel or u_channel_lo are invalid. + """ + # TODO: Update docstring with description of what qubit_lo_freq and + # u_channel_lo are + + # Setup freqs for the channels + freqs = OrderedDict() + + # Set qubit frequencies from hamiltonian + if not qubit_lo_freq or ( + qubit_lo_freq == 'from_hamiltonian' and len(self._dim_osc) == 0): + qubit_lo_freq = np.zeros(len(self._dim_qub)) + min_eval = np.min(self._evals) + for q_idx in range(len(self._dim_qub)): + single_excite = _first_excited_state(q_idx, self._dim_qub) + dressed_eval = _eval_for_max_espace_overlap( + single_excite, self._evals, self._estates) + qubit_lo_freq[q_idx] = (dressed_eval - min_eval) / (2 * np.pi) + + # TODO: set u_channel_lo from hamiltonian + if not u_channel_lo: + raise ValueError("u_channel_lo cannot be None.") + + # Set frequencies + for key in self._channels.keys(): + chidx = int(key[1:]) + if key[0] == 'D': + freqs[key] = qubit_lo_freq[chidx] + elif key[0] == 'U': + freqs[key] = 0 + for u_lo_idx in u_channel_lo[chidx]: + if u_lo_idx['q'] < len(qubit_lo_freq): + qfreq = qubit_lo_freq[u_lo_idx['q']] + qscale = u_lo_idx['scale'][0] + freqs[key] += qfreq * qscale + else: + raise ValueError("Channel is not D or U") + return freqs + + def _calculate_hamiltonian_channels(self): + """ Get all the qubit channels D_i and U_i in the string + representation of a system Hamiltonian. + + Raises: + Exception: Missing index on channel. + """ + channels = [] + for _, ham_str in self._system: + chan_idx = [ + i for i, letter in enumerate(ham_str) if letter in ['D', 'U'] + ] + for ch in chan_idx: + if (ch + 1) == len(ham_str) or not ham_str[ch + 1].isdigit(): + raise Exception('Channel name must include' + + 'an integer labeling the qubit.') + for kk in chan_idx: + done = False + offset = 0 + while not done: + offset += 1 + if not ham_str[kk + offset].isdigit(): + done = True + # In case we hit the end of the string + elif (kk + offset + 1) == len(ham_str): + done = True + offset += 1 + temp_chan = ham_str[kk:kk + offset] + if temp_chan not in channels: + channels.append(temp_chan) + channels.sort(key=lambda x: (int(x[1:]), x[0])) + + channel_dict = OrderedDict() + for idx, val in enumerate(channels): + channel_dict[val] = idx + + self._channels = channel_dict + + def _calculate_drift_hamiltonian(self): + """Calculate the the drift Hamiltonian. + + This computes the dressed frequencies and eigenstates of the + diagonal part of the Hamiltonian. + + Raises: + Exception: Missing index on channel. + """ + # Get the diagonal elements of the hamiltonian with all the + # drive terms set to zero + for chan in self._channels: + exec('%s=0' % chan) + + # might be a better solution to replace the 'var' in the hamiltonian + # string with 'op_system.vars[var]' + for var in self._vars: + exec('%s=%f' % (var, self._vars[var])) + + ham_full = np.zeros(np.shape(self._system[0][0].full()), dtype=complex) + for ham_part in self._system: + ham_full += ham_part[0].full() * eval(ham_part[1]) + # Remap eigenvalues and eigenstates + evals, estates = la.eigh(ham_full) + + evals_mapped = np.zeros(evals.shape, dtype=evals.dtype) + estates_mapped = np.zeros(estates.shape, dtype=estates.dtype) + + for i, estate in enumerate(estates.T): + pos = np.argmax(np.abs(estate)) + evals_mapped[pos] = evals[i] + estates_mapped[:, pos] = estate + + self._evals = evals_mapped + self._estates = estates_mapped + self._h_diag = np.ascontiguousarray(np.diag(ham_full).real) + + +def _first_excited_state(qubit_idx, dim_qub): + """ + Returns the vector corresponding to all qubits in the 0 state, except for + qubit_idx in the 1 state. + + Assumption: the keys in dim_qub consist exactly of the str version of the int + in range(len(dim_qub)). They don't need to be in order, but they + need to be of this format + + Parameters: + qubit_idx (int): the qubit to be in the 1 state + + dim_qub (dict): a dictionary with keys being qubit index, and + value being the dimension of the qubit + + Returns: + vector: the state with qubit_idx in state 1, and the rest in state 0 + """ + vector = np.array([1.]) + # iterate through qubits, tensoring on the state + for qubit, dim in dim_qub.items(): + new_vec = np.zeros(dim) + if int(qubit) == qubit_idx: + new_vec[1] = 1 + else: + new_vec[0] = 1 + vector = np.kron(new_vec, vector) + + return vector + + +def _eval_for_max_espace_overlap(u, evals, evecs, decimals=14): + """Return the eigenvalue for eigenvector closest to input. + + Given an eigenvalue decomposition evals, evecs, as output from + get_diag_hamiltonian, returns the eigenvalue from evals corresponding + to the eigenspace that the vector vec has the maximum overlap with. + + Args: + u (numpy.array): the vector of interest + evals (numpy.array): list of eigenvalues + evecs (numpy.array): eigenvectors corresponding to evals + decimals (int): rounding option, to try to handle numerical + error if two evals should be the same but are + slightly different + + Returns: + complex: eigenvalue corresponding to eigenspace for which vec has + maximal overlap. + """ + # get unique evals (with rounding for numerical error) + rounded_evals = evals.copy().round(decimals=decimals) + unique_evals = np.unique(rounded_evals) + + # compute overlaps to unique evals + overlaps = np.zeros(len(unique_evals)) + for idx, val in enumerate(unique_evals): + overlaps[idx] = _proj_norm(evecs[:, val == rounded_evals], u) + + # return eval with largest overlap + return unique_evals[np.argmax(overlaps)] + + +def _proj_norm(mat, vec): + """ + Compute the projection form of a vector an matrix. + + Given a matrix ``mat`` and vector ``vec``, computes the norm of the + projection of ``vec`` onto the column space of ``mat`` using least + squares. + + Note: ``mat`` can also be specified as a 1d numpy.array, in which + case it will convert it into a matrix with one column + + Parameters: + mat (numpy.array): 2d array, a matrix. + vec (numpy.array): 1d array, a vector. + + Returns: + complex: the norm of the projection + """ + + # if specified as a single vector, turn it into a column vector + if mat.ndim == 1: + mat = np.array([mat]).T + + lsq_vec = la.lstsq(mat, vec, rcond=None)[0] + + return la.norm(mat @ lsq_vec) diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 978bdb43d2..9916f23d4d 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -11,7 +11,7 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -# pylint: disable=eval-used, exec-used, invalid-name, consider-using-enumerate +# pylint: disable=invalid-name """A module of routines for digesting a PULSE qobj into something we can actually use. @@ -20,11 +20,11 @@ from warnings import warn from collections import OrderedDict import numpy as np -import numpy.linalg as la from .op_system import OPSystem -from .opparse import HamiltonianParser, NoiseParser +from .opparse import NoiseParser from .operators import qubit_occ_oper_dressed from ..solver.options import OPoptions +from ..hamiltonian_model import HamiltonianModel # pylint: disable=no-name-in-module,import-error from ..cy.utils import oplist_to_array from . import op_qobj as op @@ -58,105 +58,65 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): # Get the config settings from the qobj config_dict = qobj['config'] if 'backend_options' not in config_dict: - raise ValueError('Pulse Qobj must have "sim_config".') + raise ValueError('Pulse Qobj must have "backend_options".') config_dict_sim = config_dict['backend_options'] - noise_dict = config_dict_sim.get('noise_model', {}) + + # Parse config settings + if 'memory_slots' not in config_dict: + raise ValueError('Number of memory_slots must be specific in Qobj config') + out.global_data['shots'] = int(config_dict.get('shots', 1024)) + out.global_data['meas_level'] = int(config_dict.get('meas_level', 1)) + out.global_data['meas_return'] = config_dict.get('meas_return', 'avg') + out.global_data['seed'] = config_dict_sim.get('seed', None) + out.global_data['memory_slots'] = config_dict.get('memory_slots', 0) + out.global_data['memory'] = config_dict.get('memory', False) + out.global_data['n_registers'] = config_dict.get('n_registers', 0) + out.global_data['q_level_meas'] = int(config_dict_sim.get('q_level_meas', 1)) + + # Attach the ODE options + allowed_ode_options = ['atol', 'rtol', 'nsteps', 'max_step', + 'num_cpus', 'norm_tol', 'norm_steps', + 'rhs_reuse', 'rhs_filename'] + ode_options = config_dict_sim.get('ode_options', {}) + for key in ode_options: + if key not in allowed_ode_options: + raise Exception('Invalid ode_option: {}'.format(key)) + out.ode_options = OPoptions(**ode_options) + + # Parse the hamiltonian if 'hamiltonian' not in config_dict_sim: raise ValueError('Qobj must have hamiltonian in config to simulate.') hamiltonian = config_dict_sim['hamiltonian'] - # Get qubit number qubit_list = config_dict_sim.get('qubit_list', None) if qubit_list is None: qubit_list = list(range(config_dict_sim['n_qubits'])) else: config_dict_sim['n_qubits'] = len(qubit_list) - - config_keys_sim = config_dict_sim.keys() - config_keys = config_dict.keys() - - # Look for config keys - out.global_data['shots'] = 1024 - if 'shots' in config_keys: - out.global_data['shots'] = int(config_dict['shots']) - - out.global_data['meas_level'] = 1 - if 'meas_level' in config_keys: - out.global_data['meas_level'] = int(config_dict['meas_level']) - - out.global_data['meas_return'] = 'avg' - if 'meas_return' in config_keys: - out.global_data['meas_return'] = config_dict['meas_return'] - - out.global_data['seed'] = None - if 'seed' in config_keys_sim: - out.global_data['seed'] = int(config_dict_sim['seed']) - - if 'memory_slots' in config_keys: - out.global_data['memory_slots'] = config_dict['memory_slots'] - else: - err_str = 'Number of memory_slots must be specific in Qobj config' - raise ValueError(err_str) - - if 'memory' in config_keys: - out.global_data['memory'] = config_dict['memory'] - else: - out.global_data['memory'] = False - - out.global_data['n_registers'] = 0 - if 'n_registers' in config_keys: - out.global_data['n_registers'] = config_dict['n_registers'] - - # which level to measure - out.global_data['q_level_meas'] = 1 - if 'q_level_meas' in config_keys_sim: - out.global_data['q_level_meas'] = int(config_dict_sim['q_level_meas']) - - # Attach the ODE options - allowed_ode_options = ['atol', 'rtol', 'nsteps', 'max_step', - 'num_cpus', 'norm_tol', 'norm_steps', - 'rhs_reuse', 'rhs_filename'] - user_set_ode_options = {} - if 'ode_options' in config_keys_sim: - for key, val in config_dict_sim['ode_options'].items(): - if key not in allowed_ode_options: - raise Exception('Invalid ode_option: {}'.format(key)) - user_set_ode_options[key] = val - out.ode_options = OPoptions(**user_set_ode_options) - - # Step #1: Parse hamiltonian representation - out.vars = OrderedDict(hamiltonian['vars']) + qubit_lo_freq = config_dict_sim.get('qubit_lo_freq', + config_dict['qubit_lo_freq']) + u_channel_lo = config_dict_sim.get('u_channel_lo') + + ham_model = HamiltonianModel(hamiltonian, qubit_list) + # For now we dump this into OpSystem, though that should be refactored + out.system = ham_model._system + out.vars = ham_model._vars + out.channels = ham_model._channels + out.freqs = ham_model.calculate_frequencies(qubit_lo_freq=qubit_lo_freq, + u_channel_lo=u_channel_lo) + out.h_diag = ham_model._h_diag + out.evals = ham_model._evals + out.estates = ham_model._estates + dim_qub = ham_model._dim_qub + dim_osc = ham_model._dim_osc + # convert estates into a Qutip qobj + estates = [op.state(state) for state in ham_model._estates.T[:]] + out.initial_state = estates[0] out.global_data['vars'] = list(out.vars.values()) + out.global_data['freqs'] = list(out.freqs.values()) - # Get qubit subspace dimensions - if 'qub' in hamiltonian.keys(): - dim_qub = hamiltonian['qub'] - _dim_qub = {} - # Convert str keys to int keys - for key, val in hamiltonian['qub'].items(): - _dim_qub[int(key)] = val - dim_qub = _dim_qub - else: - dim_qub = {}.fromkeys(range(config_dict_sim['n_qubits']), 2) - - # Get oscillator subspace dimensions - if 'osc' in hamiltonian.keys(): - dim_osc = hamiltonian['osc'] - _dim_osc = {} - # Convert str keys to int keys - for key, val in dim_osc.items(): - _dim_osc[int(key)] = val - dim_osc = _dim_osc - else: - dim_osc = {} - - # Parse the Hamiltonian - system = HamiltonianParser(h_str=hamiltonian['h_str'], - dim_osc=dim_osc, - dim_qub=dim_qub) - system.parse(qubit_list) - out.system = system.compiled - + # Parse noise + noise_dict = config_dict_sim.get('noise_model', {}) if noise_dict: noise = NoiseParser(noise_dict=noise_dict, dim_osc=dim_osc, dim_qub=dim_qub) @@ -169,72 +129,14 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): else: out.noise = None - # Step #2: Get Hamiltonian channels - out.channels = get_hamiltonian_channels(out.system) - - h_diag, evals, estates = get_diag_hamiltonian(out.system, - out.vars, out.channels) - - # convert estates into a qobj - estates_qobj = [] - for kk in range(len(estates[:, ])): - estates_qobj.append(op.state(estates[:, kk])) - - out.h_diag = np.ascontiguousarray(h_diag.real) - out.evals = evals - out.estates = estates - - # Set initial state - out.initial_state = 0 * op.basis(len(evals), 1) - for idx, estate_coef in enumerate(estates[:, 0]): - out.initial_state += estate_coef * op.basis(len(evals), idx) - # init_fock_state(dim_osc, dim_qub) - - # Setup freqs for the channels - out.freqs = OrderedDict() - - # determine whether to compute qubit_lo_freq from hamiltonian - qubit_lo_from_ham = (('qubit_lo_freq' in config_dict_sim) and - (config_dict_sim['qubit_lo_freq'] == 'from_hamiltonian') and - (len(dim_osc) == 0)) or not config_dict['qubit_lo_freq'] - - # set frequencies based on qubit_lo_from_ham value - q_lo_freq = None - if qubit_lo_from_ham: - q_lo_freq = np.zeros(len(dim_qub)) - min_eval = np.min(evals) - for q_idx in range(len(dim_qub)): - single_excite = _first_excited_state(q_idx, dim_qub) - dressed_eval = _eval_for_max_espace_overlap(single_excite, evals, estates) - q_lo_freq[q_idx] = (dressed_eval - min_eval) / (2 * np.pi) - else: - q_lo_freq = config_dict['qubit_lo_freq'] - - # set freqs - for key in out.channels.keys(): - chidx = int(key[1:]) - if key[0] == 'D': - out.freqs[key] = q_lo_freq[chidx] - elif key[0] == 'U': - out.freqs[key] = 0 - for u_lo_idx in config_dict_sim['u_channel_lo'][chidx]: - if u_lo_idx['q'] < len(q_lo_freq): - qfreq = q_lo_freq[u_lo_idx['q']] - qscale = u_lo_idx['scale'][0] - out.freqs[key] += qfreq * qscale - else: - raise ValueError("Channel is not D or U") - - out.global_data['freqs'] = list(out.freqs.values()) - - # Step #3: Build pulse arrays + # Build pulse arrays pulses, pulses_idx, pulse_dict = build_pulse_arrays(qobj) out.global_data['pulse_array'] = pulses out.global_data['pulse_indices'] = pulses_idx out.pulse_to_int = pulse_dict - # Step #4: Get dt + # Get dt if 'dt' not in config_dict_sim.keys(): raise ValueError('Qobj must have a dt value to simulate.') out.dt = config_dict_sim['dt'] @@ -249,7 +151,8 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): min_width = min(min_width, stop - start) out.ode_options.max_step = min_width / 2 * out.dt - # Step #6: Convert experiments to data structures. + # Convert experiments to data structures. + # convert estates into a qobj out.global_data['measurement_ops'] = [None] * config_dict_sim['n_qubits'] @@ -270,7 +173,7 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): if not out.global_data['measurement_ops'][jj]: out.global_data['measurement_ops'][jj] = \ qubit_occ_oper_dressed(jj, - estates_qobj, + estates, h_osc=dim_osc, h_qub=dim_qub, level=out.global_data['q_level_meas'] @@ -341,104 +244,6 @@ def _contains_pv_instruction(experiments): return False -def get_diag_hamiltonian(parsed_ham, ham_vars, channels): - """ Get the diagonal elements of the hamiltonian and get the - dressed frequencies and eigenstates - - Parameters: - parsed_ham (list): A list holding ops and strings from the Hamiltonian - of a specific quantum system. - - ham_vars (dict): dictionary of variables - - channels (dict): drive channels (set to 0) - - Returns: - h_diag: diagonal elements of the hamiltonian - h_evals: eigenvalues of the hamiltonian with no time-dep terms - h_estates: eigenstates of the hamiltonian with no time-dep terms - - Raises: - Exception: Missing index on channel. - """ - # Get the diagonal elements of the hamiltonian with all the - # drive terms set to zero - for chan in channels: - exec('%s=0' % chan) - - # might be a better solution to replace the 'var' in the hamiltonian - # string with 'op_system.vars[var]' - for var in ham_vars: - exec('%s=%f' % (var, ham_vars[var])) - - H_full = np.zeros(np.shape(parsed_ham[0][0].full()), dtype=complex) - - for hpart in parsed_ham: - H_full += hpart[0].full() * eval(hpart[1]) - - h_diag = np.diag(H_full) - - evals, estates = la.eigh(H_full) - - eval_mapping = [] - for ii in range(len(evals)): - eval_mapping.append(np.argmax(np.abs(estates[:, ii]))) - - evals2 = evals.copy() - estates2 = estates.copy() - - for ii, val in enumerate(eval_mapping): - evals2[val] = evals[ii] - estates2[:, val] = estates[:, ii] - - return h_diag, evals2, estates2 - - -def get_hamiltonian_channels(parsed_ham): - """ Get all the qubit channels D_i and U_i in the string - representation of a system Hamiltonian. - - Parameters: - parsed_ham (list): A list holding ops and strings from the Hamiltonian - of a specific quantum system. - - Returns: - list: A list of all channels in Hamiltonian string. - - Raises: - Exception: Missing index on channel. - """ - out_channels = [] - for _, ham_str in parsed_ham: - chan_idx = [i for i, letter in enumerate(ham_str) if - letter in ['D', 'U']] - for ch in chan_idx: - if (ch + 1) == len(ham_str) or not ham_str[ch + 1].isdigit(): - raise Exception('Channel name must include' + - 'an integer labeling the qubit.') - for kk in chan_idx: - done = False - offset = 0 - while not done: - offset += 1 - if not ham_str[kk + offset].isdigit(): - done = True - # In case we hit the end of the string - elif (kk + offset + 1) == len(ham_str): - done = True - offset += 1 - temp_chan = ham_str[kk:kk + offset] - if temp_chan not in out_channels: - out_channels.append(temp_chan) - out_channels.sort(key=lambda x: (int(x[1:]), x[0])) - - out_dict = OrderedDict() - for idx, val in enumerate(out_channels): - out_dict[val] = idx - - return out_dict - - def build_pulse_arrays(qobj): """ Build pulses and pulse_idx arrays, and a pulse_dict used in simulations and mapping of experimental pulse @@ -661,100 +466,3 @@ def experiment_to_structs(experiment, ham_chans, pulse_inds, structs['can_sample'] = False return structs - - -def _first_excited_state(qubit_idx, dim_qub): - """ - Returns the vector corresponding to all qubits in the 0 state, except for - qubit_idx in the 1 state. - - Assumption: the keys in dim_qub consist exactly of the str version of the int - in range(len(dim_qub)). They don't need to be in order, but they - need to be of this format - - Parameters: - qubit_idx (int): the qubit to be in the 1 state - - dim_qub (dict): a dictionary with keys being qubit index as a string, and - value being the dimension of the qubit - - Returns: - vector: the state with qubit_idx in state 1, and the rest in state 0 - """ - vector = np.array([1.]) - - # iterate through qubits, tensoring on the state - for idx in range(len(dim_qub)): - new_vec = np.zeros(dim_qub[idx]) - if idx == qubit_idx: - new_vec[1] = 1 - else: - new_vec[0] = 1 - - vector = np.kron(new_vec, vector) - - return vector - - -def _eval_for_max_espace_overlap(u, evals, evecs, decimals=14): - """ Given an eigenvalue decomposition evals, evecs, as output from - get_diag_hamiltonian, returns the eigenvalue from evals corresponding - to the eigenspace that the vector vec has the maximum overlap with. - - Parameters: - u (numpy.array): the vector of interest - - evals (numpy.array): list of eigenvalues - - evecs (numpy.array): eigenvectors corresponding to evals - - decimals (int): rounding option, to try to handle numerical - error if two evals should be the same but are - slightly different - - Returns: - eval: eigenvalue corresponding to eigenspace for which vec has - maximal overlap - - Raises: - """ - - # get unique evals (with rounding for numerical error) - rounded_evals = evals.copy().round(decimals=decimals) - unique_evals = np.unique(rounded_evals) - - # compute overlaps to unique evals - overlaps = np.zeros(len(unique_evals)) - for idx, val in enumerate(unique_evals): - overlaps[idx] = _proj_norm(evecs[:, val == rounded_evals], u) - - # return eval with largest overlap - return unique_evals[np.argmax(overlaps)] - - -def _proj_norm(A, b): - """ - Given a matrix A and vector b, computes the norm of the projection of - b onto the column space of A using least squares. - - Note: A can also be specified as a 1d numpy.array, in which case it will - convert it into a matrix with one column - - Parameters: - A (numpy.array): 2d array, a matrix - - b (numpy.array): 1d array, a vector - - Returns: - norm: the norm of the projection - - Raises: - """ - - # if specified as a single vector, turn it into a column vector - if A.ndim == 1: - A = np.array([A]).T - - x = la.lstsq(A, b, rcond=None)[0] - - return la.norm(A@x) diff --git a/qiskit/providers/aer/openpulse/qobj/op_system.py b/qiskit/providers/aer/openpulse/qobj/op_system.py index f21b537810..6d49f82570 100644 --- a/qiskit/providers/aer/openpulse/qobj/op_system.py +++ b/qiskit/providers/aer/openpulse/qobj/op_system.py @@ -55,3 +55,5 @@ def __init__(self): self.h_diag = None # eigenvalues of the time-independent hamiltonian self.evals = None + # eigenstates of the time-independent hamiltonian + self.estates = None diff --git a/test/terra/backends/test_pulse_simulator.py b/test/terra/backends/test_pulse_simulator.py index 114cc47e16..2d0d86ba27 100644 --- a/test/terra/backends/test_pulse_simulator.py +++ b/test/terra/backends/test_pulse_simulator.py @@ -24,6 +24,7 @@ import qiskit.pulse as pulse from qiskit.compiler import assemble +from qiskit.quantum_info import state_fidelity from qiskit.test.mock.fake_openpulse_2q import FakeOpenPulse2Q from qiskit.pulse.commands import SamplePulse, FrameChange, PersistentValue @@ -263,7 +264,7 @@ def backend_options_1q(self, omega_0, omega_a, qub_dim=2): backend_options['qubit_list'] = [self.qubit_0] backend_options['dt'] = 1.0 # makes time = self.drive_samples backend_options['ode_options'] = {} # optionally set ode settings - backend_options['seed'] = 90841 + backend_options['seed'] = 9000 return backend_options def backend_options_2q(self, omega_0, omega_a, omega_i, qub_dim=2): @@ -379,7 +380,7 @@ def scale_test(scale): self.assertDictAlmostEqual(counts, exp_counts) # set scales and run tests - scales = [2.,1.3453, 0.1234, 10.**5,10**-5] + scales = [2., 1.3453, 0.1234, 10.**5, 10**-5] for scale in scales: scale_test(scale) @@ -632,11 +633,10 @@ def test_gaussian_drive(self): statevector = result.get_statevector() exp_statevector = self._analytic_gaussian_statevector( gauss_sigma=gauss_sigma, omega_a=omega_a) - # compare statevectors element-wise (comparision only accurate to 1 dec place) - for i, _ in enumerate(statevector): - self.assertAlmostEqual(statevector[i], - exp_statevector[i], - places=1) + + # Check fidelity of statevectors + self.assertGreaterEqual( + state_fidelity(statevector, exp_statevector), 0.99) # --------------------------------------------------------------------- # Test FrameChange and PersistentValue commands @@ -773,10 +773,10 @@ def _analytic_statevector_three_level(self, omega_a): arg1 = np.sqrt(3) * omega_a * time / 2 # cos arg for first component arg2 = arg1 # sin arg for first component arg3 = arg1 / 2 # sin arg for 3rd component - exp_statevector = [(2 + np.cos(arg1)) / 3, - -1j * np.sin(arg2) / np.sqrt(3), - -2 * np.sqrt(2) * np.sin(arg3)**2 / 3] - + exp_statevector = np.array([(2 + np.cos(arg1)) / 3, + -1j * np.sin(arg2) / np.sqrt(3), + -2 * np.sqrt(2) * np.sin(arg3)**2 / 3], + dtype=complex) return exp_statevector def test_three_level(self): @@ -813,11 +813,9 @@ def test_three_level(self): exp_statevector_pi = self._analytic_statevector_three_level(omega_a_pi) - # compare vectors element-wise - for i, _ in enumerate(statevector_pi): - self.assertAlmostEqual(statevector_pi[i], - exp_statevector_pi[i], - places=4) + # Check fidelity of statevectors + self.assertGreaterEqual( + state_fidelity(statevector_pi, exp_statevector_pi), 0.99) # Test 2*pi pulse omega_a_2pi = 2 * np.pi / self.drive_samples @@ -839,11 +837,9 @@ def test_three_level(self): exp_statevector_2pi = self._analytic_statevector_three_level( omega_a_2pi) - # compare vectors element-wise - for i, _ in enumerate(statevector_2pi): - self.assertAlmostEqual(statevector_2pi[i], - exp_statevector_2pi[i], - places=4) + # Check fidelity of vectors + self.assertGreaterEqual( + state_fidelity(statevector_2pi, exp_statevector_2pi), 0.99) # ---------------------------------------------------------------------------------------------- # Test qubit interaction (use 2 qubits for simplicity) diff --git a/test/terra/openpulse/__init__.py b/test/terra/openpulse/__init__.py new file mode 100644 index 0000000000..0e1a4c3082 --- /dev/null +++ b/test/terra/openpulse/__init__.py @@ -0,0 +1,32 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +''' +Terra tests +''' + +import os + + +def load_tests(loader, standard_tests, pattern): + """ + test suite for unittest discovery + """ + this_dir = os.path.dirname(__file__) + if pattern in ['test*.py', '*_test.py']: + package_tests = loader.discover(start_dir=this_dir, pattern=pattern) + standard_tests.addTests(package_tests) + elif pattern in ['profile*.py', '*_profile.py']: + loader.testMethodPrefix = 'profile' + package_tests = loader.discover(start_dir=this_dir, pattern='test*.py') + standard_tests.addTests(package_tests) + return standard_tests diff --git a/test/terra/openpulse/test_pulse_digest.py b/test/terra/openpulse/test_pulse_digest.py index 162a99c729..de188dc6b0 100644 --- a/test/terra/openpulse/test_pulse_digest.py +++ b/test/terra/openpulse/test_pulse_digest.py @@ -36,9 +36,8 @@ def setUp(self): class TestDigestHamiltonian(BaseTestDigest): r"""Tests for Hamiltonian options and processing.""" - def test_qubit_lo_from_hamiltonian(self): - """Test backend_options['qubit_lo_freq'] = 'from_hamiltonian'.""" - + def test_qubit_lo_default(self): + """Test backend_options['qubit_lo_freq'] defaults.""" # set up inputs to _get_pulse_digest # Note: for this test the only relevant parameter input to assemble() is self.backend, # but the others args still need to be valid to assemble correctly @@ -54,7 +53,9 @@ def test_qubit_lo_from_hamiltonian(self): backend_options = self.config.to_dict() backend_options['hamiltonian'] = _create_2q_ham() backend_options['qubit_list'] = [0, 1] - default_qubit_lo_freq = getattr(self.backend.defaults(), 'qubit_freq_est') + # HACK: fix for unit change in terra. This should really be fixed in test! + default_qubit_lo_freq = [val * 1e-9 for val in getattr( + self.backend.defaults(), 'qubit_freq_est')] default_u_lo_freq = self._compute_u_lo_freqs(default_qubit_lo_freq) # test output of default qubit_lo_freq @@ -64,6 +65,34 @@ def test_qubit_lo_from_hamiltonian(self): self.assertAlmostEqual(openpulse_system.freqs['U0'], default_u_lo_freq[0]) self.assertAlmostEqual(openpulse_system.freqs['U1'], default_u_lo_freq[1]) + # test defaults again, but with non-default hamiltonian + backend_options['hamiltonian'] = _create_2q_ham(v0=5.1, v1=4.9, j=0.02) + openpulse_system = digest_pulse_obj(qobj, backend_options=backend_options, noise_model=None) + self.assertAlmostEqual(openpulse_system.freqs['D0'], default_qubit_lo_freq[0]) + self.assertAlmostEqual(openpulse_system.freqs['D1'], default_qubit_lo_freq[1]) + self.assertAlmostEqual(openpulse_system.freqs['U0'], default_u_lo_freq[0]) + self.assertAlmostEqual(openpulse_system.freqs['U1'], default_u_lo_freq[1]) + + def test_qubit_lo_from_hamiltonian(self): + """Test backend_options['qubit_lo_freq'] = 'from_hamiltonian'.""" + + # set up inputs to _get_pulse_digest + # Note: for this test the only relevant parameter input to assemble() is self.backend, + # but the others args still need to be valid to assemble correctly + sched_list = [self._valid_2q_schedule()] + qobj = assemble(sched_list, + self.backend, + meas_level=1, + meas_return='avg', + memory_slots=2, + shots=1) + + # set backend_options + backend_options = self.config.to_dict() + backend_options['hamiltonian'] = _create_2q_ham() + backend_options['qubit_list'] = [0, 1] + backend_options['qubit_lo_freq'] = 'from_hamiltonian' + # test auto determination frequencies from_hamiltonian # (these values were computed by hand) backend_options['qubit_lo_freq'] = 'from_hamiltonian' @@ -81,14 +110,6 @@ def test_qubit_lo_from_hamiltonian(self): self.assertAlmostEqual(openpulse_system.freqs['U0'], 5.101980390271) self.assertAlmostEqual(openpulse_system.freqs['U1'], -0.203960780543) - # test defaults again, but with non-default hamiltonian - del backend_options['qubit_lo_freq'] - openpulse_system = digest_pulse_obj(qobj, backend_options=backend_options, noise_model=None) - self.assertAlmostEqual(openpulse_system.freqs['D0'], default_qubit_lo_freq[0]) - self.assertAlmostEqual(openpulse_system.freqs['D1'], default_qubit_lo_freq[1]) - self.assertAlmostEqual(openpulse_system.freqs['U0'], default_u_lo_freq[0]) - self.assertAlmostEqual(openpulse_system.freqs['U1'], default_u_lo_freq[1]) - def _compute_u_lo_freqs(self, qubit_lo_freq): """ Given qubit_lo_freq, return the computed u_channel_lo. From e7a3570a7890bcdc44c19bb65f60aefd972f8648 Mon Sep 17 00:00:00 2001 From: Daniel Puzzuoli Date: Fri, 20 Dec 2019 12:14:41 -0500 Subject: [PATCH 18/24] Adding SimSystemModel class as higher level class containing HamiltonianModel (#496) * added PulseSystemModel to extract information about backend relevant to simulation * Moved HamiltonianModel.calculate_frequencies to PulseSystemModel.calculate_channel_frequencies * Modifying constructors for HamiltonianModel to separate object specification from string parsing * added PulseDefaults object into the pulse_simulator, and changed the default memory_slots setting in digest to be equal to the number of qubits * changed digest default 'meas_level' to 2 --- example/pulse_sim.ipynb | 344 ++--- .../providers/aer/backends/pulse_simulator.py | 26 +- .../aer/openpulse/hamiltonian_model.py | 185 +-- .../aer/openpulse/pulse_system_model.py | 133 ++ qiskit/providers/aer/openpulse/qobj/digest.py | 212 ++- .../aer/openpulse/qutip_lite/operators.py | 2 + .../aer/openpulse/qutip_lite/states.py | 1 + qiskit/providers/aer/utils/__init__.py | 1 - qiskit/providers/aer/utils/pulse_sim_utils.py | 33 - test/terra/backends/test_pulse_simulator.py | 1158 +++++++---------- test/terra/openpulse/test_pulse_digest.py | 4 +- test/terra/openpulse/test_system_models.py | 123 ++ 12 files changed, 1102 insertions(+), 1120 deletions(-) create mode 100644 qiskit/providers/aer/openpulse/pulse_system_model.py delete mode 100644 qiskit/providers/aer/utils/pulse_sim_utils.py create mode 100644 test/terra/openpulse/test_system_models.py diff --git a/example/pulse_sim.ipynb b/example/pulse_sim.ipynb index 56fb235816..0e7f957add 100644 --- a/example/pulse_sim.ipynb +++ b/example/pulse_sim.ipynb @@ -20,12 +20,12 @@ "metadata": {}, "outputs": [], "source": [ - "#Import general libraries (needed for functions)\n", + "# Import general libraries (needed for functions)\n", "import numpy as np\n", "import matplotlib.pyplot as plt\n", "from scipy.optimize import curve_fit\n", "\n", - "#Import Qiskit classes classes\n", + "# Import Qiskit classes classes\n", "import qiskit\n", "#from qiskit.providers.aer.noise import NoiseModel\n", "#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error\n", @@ -41,30 +41,38 @@ "cell_type": "code", "execution_count": 2, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/dpuzzuoli/Documents/projects/qiskit-terra/qiskit/pulse/channels/pulse_channel_spec.py:87: DeprecationWarning: The PulseChannelSpec is deprecated. Use backend.configuration() instead. The supported methods require some migrations; check out the release notes for the complete details.\n", - " DeprecationWarning)\n" - ] - } - ], + "outputs": [], "source": [ "#Get a pulse configuration from the fake backend\n", - "backend_real = FakeOpenPulse2Q()\n", - "configuration = backend_real.configuration()\n", - "system = pulse.PulseChannelSpec.from_backend(backend_real)" + "backend_real = FakeOpenPulse2Q()" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dpuzzuoli/Documents/projects/qiskit-terra/qiskit/providers/models/pulsedefaults.py:166: UserWarning: `qubit_freq_est` and `meas_freq_est` now have units of Hertz(Hz) rather than gigahertz(GHz).\n", + " warnings.warn('`qubit_freq_est` and `meas_freq_est` now have units of '\n", + "/Users/dpuzzuoli/Documents/projects/qiskit-terra/qiskit/providers/models/backendconfiguration.py:363: UserWarning: `dt` and `dtm` now have units of seconds(s) rather than nanoseconds(ns).\n", + " warnings.warn('`dt` and `dtm` now have units of seconds(s) rather '\n" + ] + } + ], "source": [ - "#Get pulse simulator backend\n", + "# create a PulseSystemModel from the backend\n", + "# the PulseSystemModel stores model information for simulation of pulse schedules\n", + "from qiskit.providers.aer.openpulse.pulse_system_model import PulseSystemModel\n", + "system_model = PulseSystemModel.from_backend(backend_real)\n", + "\n", + "# set dt = 1 (this will need to be removed once backend has correct units)\n", + "system_model.dt = 1.\n", + "\n", + "# Get pulse simulator backend\n", "backend_sim = qiskit.Aer.get_backend('pulse_simulator')" ] }, @@ -147,8 +155,11 @@ " name='meas_pulse')\n", "acq_cmd=pulse.Acquire(duration=meas_samples)\n", "\n", + "acquire_channels = [pulse.AcquireChannel(0), pulse.AcquireChannel(1)]\n", + "memoryslots = [pulse.MemorySlot(0), pulse.MemorySlot(1)]\n", + "\n", "# create measurement schedule\n", - "measure_and_acquire = meas_pulse(system.qubits[qubit].measure) | acq_cmd(system.acquires, system.memoryslots)\n", + "measure_and_acquire = meas_pulse(pulse.MeasureChannel(0)) | acq_cmd(acquire_channels, memoryslots)\n", "\n", "# Create schedule\n", "schedules = []\n", @@ -161,7 +172,7 @@ " # add commands to schedule\n", " schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp)\n", " \n", - " schedule += rabi_pulse(system.qubits[qubit].drive)\n", + " schedule += rabi_pulse(pulse.DriveChannel(0))\n", " schedule += measure_and_acquire << schedule.duration\n", " \n", " schedules.append(schedule)" @@ -171,111 +182,22 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Design the Hamiltonian" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Let's build a transmon Hamiltonian with anharmonicity to test the Rabi oscillation and CR" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "hamiltonian = {}\n", - "hamiltonian['h_str'] = []\n", - "#Q0 terms\n", - "hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0')\n", - "hamiltonian['h_str'].append('np.pi*alpha0*O0*O0')\n", - "hamiltonian['h_str'].append('2*np.pi*r*X0||D0')\n", - "hamiltonian['h_str'].append('2*np.pi*r*X0||U1')\n", - "hamiltonian['h_str'].append('2*np.pi*r*X1||U0')\n", - "\n", - "#Q1 terms\n", - "hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1')\n", - "hamiltonian['h_str'].append('np.pi*alpha1*O1*O1')\n", - "hamiltonian['h_str'].append('2*np.pi*r*X1||D1')\n", + "### Assemble qobj, using qubit_lo_freq as computed from the Hamiltonian\n", "\n", - "#Exchange coupling betwene Q0 and Q1\n", - "hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)')\n", - "hamiltonian['vars'] = {'v0': 5.00, 'v1': 5.1, 'j': 0.01, \n", - " 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33}\n", - "\n", - "#set the qubit dimensions to 3\n", - "hamiltonian['qub'] = {'0': 3, '1': 3}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Setup backend_options for simulation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First copy the real-device configuration to our backend options, then override the Hamiltonian with our custom Hamiltonian, and add any additional solver options." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "backend_options = configuration.to_dict()\n", - "backend_options['hamiltonian'] = hamiltonian\n", - "backend_options['dt'] = 1.0\n", - "backend_options['ode_options'] = {}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Restrict the Qubits Used in the Simulation " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can use a qubit whitelist (`qubit_list`) to restrict the set of qubits used in the solution. The pulse simulator will appropriately alter the Hamiltonian. To start let's assume the list contains the first 2 qubits." + "Note: the one thing below not being used by the simulator is `meas_lo_freq`. This is normally drawn from the backend, but we could change it to be drawn from the `PulseSystemModel`." ] }, { "cell_type": "code", - "execution_count": 7, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ - "backend_options['qubit_list'] = [0, 1]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Assemble the qobj with the backend config file and the qubit_list\n", + "qubit_lo_freq = system_model.hamiltonian.get_qubit_lo_from_drift()\n", "\n", - "Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "rabi_qobj = assemble(schedules, \n", - " backend_real, \n", + "rabi_qobj = assemble(schedules,\n", + " backend=backend_sim,\n", + " qubit_lo_freq=qubit_lo_freq,\n", " meas_level=1, \n", " meas_return='avg', \n", " memory_slots=2,\n", @@ -286,77 +208,30 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "### Set qubit lo freq\n", - "\n", - "To simulate, the frequency of the local oscillator for each qubit needs to be specified. Here, we set the qubit lo frequencies to be determined automatically from the the Hamiltonian:" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "backend_options['qubit_lo_freq'] = 'from_hamiltonian'" + "Note: The above command can now be called without the arguments `meas_level`, `meas_return`, `memory_slots`, and `shots`, as they will be populated with defaults." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "When this option is used, the frequencies are determined from the gap in energy between the ground state and the dressed state corresponding to the first excited state of each qubit. The effect of this setting may be seen using the utility functions:" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([ 0. , 4.9990098 , 9.66953431, 5.1009902 , 10.10132826,\n", - " 14.76614835, 9.86913744, 14.87385165, 19.54 ])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "from qiskit.providers.aer.utils.pulse_sim_utils import get_dressed_energies, lo_from_hamiltonian\n", - "get_dressed_energies(rabi_qobj, backend_options)[0]/2/np.pi" + "### Setup backend_options for simulation" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "The dressed energy for qubit 0 is $4.9990098$, and for qubit 1 is $5.1009902$. The simulator will automatically pick these values out for the qubit lo frequencies due to the high overlap of the eigenstate with the first excited state of the corresponding qubit. The function `lo_from_hamiltonian` reports the oscillator frequences resulting from this choice:" + "These are additional solver options, which for now we don't need." ] }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 6, "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "OrderedDict([('D0', 4.999009804864072),\n", - " ('U0', 4.999009804864072),\n", - " ('D1', 5.100990195135927),\n", - " ('U1', 0.10198039027185501)])" - ] - }, - "execution_count": 11, - "metadata": {}, - "output_type": "execute_result" - } - ], + "outputs": [], "source": [ - "lo_from_hamiltonian(rabi_qobj, backend_options)" + "backend_options = {}" ] }, { @@ -368,7 +243,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -379,16 +254,16 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ - "sim_result = backend_sim.run(rabi_qobj, backend_options=backend_options).result()" + "sim_result = backend_sim.run(rabi_qobj, system_model).result()" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 9, "metadata": {}, "outputs": [ { @@ -397,7 +272,7 @@ "128.0" ] }, - "execution_count": 14, + "execution_count": 9, "metadata": {}, "output_type": "execute_result" } @@ -409,7 +284,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 10, "metadata": {}, "outputs": [ { @@ -419,7 +294,7 @@ " 0.+0.j])" ] }, - "execution_count": 15, + "execution_count": 10, "metadata": {}, "output_type": "execute_result" } @@ -438,7 +313,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -453,19 +328,19 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Pi Amplitude 0.308705\n" + "Pi Amplitude 0.312279\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -514,7 +389,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -531,13 +406,13 @@ " \n", "# excited\n", "excited_exp = pulse.Schedule(name='pi_exp')\n", - "excited_exp += pi_pulse(system.qubits[qubit].drive)\n", + "excited_exp += pi_pulse(pulse.DriveChannel(0))\n", "measure_time = excited_exp.duration\n", "excited_exp |= measure_and_acquire << measure_time\n", "\n", "# superposition\n", "sup_exp = pulse.Schedule(name='pi_2_exp')\n", - "sup_exp += pi_2_pulse(system.qubits[qubit].drive)\n", + "sup_exp += pi_2_pulse(pulse.DriveChannel(0))\n", "measure_time = sup_exp.duration\n", "sup_exp |= measure_and_acquire << measure_time\n", "\n", @@ -558,23 +433,26 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ - "readout_qobj = assemble(excited_exp_schedules, backend_real, \n", - " meas_level=1, meas_return='single', \n", - " memory_slots=2,\n", - " shots=shots)" + "readout_qobj = assemble(excited_exp_schedules, \n", + " qubit_lo_freq=qubit_lo_freq,\n", + " meas_lo_freq = [0.,0.], \n", + " meas_level=1, \n", + " meas_return='single', \n", + " memory_slots=2,\n", + " shots=shots)" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ - "sim_result = backend_sim.run(readout_qobj, backend_options=backend_options).result()" + "sim_result = backend_sim.run(readout_qobj, system_model, backend_options).result()" ] }, { @@ -586,7 +464,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 16, "metadata": {}, "outputs": [], "source": [ @@ -604,7 +482,7 @@ }, { "cell_type": "code", - "execution_count": 22, + "execution_count": 17, "metadata": {}, "outputs": [], "source": [ @@ -616,7 +494,7 @@ }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 18, "metadata": {}, "outputs": [ { @@ -625,13 +503,13 @@ "Text(0, 0.5, 'Q (a.u.)')" ] }, - "execution_count": 23, + "execution_count": 18, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEgCAYAAABM0P/cAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOy9e3zU1Z3//3xPbmQ+gwIhgSAk3C9eUEgkZNBAV6i1toKPeiWhIGiGomhvtv62Xct2d/u1ddutIEhSuVnQ7mK9tLu21kslkAlIAlZaFIVwi9yDQmZCrnN+f5zPJJPJTDITEhLg83o88pjM55zP+ZzzmXPO+7zvopTCggULFixYiAa27u6ABQsWLFi4+GARDwsWLFiwEDUs4mHBggULFqKGRTwsWLBgwULUsIiHBQsWLFiIGhbxsGDBggULUcMiHpcwRGSkiCgReT7C+tPN+j/u6r5ZaB8iskVEGrq7HxZ6JqJd352Ny5J4mC88pIOL+YPsM+v87EL37VKAiMSa7+/t7u5LZ6KnE1eT2CgRuakD99pF5LsisllEKkWkTkSOiMirIjKzK/p7IdAeARaRChHZeyH71NMgIg+a8yYvmvtiu6pDFyNEJAN4A+gPLFZKPdvNXbrQcAPjgJPd3RELFw4ich3wRyAdOABsBE6b328HZonI60CuUsrbXf200LNgEQ8TIjIdeBWIB+5TSm3s5i5dcCilqoGPu7sfFi4cRGQQ8BYwAPh34F+VUg0B5UnAS8BM4AXgG93RTws9EEqpy+4PUHroTd/vA2qBM8CX2rjvavQCqgDqgGPABmBUiLrrzeekAY8Bu4BzwNtm+XSz/MfABOBP5vO9wHtAVpg+xAKPANuAs0A1sANYBEhQ3ZHmM56P8L009Sno+hagAYgz+7vXfF+HgP8HxAXUfdD/fkP8BbebDfzefI91wGFgJZAapn9Z6I2uynxXbwGT0JueAm4Kek8KeBsYBKwGjgCNQJ5ZZwzwc6AUzW3Vok/eBcBVYX7PUH83BdXNNX/DL4AaYDfwz0B8mHHlmr9hDXACWAcM9L/3KOb1llD9aeeeteY9v22jjgPYb9b7WoTtXgH8BPi7+XtVmfPmJWBCiPqTgf8xf6M68/NN4K6gevOBV4By9Ho6Y457dpi5H+rvbZrneqi/54Pa6rR13847qzDfUR9ghfkOaoB/AA8TxfpGz/nngIPmvD6BXmsTgur550yov8Ft9fey5zxE5DHgv4DjwG1KqQ/C1LsdeBmIQbP4+4Ah6JPY7SIyVSn1txC3LgduQovD/g89+QIxCfgR+kf8DVpU8A3gXRG5QSn1aUAf4s02pqM5hA3oifFP5nMmAfOiewNR4XfoDf/P6M3gduAJtJjvIbPODuDfgH9BbzgvBNxf5P9HRB5CE4pzwB/QC2e02c7XRCRLKfVZQP1p5nNj0L/DfuB6s82/ttHn/sBW9Cbze/SiOGGW3Q3km/cXA/XAdQF9yFRKHTXrvgL4gDlm/aaxoImov5/rgG+a1142n+sE/gP4JxG5VSnVGFD/ceAXwOfojfwMcJvZn+o2xnXeEBEDmG1+/Wm4ekopj4j8F/AMsBD433baFeAvaGLvRs/rRmAw8CVgE7AzoP5C9PytR8+FvUAKcKP5vJcDmi8APjDbOIb+fb8KbBCRUUqpfzXrnQb+FU1sBgeNr9z8+1fgu+iD0dKA8h0BfeuqdR8OCcC7aIL9ovn9buBZ9Pp4rL0GRGQEej8ZiCaUL6KJ2d1mn+9USv3JrL4a/a6+jpa8fBjQ1Nk2HxTpCeVS+qOZsv4/8/MTYFgb9ZPQp8iTwNigsvFobmF7mBPIYSA9RJuBJ5+8oLKHzetLg677T9i/BmICrsfQfIK8PZKTSZhxtsV5KOB9oG/AdQd6ETYAyQHXm079YZ4zDr2Y9hDEZQBfRm80G4PGV262OSOo/iMB7zEU56GANYHvK6DOYCAhxPXb0IRiWSTvJ6Dcz3X9D9ArqOzfzLKHA66NMN/DKSAtaLyvmfW7jPNAb+QKOBhB3XFm3bMR1J1g1t0YoiwmaA6NN+dPJTAuRP0hQd9HhKiTgOb06oCBId5J2HeIedoPU9bp676d91Zh3ruJAC4VTSD9nJ8z4HrI9Q28Y17/YdD1m821dRKwh5i3eVH1N5rKl8pfwKaizAk3vJ363zPrusKULzPLR4eYRA+Huce/Eb0XoizB/JG3BlyLQZ9OKwi9ESaZ7b3Y3uRqY5ztEY9pIe75D7PsKwHX2iMe/vd1a5jyP6JPoYb5fZpZ/y8h6sagT6rhiMc5IKkDc2Q38Ekk7yegfBeaE7wiRFms+fu5A679xGzvX0LUH4UmYF1JPGab9bdEUNcRsGZajS+orp94vBBBu8+ZdRdH+xsFtXOP2U6w+Op8iEenr/t2xuAnHtkhyvwb/G8CrrVa38BQ81o5EBuinZeC3xMdJB6Xu9jqTeBW4EUR+YpS6osw9bLNzwkisiRE+UjzcxyaiwnE++30oTT4glKqVkROAn0DLo9Dy0KPA/+iJQOtUGPW6yq06iv6hAUt+9oe/O/zSyKSHaK8P3qzHQn8Db0Zgd4IWkAp1SgiJehTfCiUK6UqQxWY4pU5wFz0SbIvmhj5EbHYSER6A9eif5/vRvj7TDQ/NwVXVEp9KiJH0KKHDkNE5qNFFoF4VylVBPg7qSJpKuD/XrQt0thl/s0RkWFoUdQWoFQpVR9Ud7L5+ScigIgMBX4A3IIWHyUGVbkqknYiRFeu+3CoQ4tZg/Gevy/t3O8vL1IBhg8BeBet452AFmd1GJc78ZiJFjHcgdYxfFkpdSpEvSTz09VOe44Q1461c084gtVAy43M34cx6BNrNH3oDDQqpTwhrvsnaEyIsnDwj+WH7dTzj+VK8/N4mHrhrkPb738pWux1BK1P+Qy9wYOWlQ9qp3+B6Gd+DqDt3ydwQbc3rmOcJ/FAj2NKiD4UAX59TjBxCYXBAfd+3lZFpVSDqaP6CVo38Auz6KyIrAX+WTWb/PYxPz+jHYjISPSmfKXZ/zfROqJGYDj6IJAQwVgiRVeu+3A4oUx2IEx7V4YoC4S//GiYcv/1PmHKI8ZlTTzME/430Irne4D3RGS6Uir4hz9jfl6jlNod7WPOt59BfdiolLqnk9rsLvjHYihtHtwe/KfcAWHKw12HMO9fRFLRuqW/ocU8nqDyORH0KxD+MW1XSk2K8p4BaP1PMM6XcKCUasthcBtaPJhmKps/baPudPNzVwjuIdRzT6OVu4+JyCi06NEFPIq2xHrArOo/PF2FFj+2he+jucM5Sqn1gQXm7xXtb9YeumPdp4iIhCAg/rlwJviGIPjLw82d1AjbaReXpYd5IEzWbjbaPPIaYJOIDA6q5mcjb76QfQvCP9AWTtki0tOJvs/8DMeNRPs+/ZY5rTZCEYmhWbwQDUagRTFvhiAc6WjZcTD8VlKtxmWKPPcA14lIpKc6v1XP1OACc8ONhvOJGubp3y+6COs1b1plfcf8GrWoQyn1qVLqN+hxngNmBRT758JtETTlFxP9PkRZq3doohEtoQwpRzTLO2uedgbiaRblBWKa+bkzRFkg/OU3m2sjGF8yP3cEXAs7r9vCZU88QMvN0SehArQ5XJEpW/VjFfr0+1MRyQy+X0RiTDa9K/tYjzbXGwz8WkR6hejHIBHpSp1HRFBK+dCijXDikGVo8cczpiiiBUQkPijERhHa/2KGiMwIqv4twus72sIB87PFIjN1F4WEXht+3Um4cf0KrQ9YJSKtxAsi0k9EAmXW69Hv4TERSQuoFwM8TUs9Q1fhn9Fis2+KyJLgDUdE+qE362FoI4Ln2mtQREaEmYd90b5CgdzmCvTmtURExoZoK1CHccD8nBZU56uEN1GvRP+WwQfCwPIUEQkl7uqudf+UaZbvf05/tDk/aMvBsFBKHUCbko8AFgeWicgU4F70mF8PKGpvXodETz/BXjCYbOJCETkHfBvYLCL/ZJ6aTorI3ehF9L4Zs2k3mjUdgpYp96br9A1+/ASt2H0YmCki76Ll9QPQ1jlOtB7hoy7uRyR4B7jLDGuxE71JvqeU2qKU+oeIPIi2/98tIn8CPkXLq9PQJ70jaAW0Xyn+INpm/g0ReRltTXI9WpzyZ+ArNHM87UIpVWG2cxeww/xNr0SbCnvQCt+rg27bjZYZ54pII9pYQAHrlFKHlVKFZoibfGCqiPwF7e/RDy2Tv9kc8yNmH/aJyI/QjoofiMj/0OznYaAd7Lr0MKCUOiIiX0ZbuP0EreT+Cy3Dk/RB6yRuV5GFJ5kAbBSRUvQYjqL9Nmai95yfBzx/l4gsRh+MPjDnyz60vuFGsx9+kdlytA/Nq+ZvdxQ9R25F6y7vDdGXd4A7gddE5M9ozme/UmpDQPkE4M8ishmtsN6plPq/blr3FWabfxeRP6DXxF1oMdRSpZQ7gjZcaAOF/xKR24Aymv08GoB5Qb+jG63r+56IJNPsB/WMUqoq7FOiNSe7FP6gpYd5iHK/+elRtLzTf304+qS013zZZ9DOeuuAO4La8JvshfTSpH2zz5AmhOhT1Fy01cRp9GT/DNgM/H+Bz6OTPczD3BPSzA892V8yJ2JjmHavN9+d3wv2NHqzeY7QZsHZaKcnD/pE6PcwX2m2f21A3TbNhc06BtrXx/97HkJvYn3DjRnt+PZX8/l+09VgD/M70I5hJ9E6hWNo/cK/AWNCtJmLJrB+D/MX0LLpLvcwD3oX30c7J36OJsT+8RXQjnluUFtDzPfqNsdeiya0/0d48+wpaCe1EzR7mP8JuDOo3k3m+//c/A02m+873NyNBZ5C+0nUB88J9MZfgF5DDYT2m+i0dd/Oewv0MH/OfAe1aIL1CNF5mA8218Uhmn2JXgEywzz7q2gxnSfgd29zDGLeaMHCRQsR2YY2e+2tlKppr76FyCAiC4Dn0Zv17Uqpc93cpUsaIlIB1CilWolyeyIsnYeFiwKiQ4aH0iM8iOY+/mQRjs6FUmoV+tT+JeCVQDm8BQuWzsPCxYLhaLnzW2iZeBya23CiRRjf78a+Xcr4Z7ToqS9aB1Hcvd2x0FNgia0sXBQQHRr8F2iTzAFoReIxtN7j35VS+7uxexYsnDcuNrGVRTwsWLBgwULUuCzEVv3791dDhw7t7m5YsGDBwkWFsrKyU0qp5FBllwXxGDp0KKWloWL6WbBgwYKFcBCRg+HKLGsrCxYsWLAQNSziYcGCBQsWooZFPCxYsGDBQtS4LHQeFixYuPRRX19PRUUFNTWWr2i06NWrF4MHDyYuLi7ieyziYcGChUsCFRUV9O7dm6FDhxI+AruFYCilqKyspKKigmHDhkV8nyW2smDBwiWBmpoakpKSLMIRJUSEpKSkqDk2i3hYsGDhkoFFODqGjry3Hkc8ROQrIrJHRPaKyBMhyheKyC4R+UBEtohIcM4FCxYsWLi4oRQ0NurPHooeRTzMLGbL0clwrgbuD0EcXlRKXaeUugEd6+hXF7ibFixYsNB1UApOnoRDh/RnDyUgPYp4oENr71VKlSul6oDfobOPNUEpdTbgq0HHE81bsGDBQqdi2rRpHDhwgNOnTzNjxgxGjRrFjBkz+PzzzyNvxOcDrxfi4/WnL+IEmRcUPY14XIXOOOZHhXmtBUTkYRHZh+Y8Hg3VkIjki0ipiJSePHmySzprwYIFC6Hw1FNPccstt/Dpp59yyy238NRTTwFw5swZfO0RA5sNDAPq6vSnradt0xo9rVehtDatOAul1HKl1Ah0vu4fh2pIKVWolMpUSmUmJ4eM62XBgoXLHEqBx9P5kqHXX3+duXPnAjB37lxee+01ALZs2cKYMWNYsmQJhw4dCn2zCCQnQ1qa/uyhRgA9jXhUoPMf+zEYncc3HH4HzOrSHlmwYOGShFJQUACLFunPziQgx48fJzU1FYDU1FROnDgBwO23305JSQl9+vRh5syZ3HrrrWzcuJG6urqWDYhATEyPJRzQ84jHdmCUiAwzU17eB/whsIKIjAr4ejvw6QXsnwULFi4ReL3gdkN6uv70ei/Mc/v378+3v/1tdu7cyZIlS3jyySfJzMy8MA/vRPQoD3OlVIOIPAK8CcQAq5VS/xCRnwKlSqk/AI+IyHSgHp1+dG739diCBQsXKwwDnE5NOJxO/b2zMGDAAI4ePUpqaipHjx4lJSWlRfnu3btZs2YNr776KlOnTiU/P7/zHn6B0KOIB4BS6g3gjaBrTwb8/9gF79QlBKX0CcswejRHbMFCl0MEXC7Iy+v89XDHHXewbt06nnjiCdatW8fMmdpodMeOHSxatAibzcaCBQv44IMPcDgcnffgC4geRzwsdB38Ml7/ScvlsgiIhcsbItAVe/cTTzzBPffcw6pVq0hLS2Pjxo0AJCYmsmbNGsaNG9d+I0ppM12brUcuVIt4XAKIlJsIlvHm5XXNwrFg4XJHUlIS77zzTqvrERENaHYU9C/sHmh11dMU5haiRDQWI34Z78GDnS/jtWDBgoZSikZfI+p8zLcuAkdBi3h0M87XzjwaixG/jHfFCktkZcFCV2Du3Lk0xDdw6MwhTlaf7DgBuQgcBXtejy4jdIadebTchF/G212Eo6ucsixY6An45txvEmuPJT4mHm+dF5/qIMdwETgKWsSjG9EZduYXEzfRlU5ZFiz0BNjEhhFvUNdYhxFvYJPz2GJ7uKOgRTy6EZ2lg+hubiJSdJdTlgULFwoiQrI9mbQr00i2J1/S+UUsa6tuRKfZmV8kzhtd6ZRlwUJPgYgQIzHd3Y0uh8V5dAGikeu3xTVE1E6wLKiq6sLJg6JUYFxMIjYLFjoCf0j2jRs3cs0112Cz2SgtLe3ubnUJLOLRyegsuX7E7fhlQWlpsHYtzJ9/YRQKHRzoxSJis2DhfHDttdfyyiuvkJOT0+K61+ttHQTxIoVFPDoZnSXXj7gdvyxo3z44fhw++kgTEY+no0NogbDMhaXAsHAJQCmFp85zfj4ZITBu3DjGjBnT6vonn3zCmDFj+N73vsdHH33Uqc+80LCIRyejs5TgEbfjlwX96leQktKp9uBtMheWx6GFixxKKQrKClj0f4soKCvodAISChMmTODDDz9k3LhxPPjgg9x0002sWbMG70V4+LKIRyejs+T6UbUjAgMHwrx5cM01MHduyLgjyqfwHPOgfCoidUWbzEWoDlpOHBYuInjrvbgPu0m/Mh33YTfe+s7ZwNvzMO/duzcPPvggxcXFFBYW8pvf/KYp98fFBMvaqgvQWcHWompHBBYuhDlzQlpdKZ+iKK8A2zY3jZOcfJzjwl0ibQZIbNc6KrCDVtRFCxcZjDgD5xAn7sNunEOcGHFRcM9tBC2sPFcJZ8CID9/ewYMHWbt2LS+99BLXX389S5Ys6eAoug8W8egB6DRL23DURim8+49j21pMw6ChxGx1s60hj/SxjpYBEoM6EpUpsRV10cIFgFIKb70XI844bx8KEcGV4SJvfF507bURtFChOFd/rsnDXAVl0T5w4AAPPvggp06d4oEHHqC4uJikpKTzGkd3wSIe3YwuP7CbDzCK3QxIauT4kQM0Tp5CVo6BuySAowjTkYi5H8uJw0IXw6+j8HMKrgxXpxAQR3yUh5zgoIVJSdoTHBCExLhE/vj6H/npEz+l8lQlt99+OzfccANvvvkmMTEx/OxnP2PSpEnn1e+eAIt4dDHa4yq6/MBuPkCGpjOKgwxa8guMYQOYKkJeoITLc54d6crMOhYs0FpHkTc+L/qNPxzCiKGUUviUrynMSIOvgVhbLGIYzQs7yEglKTGJh3IfwpXXmrgNGTKEIUOGdE6fuxkW8ehCRMJVdNqBPRyVCniATHHiGD6gqbwFbeiMjnRVZh0LFjhPHUVbCCOGUkpxsvok3jovRryBp9ajRWbxBsOShyFJSSF1HiJCjO3S9zCXC2Ge1t3IzMxU3eHl6fFoM9f0dG3RumJFWJXE+ek82qNSkT5AKZTHixcDwyEIF0fYEwsXJzqiv2jrno8++ihksqVA7iHkcxob4dAhLYaqq9MOtzExNPoaOXTmEPEx8dQ01OCt9xIfE099Yz1j+48lLiauVVNr165l1qxZ9OnTJ7KX0IMQ6v2JSJlSKjNUfctUtwsRqSvEeXtdt+ewF+EDFELBBgeLHhYKViqUFQLXQhehoz4Wfh1FNMTmZPXJtvNrhMmdERght3dCbxxxDuob6zHiDWJtoYU28+bNuygJR0dgEY8uxPn6fETiNqEUeJSBioBKtddeIA0qK/LSUNR5HuSWC8jljWBP7oh8LDph0viUD09tFQkSh7fOEzK/hgIa+yehgnJnBEfIHdZ3GGP7j2VYn2GXdLTcSNHjiIeIfEVE9ojIXhF5IkT5d0Vkt4h8KCLviEh6d/QzUnSUq4gkdFRTnYeFAuVCLQ9PpSJpL5BTysgxiM3pmAd58Jq38nhc3gjFZfj1FwfPHAytv+jopFFKi6GUQilF5blKEr/wYj96iv5eWuXXaMGZ1FQS/BS//kJEEBHiYuIQaHrG5YweRTxEJAZYDtwGXA3cLyJXB1XbCWQqpcYDLwO/uLC9vDCIJHRUizolglfCU6lI2mvBKS0UJEK2KZBYhFrzVhisyxuhuAy/j8WK21eENrnt6KQ5eVLrL06exKd8VNd4MOoUtTGK2OqaVrnAfcqHt84beeY/v3LdfMblTEB6FPEAJgF7lVLlSqk64HfAzMAKSqm/KqWqza9bgcEXuI8XBJHoS6IJL9Uh/UsEbFMwsfB4moP8btqkv1thsC5vhOMy2tRfRDlplFL4fI2oAP8Lm4LEBIOqOEWiz4Y3QfBJc/iQRl9j9Jn/gn08fB1MM3spQJnsXU/4A+4Cng/4Pgd4to36zwI/bq/djIwMdTHC51Oqqkp/drROYHkk7UXbn6oqpebMUerHP9afZ88qtWKFUllZ+u+55zrn2RYubvh8PlVVW6V80UyACCevz+dTz21/ThWVFqmzh/cpX3m5UsePK+XzKZ/Pp45VHVP7T+1Vxz3Hlc/nU8c9x9XuE7vV7hO7m641NDZE1jefT6ljx5QKeEYgpk6dqvbv368qKyvV9OnT1ciRI9X06dPV6dOnIx93O/jJT36i1qxZo5RS6qOPPlKTJ09W8fHx6umnnz6vdnfv3t3qGlCqwuyrPY3zCHXEDckXikgekAk8HaY8X0RKRaT05MmTndjFC4dI9CXtJZMK5Aqg41Zd4UTQwQdEh0P7CQ4fDtOnN0scrDwelzeitZIyb2q2bW9D/+EXi8XaYjllgG/I4CbFt4iQYqQwpO9Qku3JWoFuKs61Ml3/79drtIlAfxC7vYVyPRhPPfUUt9xyC59++im33HILTz31FABnzpzBFyG3snbt2nZjXvXr14+lS5fy/e9/v1XZ559/HtFzOoqeRjwqgED3y8HAkeBKIjId+BFwh1KqNlRDSqlCpVSmUiozOTm5Szrb0+HxQFGRFiFFIzYOZeQSri0RcOUrVvzCgytfNa33nBwtFrbEVBbOG4EJz/yy0AD4xWINvgaMeAe2mNgWm3qg0tsmNhzxjiafDyPOjs1bHVJ3oVRQdFy/yCohoV2R1euvv87cuXMBmDt3Lq+99hoAW7ZsYcyYMSxZsoRDhw6d75shJSWFG2+8kbi41j4nmZmZzJ49m3fffTdiU+ho0NOIx3ZglIgME5F44D7gD4EVRGQCUIAmHCe6oY89FwG7vlKwfj2Ul8Pbb0e+iYfiMHw+eP55nW+qVVtKIYUFOH6wCCnUN1jpZi10KgwDsrP15Nu/HzZsaLHZ+5Xv/RL7kdwrKaT4IrBusj2Zfon9QCl8BSupcS3QPk0BbapQ/iE2G8owUGfPoGprobIyrML8+PHjTWHWU1NTOXFCb1W33347JSUl9OnTh5kzZ3LrrbeycePGLsku+MknnzB79myeffZZrr76an72s59x5Eirs3iH0aOIh1KqAXgEeBP4CPgfpdQ/ROSnInKHWe1pwAFsFJEPROQPYZq7vBC063s9ipISLToaNgxycyPbxIONXDweWLYMnn0W+vWDoUOD2gpjFWOJqSx0GkRCy0IDqwA2jxdpxwpKKUWDrwFvnRfxVpPwfhlnB/ShpuhdVABHE8oKSwGnEhVeaaA6MUYr5zugMO/fvz/f/va32blzJ0uWLOHJJ58kM1M7cVdWVnLDDTdwww038OSTT7Jy5cqm77t27YrqOTExMXzta1/jlVdeoaioiPLyctLS0nj//fej7nMo9LjYVkqpN4A3gq49GfD/9AveqYsBQZu4kZuH06lDrk+dGnnIqeAQVwBlZTB6NHz8MSxerK8pZRIGK5quhU6AUu2EKvHLQs15pux2vHWe5vpeL9TWhox0G/gMf6wqAGW3U5VxHb3LdvHFpAxS7In47/BbYfnjWtnEpnUkDV7i7InEnKtBXXkFEiZz54ABAzh69CipqakcPXqUlJSUFuW7d+9m9erVvPbaa+Tk5OByuQBISkrigw8+ALTO48CBA+eV6+PMmTP893//N2vWrCEuLo5Vq1Yxfvz4DrcXiB5HPCxED6XAqwwMpxMxF5c4jBZBbqHZbLY9BXzwfU6nTovevz9s3w4ffBAYQqv5BmU38HrFCoVlISooFUGo9RbzzE7BjsKW9Q1D6yKCQowEIpCbqGusY3i/EZQ/kEv1PdVgGKQE6UmS7ckkJSY16Uds2DDiHXze20N/sSPV1aiTJ/H1T2oVN+uOO+5g3bp1PPHEE6xbt46ZM7XHwY4dO1i0aBE2m4278+7mtb++Rkq/FJLtna+XzcvLo6SkhLvvvpsXXniBUaNGdWr7FvG4yOGXVrndgjPbhWt5HmLYwetFDAOHQ1AKVq7UCu+cHJ1wMBILLj9yc7WecvBgePlluPvuoKjtIijDEVFeEr/ToEVgLPgRcah1c2J66zwt61+Xi6PenLRpaSEj3UJrbiIhNoH+RjLemCqMXr1b+XiICDES0+J7sj2ZpIS+2L6ogIR4as9UcizGg72Xo4kAKKV4/AePc/9997Nq1SrS0tLYuHEjAImJiaxZs4bRY0Y3BV301nlJSkxq8axIcezYMTIzMzl79iw2m41f//rX7N69myuuuIJ77rmHtWvXEhvbNdu8RTwuZiiF97gXd7FB+q71NwcAACAASURBVFDBXSLk5Rk4Clvu4h6PsG4dVFdrfWNeHvTuHflj/BKDtWv196IinS49UEIVSV6SZkJnZaq9HBFONBVtqPUW9QdnY6zZoCfVI4+EJRwQgpsAkr3Q3yNII4i9/TGICDExsWAY+DwePPEQF5fQRADATEPbB176w0tN5sH+8fuj1iqlWonFgjFv3ry2O6MUA5OTqTh8OOSY77jjjhA3dR4s4nGxwtyJDbebBY1OVh1w4ZwiGITYxXE03RKuqba4Ab++cvNmra8sL2+tgI9E9WFlqr180ZZoKtJ0sIHEp6l+rUKWPawnVW2tVmAH6DqUahmO3S9+8ikfNgVimt4qj0frSWy20OHb/WaHfuKUnIwkJeGrqaQugAAoFNV11QySgXjNQJCnz50GIMmeRLI9uakfwWKxKF9o2FS4FwoW8bhY4c8QmJ5OzkE3Gb/IwxjgQGi9izvQnIJfbBW4YUfKDQTqK0Mp4CNJJGjp1i9ftCeaEsBRB7R2VwBCEx9HvAMV66MmK4OEbWVa5xGg6whUkBvxRpNY6YT3BN56L454B8mGQe2ZSjzx4Kup1H0NqC8iYTdqiYlpQQAAvnH/N0jBhv3oKRy9e3PS7qFRNSIInlpPC/FUsFgsUkybNo0+vXuHTYV7oWARj27Eecn/AzMEOp04Bhimf37rXVzQl3JzWzcTKTcQCXFo0pUopdPaBlWMpA0LlybaFE21cYLxcxtKqVbEx4gztOI8tZScBzOY0rs3iuYwFcHmtkmJSZyqPsUJ7wl6xfbCU+fhin6DOBbjIS4ugdo6DyhIiE1oqYdoK2d5AAFo9DVyx11fI6XyHLUxCkedUJmoTYNtYsOR4Gg/dlYEmDZtWmuCFsbqK1J0xInQIh7dhPOW/7e1EwdrvE1s2ND6edFwA2GajWpgEbVh4ZJDm6KpMCeYQG4je3A2zsFO3BXNxMdT56HoYBHD+wynqHIH0676GpWVlSQlJTV5k/vTxzoS9KSrrq+mV2wvzjWcwx5n50jVEbBBXWNdEyfkr9+00fuTRbWzUdvEhr2Xg+qEWs1FXWmAzUv/xP7U+epISkzqvDwgpuiMMKlwo4FSisrKSnr16hXVfRbx6Ax0gIUId+KPqqkoduJwzztfbqBVfy3FhoUw8Me3aoUwJ5hAUVdJRQnLv7qcvOvzmriW9R+up/zzcvad3sf9193PkMFDOHLkCIGx7Kpqq6htrCUhJoFT8afw1HmobaxFKcWJxhPExcRhExt9e/XlnJxrKk+ISaAyobJlP30+qKnRnuX+72FMgk8q4FSlfr6vjoSYBGoTQkZS6hHo1asXgwdHF6DcIh7niw6yEKHWS0eaUgq8HoWBF3GE3/0Dn5ed3Zx7QyQyGhSKqIXsr6XYsBAtwpxgjDgD5+Bsyj4twjkqp4nw+MVYJRUl3DL0Fv5S/he2VWyjV2yvFop4T20V3/l9PgMHjODg2UOsuH0F9lg7+7/Yz5L3llB5rpI9p/awOGsxj018DG+9l0X/t4j0K9M5eOYgK25f0YrYKaW0c+KaDU0+VSEXqrk4lNtNbVYGCd9aHNahMBq060x5AdGjwpNclOhg0ppQ8Z+ibUopKFip2DijgE9mLGoVnyfU85Yv1/8//HDkCdrCRdQN2V8rsJWFjiBEPBsBXGXCijcEV5lWXPszEq7/cD3OwU7KvygnxhbDiL4jWqSzVT4fMb9Zxfc37Gf4xrdxXpWNz+ejsKyQJe8toVE1kpSYxKNZj/LopEfNIIltZzf0i9G+8/t8PvnjWlRaGvVbilqENWlCgEFLr21lSHV16zpRQqmO5X3vKljE43xxHpmOAteLnxOIpimvV+cav6HazUfedJ1zvA2K4+cyioshNVV/RkLrwhG1sEMPsRGEitRrwUIrBE4Urxdxu4kbNgJxu/F+caKFGCt3fC6FXy9k7vVzKf+iHOdgveErpVi1ZSmlLy+jakBfcquGEXOuBtf/ulj7t7WkX5lOjMTw9Jef5tGsR7GZHEF72Q299V6KDxXTr/8QigcrPt7xJusd5RR8vL71Rt7GvqBUy3zukSKivO8XEJbY6nzRCSZEgeKf7GzNHbQXVNBPbCbebPDBfieTG93E3Bye4vjFTomJOv3yyy9DRob+3qKCfwwB3w1DQkqiIh16pzoHWi7qly6CJ0p+fgsRqNEnpYXFVqBISSmFMlP/eOu9FJ0qI/mGMfT7YA/n7nSxuXIHI/qOYP8X+yn/opyc9BwGGANaEYi2TIbtsXYaVSMvf/R7Jv7TBNwNsaQOHMnBihLyrp/TUsQVZnEopVhZupKig0XkpOewMHNhxOKnYIs1e6wdT2B8rwsM6W7W50IgMzNTlZaWdnc3wsLj0SKh9HR9UFmxom0dRDCxqTmn+Mf7XjKnGjr3eLD41adY9YyHbdvgmiwHZTuE48dh7154dLHisQUe5MUNLRdtYWGL3V4hHd6zox1fRAO3XNR7DDpNDh9qohgGyuPBGw9GgM7D/yxPnaeVnsKIM7SV1qFibk6ayL2T5vPi31/CXaGttvw+JgKtD0xtzC//s1IdqRypOkLmoEzKjpaFj8cVAlW1Vcz47Qyq66uxx9l5a85b9E6IPNyD/13bY+0UBsf36oK1ICJlSqnMUGWW2KoHIFrJV6AYaXOR4m9uL6kjDdwl0loMpRS1S1cy9T9m8OOiGfR+sYDRoxR798LYMYorfldAw4J8HXvEn+npxIlWciq/Wa/Xa4qeopBDdVoO8w7qlyx0HTpVDh9ioiigYM8GFr3xMAVlOh2mEWc0Kc1D6Sn84qflt6+g0Z7II39ejELx7G3PtiQcwYq8duaXEWeQPTibQ2cO4RziZPGkxWFFXJG8t47Ab7FW3VDd7SIsS2zVA9CW+CeUlKbJoKlYsaChgKsOuympcHLVXBeGETSJvV7itxYR31BN9RnFVTVFFP89j4kTHSQ2ermx3k3MqBFweL+OO5KTAykprSymfD5YulSHZ5+S7cNVtwzZUdYmBxDY90jFW21yN5YlV49DxEENI0HAQlB2e0jnwNzrctmwa0OLE3cr/xGlEK8XiQN3RfO9dY11zZzCmFxtLRVoUh7B/BJ0aBH/Z7RjdcQ7mHf9PIoOFZGTltPhdxVtPLCugCW26sFoi4v2+eC5pz2ML1iEfWw61115kLjCFUjv1tEIa55ZyeF/X0dsLPymfh71D7jYVCQcPaK454sCZia7uenxbGxz8lpq8M2dXCEsXaqJx5jRivtOPkNu5TJixo3RcdpDyKGilTBFXN/SefQoRBRO/XzaHOxEoc1ynUOc5F6Xy8NvPBzenDZgIimnk4IMhbuihImpE9lxdAdpV6Sx7/N9FH6tgN5rX2w94YLmV6BIroUp7xcHWDHtaRx9B7Sq1974O0vMdyHMdtsSW1mcRw9GW/521dWwdZdB6ignyR+78T2mc3i0gggJjy7kPV8eL74IB0456L9JaGiAKo+wLsHFn315vHOnwcDeob3UvR7NcYwZA4c/8pKZVIZt7BjYswduvTXkCS0w7XRRkQ6N0lYk34h9Cy0X9R6FSIMa+hHJhteCm6lws/yry5lz/Zym03WbJ+6AiSRuN67c5eRdPwd7rJ2CsgLW/W0dABt2vUj+Qw9Rfc8sjD4pzX0JmF/BhDF/Yr5+9qFiFmxvxHjtBzoxVX5+6/wibbwHP8fi8/k47j1Oij2lyeIrGnSE8+lMWDqPHoy2dAV2OzT6hMc/dbE6YwXxj4Q/2otNuO+h3qSO7k1unjBypN6cY2LA4xXsKQ4S7dJCl6F8qkml4e9HUhLMWWgwdv4UpH+STiu4eHHI5/rvefttLQ1bv75ZPRJKXdJpehELFxz+TSwSwhGJfiRYj+GIdzS132RO+9XlWvTU6uaWE0kc+l6bzUbe+DyG9x3O9GHTcVe4Wbp9GYs2/YCCHYXaWivIhDZYJFfdUE3+xHyedi7h5ooYxDzpNJkQX5FG2Seb8NaF8PsIgs/nI+/VPKasmkLeq3n4OpDOtrthia26GOcrZQl3v98wJTUVjhyBp5+GAQMiN5edfb9i8XwvfQcblGwVhg9T3JLlYX7CBho2u3HjZHWsDvPucun7ly6Fbdsga5Li0QVebA67ZoHCDK6qShtuDR+uCUhhoT7UhRNPWRKpSxuhLKPCnZzb5FDaC6RY58GoAzFFsKEslDJSMyg9UsrQPkM5eOYgy7+6vJUuBWjBeTw04SGWbV9G2WelPFjqI+ezWMTPeZQVkLBqHc7DMPrr85B25LTHPMeYsmoKqb1TOVp1lOIFxQx0DGw9zm5eEJbYqpvQnhw/krkRKKUJrG8Y4MxWlG7y0oidf/lONRk5Aaa6/uM9gEOf2pqU1nYFhQX882duNh9yslXyufdMIcnPbOI4+ymxTyfhpJuRD+ThdjvIy9PNvfQSHDoEb70lgMFjiQUtQjQEm/M6HHDzzbBmjQ4BtGGDFl+FE09ZEqlLG9EoedsUyQTLOM3kMqHS0xJC9JQ3Pq+VqSvQWvEfZ+AaPZu8YTOx90lh2fZnWbZtGWP6j+H5zH5kPP4LHH21r4hrbB4Nns3EThiu10Q7Md1S7ClkDc5iW8U2sgZnkWJvmeP8YjBLt8RWXYi2LP/ChfwIh8D6K1eCp0qRTwFLGxfxyLY8Fv39WySsK8DrMb0HV66EGTP0n/mAJsfvat2xoTnpfHOkm/lfO0HSJ25iR43A44ERtnJ2OZx8dMhoEXfr2DEdE66+HnZu8WqPdnNwyuMNOZ66Ojh1Sou83G59zRJPXZ5oz4M7YgSKprKz9alk0SJqn1uG+1BxC/PVUKInR7wDmwiu0bNZkfNzXBPzccQ7Wpr8xtph5Urky1/GuP1Ozi57mpLDbkYnjWbPqT1kXJWJvU8KHtMiTAyDuBuzkEOHWk7sMCbtNpuN9Xeup3hBMevvXI/NZmspNrsIzNItzqMzEIaFaMvyL9rgs4EK6HXr4P13vTxx2M3onFSuee9lihLvwokbgzzworXU1dW6b0VF2vzRcOD1gj3RYHODE9vLbvYkOdlsS2HERCdTernZPGMu61UeGVMdFOZJU5+8Xm3BW1eniceEmwxiE5sH58XAXawYNUinxc3N1VxIWRmMG9esW3c4rJwelzNCchQtLPtoJa4KFmEpwPtALkauqfN4WGcSTNhWRs6DGRRV7mjB2bTidszDlaxbp3NszpuHys8n97pcZl87Wz/X64WiIlR1NZXVlZS++DS7vuHA0Xcgi7MWs/jGxc2cy1WTcbnrkLIyHbYhPz8ip0ObzdYkqmpltTYxH+nhZuk9jniIyFeAZ4AY4Hml1FNB5TnAr4HxwH1KqZcvfC8D0MYEact/I1qXBX/9997T4UUGjTJwH3Yy/LCbK2Zk8RXfZ8ROzkQMu35QTo5OWA6Qk4OyG03dzMgQSm0uhs7M48XXDe4aLKw74iLr6TxyUgwyqiWk0+2okYqr07xMmGLn0QXViCO/aXCGggWNBdhednPzJCcb1rsodguNjZrrCNatRyqe6gFiXwtdiTCmteH0DvkT81t6VgdtsvdOms29sqCFAr+VNZjH0+JwpTZtYtXVNRRV7qDB10CMxDBliBNXTg6N5Xs5XVPDtuHxYBgMvmIwCyYs4FzjuSYluVGwBt9fTxEzdhzs2KHbdTiiOiGG9Jfp4aesHiW2EpEYYDlwG3A1cL+IXB1U7RAwD3jxwvYuDNphL0PECGy6Hk3wWRF9oJk8WVtJvfOuUPNNF7GFK5Df/pa47BuRHTu0Vhpg4UJ46y3953LhrRbcbq1gLy2FjEzhwCkHWZOFo0fR+c8HOBCbtOhv0/CG+Lht7zM8J9/isdI8bA9/Sz/Ln62w2ktOrJusu9Jx4qasyMvQdIXd5+Hpn/t4bIEHm0RnnBGtaM/CRYiA9dOwpYiyT4vaFDudqD5B8aFiUh2pFB8qxttQDS4Xvmef5Znrz7HojYfZsGuDbtsUGQm0tAYzDH24sttRhsHZrBsoOlVGqiOVbRXbGNR7EO6KErzz84h56x02FfyItVkJnKg+SXxsPEac0aS/OXZ8H5OO2rCNGavZ64yMppOgstupycpARSCjDRnRN9zm0UPQ0ziPScBepVQ5gIj8DpgJ7PZXUEodMMsuiG1bV3o9R6MgVkpHDSkrg+nTtfVS3hzRToEe0xEj+IQT4Fhht0NDgw6ImJWluYBz5/T1aq+ZDwQDEG2me9wMiugQnNkKY/Uy7jiwjMS+I5G9n8Ldd7d8lmEgTifxbjcqx0lWdSMJLz1DXkwZA77fiMTEwJQpUSn+rLxSlwEC1k/sTTlkjGrmPEKJnZITk3Vwwn9sJKd/BvaYxKZgg8s+XMmY5LEUHyom77pcjDUbaNhSROxNOS2tn0Rg4UJUbi6rdq5i06kyGpWPI1VHyBqcxZGqI0wZMkWHWXQ4uG/8/bxb+T5DrkjjmPdYk97EleHCe+1sjBOrkdLSFuy1UqpFitwFN+WHthozN5do/WV6Anoa8bgKOBzwvQLI6khDIpIP5AOkpaV1qDMRGTxEGlr2PBDYj8ZG2LcPpk7Vj/N4wLAbLVh3ZTfwelrGeztxQls83XWXNu2trjZDtKNwbGgepHoon6I5hXjecrPLcJL0aC4PzYfad8tI7D8G+cQ8XR05oomBYZhrQDDyXUhuLvLb37Lgd9NR+w8gGROQrXtbE5sIYEUjuQwQsH7EMHABeaZDYCixk7feS6zE8PT+USS/toO6L5YBcN3LBXx7uJ1fj/+YxZMfxV6r+OSPa/ko0cu4P5YzOjcXCfRSFcHby0bR6Z2k9xnK3tN7+eVXfskAYwDeei/rP1zPov/9FvPer+VLR3qxcLCNVTcexZk2pYmoCeBY+6IWVd14oyYcprOfP3z7oN6D2HSqjPtMgtOEEJtLdzv9RYueRjxCBqToSENKqUKgELSfR0fa6Clez4HK8rfegiFDdHiS5sC3wuz7XcjMPIwUg8JCCRkg1+eDzz7Te//69VBSAjkTvSzY4W5yePJMnwVuN4dJ47YTazn7X++xeXMW+49k46SE0YtvhUcewXvqHEaK5lSaI/wKebMEx+bNSE0NkhAHn34KmZktiE2kuAB02UIPQ6gN1J+oye+rkdM/g+S/LcM+YgwJxdsAsI8Yww379vDdPBdzbpiPFygerLi+XFE8XHFVPASvUH+gQ7/X+esfv44rU2/i7sPa+e/MuyVsvzabmysGMOF7P8eboLmKJqW6f4MoLdUnNNPZqil8++6XyRqchT3W3vLhITYXZRg9JktgJOhROg80pzEk4Ptg4Eg39aVHeD3783ZkZ2tRlQiMHQubN2udX1oarFoFt0wXZtzpYOkyoXiLYlSqB3exahEgNyYGxo+H99/XFltpQxTbtipqJ2bDwYMop5P1b6bgxklqdTmCj8G9Khn31jJSrqzlP4ctxzP/UQqej2HRDxwUFAoej25/yBBYvRryv2NQRA7KMPTFxx6D3/0Onnsualt1S1l+GSACxVagZ3rhjkLmT1nMjXc/ysT6/khODjJ1KhPr+5N512Jsjt488qdHWP/hBt6aPox5M7y8PWM4djNJlN8U1v//zNF3MLbXYKYPvQV3hbtp884YlMHfqvby2XXp1O3fR+2kDBa+9z1uWn1Ts0e4f4M4cECLBH7wg6YxVDdUE2uL5a6r7yLWFkt1Q1AmQfNedfAgNVkZ+BITe1SWwEjQ0ziP7cAoERkGfAbcB8zurs5098k3mLNduVKbtJeUaH0f6A27vBwSEnSMwm1bFQ82FhD/spucLCcpyS6cTjGtrDSHPWIE7C9XDH1zJd+kiISsSfDss3ilNyUPC2m5Ll7ZPZvn6hfQ670/U+lI54pPy8h67EEUwqZNuo3iYpg5Uyvx16zRa6h/f+H5pIVkvJqHw1D6pdlsTWbCkb7Hi8BHykJnIAL2PlhpPmvsLFIWPoL3/pNNcakkL4/GOEWJGTSx6FAR2ISvTriHo56jeOu9zR7kg50opVj3t7XM3HSc+YeFfeMqGLxgbpNI6oHrH6CmvobiQTvpNWAyIyfcw7Y1y0jtrZXqJ6pPaDNblwtmzdKEI2AMhtGOQ6QIKj9fW3mdKmXi9mXsOLqjc6ITXyD0KOKhlGoQkUeAN9GmuquVUv8QkZ8CpUqpP4jIjcCrQF/g6yLyr0qpa7qqT93h9ew/cSvVel0tXAhz5jTrOzZt0qawZWWagPxTlpcv7XDTcFc6cUfdyLk8XC7tJW63N4uw5tzpYd7v1xFz5DDyH28BYDz6GDkTvRSVGeRMtdGrtBcHr8rG/tle1I3X8cDDdn6zSlsAl5frsCM//CFMmABDh2ri9ckncOtibblFYYAJpnLhLpGICYGlLL9MEIFiyy9eKjpYBAq+/advYxMbsTGxzYEIHQ4MpZo27KyrskiITWiKxgvNHuRFh4qob6zHd/Ys4z/+gpNpqdx7No3EMbng8VDw0XpWf7CG497jJNuTmTpsGinGgNAe4SIwYADK6WxWzkeoAPc2VFNUuYP0PkMp+6yU7L7j2frFrhZ6lZ6MHkU8AJRSbwBvBF17MuD/7WhxVs9DJ8hZgrMEBq+rQGLmcMC0aVC8RfGT73mZs9DAZjOQRCdxbje1GU4S7EaLe/LzoaYGdpZA5YlGUvz93boVsdlYsKOMvEwn8YseoujeTE5XlNLXcSWxuz7E81+FuHe5mD5d+OQT3V5ampZK+XxaV7h4MTz6aLMXO+k6t3qZyiN9pEMTglyFQ7ymqVfo2FiWsvwygZ+9z81tuxpCg6+B7Ue2kxibyKnqUzxwwwMtTukiQv7EfGoaaij7rJSc/hksv+1ZHAm9UUqRkZpB2dEyctJyUD4fZ/6wnbTTDSTXnCNx0TTkxRep31JErP1TDo48yOe1X1DbUEvRgU3MGT6L9dOf44StmhRjQIsouAooyFCUXaGYONJHXp2nqT8huQdznzDs9qYovQ+W+ri5YhfzJ2eSMCuEZVYPRI8jHhctOknO4vUoyjZ5SR9hUFIiLF/edpKo/IcU82oLiC91s3mRk1UxLrKzXfiuyWNbqYGzUFp0pbpai67SRzl448B85iStphEbcVmTsZWVQVo6MVvd1NbUELOzjH3GdVx16kPiRw+j9y43ORl5bCpz4HRCfDxs2aLb/vKXNTeyYIEmIspuaOJV5iY2x0mGMnCX6Hhcht+6q6EBYmJQU6bgzXVhOJpT6Ha3yNBC56LdUOwbNjRxqd4HcjEC/DK89V7cFW6G9RnGewfewx5nxxHv4HDVYaamT21xSq9uqGbHkTLu2nyafh88S9zdNviW9gYvPVJKxqAM8jPyEa+Xejaj7h1C/IHDyJ13wg9/SOzQ4YzcXExdyuf44hWfnzvNtD9/jP3nX8cWE8PABx7QEzNgXMe9xyk+7CZ9wAjWffgCmw9vISc9J3QIloB9QpxOXPn55A2fhfHaD5Ch6fTaVgZzqy8KNrunKcwvXpxPLBp//BufD2NDAd/fv4jhbxfgzFY4HK39hPw5yRd9S7F6mZeEMjcNg9KxbXMzMtXL6jXCf650cKpSWnWlScd3UPj8noU8OOxdMk+/Td77j+Gb7OSTtw/y0qcZ7N9YRtzIoYyo/jufj8xkQO1BajOc3POA0aQ7sdm0HmbuXDh8GKbmKBzocO4FhUJ+qYtVE1dAvgvXQtEOkXleHTguNRW2bUOlDuKTtW6+k+9tpS/t4T5SFiJEu6HYzbWj0tL45I9r+c7v81vUa3LI8x5j+vDpjE8Zz+POxyn8WiH5E/ObMg766+b0z6DfB3u0Nda2sqaQ6UOvTOcf5duorvciDgfxN00l4bNjiN/u3emk4UA55WMHMmHETcTb4rklOYtbNh2GfXv1JN+0qWlB+Xw+lm5byuN/eZxG1cje03sBGN5nePjUsEH7hFRX6+CK3W2Z0wF0iPMQkX5AInBKKVXbuV26SNEBOYtSmtMwNpjRaSdORHbsYPT0dIaXu4nNy0PE0TJArqGoXVbAmGVuksc4+X1pPnmZThK2FeGblMPHhw1sNm2RtWcP3Pplhd3nxVOlHf4AZs/WoqviYuGvm3ozZgxs2w77/93F00V5HPnCzielhcwWN97bnLyWkE98RjV/jzd4Z4Fw+LCOtxioh8nLVcSuLoCHtbjMXeoifahQtMPBfdW63w68YNib31NWFg2Hj+BmCgNHGIEBUi1u4xJCKIX3AGNAS49vU2fgHgIDB4xoJY7y6w/ssXaqG6qbuI2C0oKmlK5+M9sFNz1K7d1C/NZSaidnYL8yGedV2cSuWk1eRQz2M+vxzM/DyM9HZs/WViePPALZ2cSuWEndng1cddjN7UZ/rqgVHL0qEHsdqq6O2swbSEhMhKoqlu56nme2L2Vc0jiS7En88iu/5PWPX8dd0UbU4FD7RIRs9oXIHBgNIsrnISID0SFBvoL2Ak8IKD4MFAEvAX9WPdDG7ILl84hC5+HnXss2efj+/kWMnp6OHDygfSLKmnODK9OPYu0aRaLPy+z7FQt2PszOynSq9xxkzyPLWdBrPVJUhMrJwZO7kPUbTOuqiYpHEwr49AWdn6Pmmy7Epq2l9u+HW26BF80gL9nZ8NvfwrJl+m/MaMVVfbz8qsBAbILPp0VTXq8mZJMna0fF3Fw93NVLPYx+ZhHGuHQmJB1kdcYKinZo8ZYrXyEBynPv7HwMqUYMOz5PNctWG5Tt0Mp0pbQ1mWVhdekgMOhfU+yotCnkT8xvIgQCKI+Hgo/Xt4ht1dYmWVVbxYzfzsBb58WIN3hrzlv0TtCOgMrnY9WWpRSdKsM5ZAo2bzVjn1yKI30URuVZ/jNvOBmjcnAV1yLLluk0mWZKZb+/RWJMIierT5Dy21eRzZspTm2g0BnPgjJF9iHFL6WEZTfUUu9r4Ec5P+KxrMeA9gM7+vcJZbfj9Y+/3f0i+nS/nUFsOpzPQ0QGA/+GNpetAkqA/wROAueAfsAwtBf4/wIHReRflFIbOtTTix1R3aA18AAAIABJREFUmGY1ca8jDNz7nQwvdxOXM0VrtAOUyF4PFG1S3Ha4gAnn3Jx+YSJ187KZuKOE2lud3DRPIa5NkJaGuN30njOHhQsdzJkDdp+Xmgfd7Pakc4PNza/fyaNKORg7VhOP/fu1heGsWdq3yWYzld0CZaWQleEXGymqjnnBZyexsRp7ssEvfym89pru7qRJ8LuXDL5a6yRzu5vaHzlZ8KjBff5hNIkl0vlolZtf/TWXydnC/MVC4YsOSs1gpLNn6wNgJBZWlg/IxQM/5zBr7Cwe/8vjDO0zlOJDxdQ21FJ2tKx5MzQMXINn6dAiCb1bbHihNkKlFI2+xhaffvgtmVJ7D2LToU3Q6GNSrIOBfylh7+gkBqZMp+zTIhq2Q9wYM6XytGlgtzc5JTZt1jdmk3vvryjc9ANGJQzCVvIytZO+zvgtXgZPTEZdYTD/hvlN/QpUkofb9JVhREUMQgZObMOUtytyywejPbHVHuAvwCzgL0qpxnAVTUKTC/xCRAYppZ7uvG5e3Ai10dntMHEilJUJV811EZuXBw6jFQEyDG1+m/qWmz6+U0ytWEaCegRZvpxehqHZl23bdL7XGTNQiXYddt0OhQUGCYecjPC62ZniZPdBg/0HYOdOePxxbfIbrFOw2eDRxYqapQXEbHOjVjqprVMYpW5eUI0cq46l/honht3FCy8I1dWwdy8oJfw+ycV7vfK4+QGDxoDIvBgGyunk41VuXizP5vrqDYzZ7qaqzol7l4uhQ4UdO7SyPRLJn+UDcvFBRBhgDGBK2hSdyW+Qtnxq2gyvnY1j/kJk2zaMrCy8q1c2EZBQGyHAhl0bUEpxtvYsCTEJbPjbehZere3YfT4f9Y312sP7qiympWRR5duO78vZJFee5diJciaOvJmG7Dpit5YiEyfChx9qW3aXKyiPegm54/Nwpk3BfaiYnOwsjIpKjJzpjBiiyBk6tYnjCUa4TT9aYhAykVYbJ6ho2+8I2hRbicgNSqkPompQJAEYqpTac76d6yx0dxra4I0OCAiP3iIkTqt7df4NRe1/LiV+5VJsY8fo/OHPPacr5efDrl06tPS117Fq8m8o2uFg4kRNU0YMVxwv97L4CYNZdwqDBukQJW43DBzYeu4pBVVHPVTMXMSec+mkVO0DmyJxZBrX732ZHcPuoubgUT7MX8ELrzio9ir6J3r5+n0G728XJk2CxEQocStyMrzcO9/A0VvwehTfyfdSeUqRt/VhrspO58YBQeIt892E4ygC/V/MFA4cPKgjE18ExikWaOYggjP5ua6aidx0E2rgQM7u/5gf/ds0rr1+hg4+WO9tlb5WKcWM387gTM0ZDp05xNAr05mz7Rzf9U2mJE0oyFDs+7ycqelTOVJ1hKdn/II+L/wPvd7fAU4nVXPvZ/UHa9j22VZuNSYw98W/a7PyA+XEPlcADkczwRrsJHd8LkacocVssXbwevHEaSdYv14mHHcUkvMIQxDbEjO1aB/aPEF1FufRYbFVtITDvKcWzbFYILSzGzRfKytrllIFbpotiY7g+v5iJEHpGwJjROXkaBtZoHZyDptKDVIHaV2GUrB/vzBvnoNrrtXRdLdu1fqKlJSA9rMVrjz98IJCYdXzBjkfOfnKFW7+VJ/DhAmKXjvdeBKzqPrwKPU3Otn2d4P771M4Xizg5hg3oxKdLJvsYus2YX+54ol+BcT9h5v/3uCkYb6LfJeQMdWBu1hx5W1ObkxwY5viZEF+gHirjVwf7fm/WLg4EOj70MKJTimYNAn11l+otdUy40Mvv+9b3KQkn5g6kbIjZUwxHeg8dZ4WbSbW+rhun4famwZgK/kjY6d8g3LZz6Ezh7DZbPzg7R+SmZHB4m8+izgcrNr6a55552fUJ8az/4r93Dvpfg79+Xe4h0Dtx+txZS7EleFi9rWzWbVzFd/632+ROSiT+RPmo4DCPc35zvMnPITnixOs3/cqJZ9tbdqslVKcqD7BQxMeauUsGOxECLS72bfwG/HHBQoj470QUXotP48uRjgjrMBrdnvrQ0RromPD8dhjrY/l+fk6RohhEG/0pnGOsHEjoBRz7/Kyp8Jg9mwtXrr5JkVsjRfnzQbVZn6P9DRFwroCGja7aZjk5J0tLqrPCS9d4eJPcXlce5PBvhg4NmwOzul23G9Xk9rHIGeKkH9/FY0lRcSOHk7DFjd/V3mMGOHg2F4vfT9ysy8+nYxaN8s35THrTsf/z96Zx0dVnu3/+8xMtjkTlgAJAUI29k1IgCQTCC6g1hWrKJpBEEqGYoHWWvtu7du3fX9vq7WLIEiC4Ja40qJtrVVBzEBOCGSCIghhScgCYZUlM1kn8/z+eDKThQQSRYWW6/PJB5LMnDnnZOa5n/u+r/u6yMgAm02gme2IGptfirorWUPr+5GfT6fzL9dw9aDNYigEZGYi5s+nItRF2KcHSLv3Vn+G4jzqZGzEWBZOWOjvScT2iiW/Ip+RfUYyJCweS5oB7chpvClJHGyoYu51c5kRN4P/yf0fTteeZvn2FUgBC8bPx/Liq/y2qAZ9UA1bvzOAs3Pv5+k+BfSPiKesMt+v7PvCJy+womAFIQEh/OPge/xp+0vcMeEBPju5m9jeseSVbWXom5sI1rdzLhqGzL4fvTyPh8Y8xKJ3F/kn0rPvyb5oMHA1uLpXZuoCu/PrVum9LMFDCPFfqBLYry7H8f6ZIIRiG9lmutHCW8lMt2LmdZSdmM2qpOUjXmkaFzbkpWwtrYv7ITtSwn33SsLWZ5L6J53rk628mmPH4YBx2zJ5LFRn51Errpl2UlIERQ43NqljGtif0uxcTsp0jh0LRUrBsCQLOa8qWm9OjpoOv/8RjfSZboRmRryaTUB5CZSXYJo7j0TUIOCseRrjqq1EbFAsrxqh8cQTrbPr7mu+tP+sXJv/uLLxpZg+oaGI6dNJ0HXqZ32HKVOW4PbUkFeex3H3cfRCnUBjIMuSlvmFB+8ffT+HzxzmVzf+L3HfjcVQW0ua2UxCs6z6/+T+D/Weevad2seIviNwHnWyYOgDpB0xsjWiFzcdqyd+yH2EaxEkDpvmL1N5m5o4fvoQhUd2MKTPEPTyPBY7TUwqL2bn1t9Sf98NHD57mOReY4h++3doDRC97zyHy95k2tRU3NNdFFQWXKiF1Qk67GlcDFfAFO3lGhL8RfPXNbSHVDRVyxOLFV21ucfUegCuvXpvSIiiyxYWqqa6zxL5ArSKOlLXeWOdm9JSKMx1890InaRZLa5+wwe5GXNe52BDNENO6Pz8MRcB9S6eXhlCVGQjct06eu3bxpLerxBhrua6cZJPPlE7fE1TTKgnfyOxk0nVdxfz9vQV7H9RR940HWJjEbZ07IvURLzBKFi6286m767i1j/bMQUIFRjzJO7jri9lCej7rHTVefEavj1cciiw1eN8Krd+pKcrMsjipQiDAbPJTJ2njvyKfEICQnAedfqDkjXKSm5ZLjuqdmD7Uzrrtq5Ams0IgwGfrHqkJRKBYOGEhfQI7IF1UAqWAI1hd8xjTq9pBKXdwNbTO8kqUgOHK29bidfbxKqM8Ti/m8y094sJD+nHPVE3k3bURFlPyY1Hgwh3SZ6a/iRzxs3BEmjB09RImCeASUn3kHbERAQWkgYlUVVd1VYLqxP4ykyrbl/Vpi9ywf1p+6RvdRd1ucpWcXTsxfGvidYsiC4o/LXeRJjN8MwzsHy5GvQrKlKH8AUZaFW5arUdr0+04ijUmD4d9hdrDE61ElikU5dkZUKAxssvQz1WUk7o5PWwcvvZbPosz2f9Cwn0OSBJCOiPOVQyfucLZGpb2bA9jcoe6bz2qgWvV/DmmxDscbPCqwLQGFFIUcAY4kp2EzBtGlgsCKHOMy8PTn8h+H2WhcYg1aPI1yULmjLRnmjb4GtPGLkYBffbEKm8hu6jK0yfCxq6CRmIVlm0jz1R46khyBhESlQKB08fZOKAif5sxjbOxqbSTbjrXXznowpGvvwH6mdD8KPLMJvMNDY1snbnWkIDQzEYDAhg1J+3wtFtiJQU6v74NP/x57upO1XP4fNl2MbZEEKwff9mvrv/LBVhJkbtP8Wdv3ydfv1iqD+3grh3sznTcIrF68soPvBj1k0yMv/2JKyljQQYAxEnvwCrFREaSvY92ZyoOUG4ObyNFpbv+ttnZq3LTN8E1far4rJkHlLKcill2eU41lWP9v4EZnOXTEF8C6PbrYQGGxpU5jFhgpL98R1u9epW1ge0bMcDf2AnIVGwcSOUVwheCFDSIHannYZGQdRgwV/62/nfyFW81zudsOJ8ZFQ02l4n20nmuNtCaLiZ6Dgjk+6PY554kT/WZXD38Uzytkrcbth/ROO1Mith1WXUVDeRYNqNKWkicmEGLrcKBJqmym3FxWruqqhIBcVVv1Ue56KVfEv7W+X1XvMs/2dAh37c7dA+wLjPnmi7yWqWADGbzEwcOJFwczhLk5eyZPIS/yKqBWgECBNNVUe5M/80w481EpT9OrhcuBpcFJ8upkk2UddUR35lPkOCIjFsK6BhYH8a8hy8siubw+fKOF17uo28SdKwG9k9pAdRZyWGhImE94vBYDQS/OhSBj33KmHBvdkb4sKd+yGDTX1ZO9nEmeVPIV95herf/4bq++5CSonBYKC/pT9CiDYZRFcyswvuT0dSJ3SSvX1DuKZtdbnRPtOoqemw3uKTHOnoby4E9O6tZM4feAB/Y7tgkwtHrvQf+vhxFUCkZiFrjWDbNuVJc9ONku2b3XxUoBEdDXsKXFhTJCFmFaFmf89Cw0RlRLM9IJVVpqXMG/Ah9e9uwrRgHkFHSgjvJ/H0j+LeiDxumeImOEgS2Ojmk0kZvDnxKSZMMjLs5hgaC5w8v7yGhQtVxiSlGjRculRJxScmqvjZkbNW+1t1ouP14xquZHTwRu6oBNMeFwSYXuEtxkoJCWA2I6UkqyiLoqoiJg2cxNLJS9vs4Gsa3czYWMqrWyMYUGuid3BvmmQTXq+XdTvXUXGuHHOdF09TI5MiJ3G48STe5CQO78rlZfNBXj70JyYOmEiQKYgHxzyIJdCClJI6bz2f3jkZ8+QpWI8YEFlZSK+XTGcmb/76IWr3f86QojI2RdTwyqE/s+90MT/e+nPmv/YAK5Ym47hzHFsfvx957pz/ea0DRVcCQ1cCcFfLg18Xuly2EkKsu8RDpJRywVc8n6serdVkRUc66rQkJw6HYtq2ruFbLDBvXsvv+vdXVNqglzKxoVMVa2XdYTueJsFPfqJYu+nparGNj4dDByWxH2bysEHnWFwKJR8KbEKnCit5g+2kThHYbPCYI53+d6ez/s8WQhGMtYaiRYIr3Y724ENELLJzx7Y/YRiSxLClIcwxZFKao1Nw1kr9XRkEi1T2v6Tj8Fj5P92Msd7Fxg81pBT88IdqdmX5ctixQw0jmkwCa4od+0obonkYsnUTPCWlJUm7RsG9SnCRac1LMX06pJJmZEB9vWKJZGXhfiTdv8g6q5zUtPMBN9dLUiq8FPc1EdmvLyURgeTGS1yfr6PwSCE/3xtB9K4yTNOmcctjr1In65G3e3nsz3YiwuMQhzfRK6QXP5y8jB+MegRXfTVrd67j2e3Pcp0Wx6D3diKD+kNZGe77Z+I84GBRSR2b4gUjzwfwytgGegcEU3L6ED/61EzA1nyiv/Bw3mxk3Jq/0uS4Ac+8h9EHOInuFYNeoZM+VknPWwdZL6qB1SU/kG9gEPBi6E7P40Yu9BMPA0KBs81f/9KQEjKzBHqhnbREGwsyOv6ju1zw4otqZ11Sohb/0OYB1Y5IFHabG88WHVNcNMPKdUb+t43Hf2EhJga/mGBKirKW1XBjRWfo9Ghiix2kDBbI2HgOvqBT3jed02VgJ4eHt+v847wVzHZmzoTTp+HZZ9XEe1qCgQWmAAyz7sNTUYXp5ElCinRG3hLN0BId0xwbbuw87bDRKzKE+59bznWNTj61pFKwzY7bra65qAgGDoT16+G++0DPF9jmWLC0k11PT1eluWZtOlauvMamuirwFR27LggwNTUqcDQfT0tPxzooBecBBynxU5DV1cjeqiEupSSrOIfAKAPJFSH0sM/nQfEqpwx1mHe/zsMxM7l16z8wNhhpfDefzDt+x/dveAKAMXHJOKuczL1urpJCeSGHA/97C1sGNfF6omCcFsf+k8WYA8wYJHhkE2aTmcQhaXzYfxtDi03sHNoDrbeRABGA1ghB2wsp6WNgyBdGhp1oQgSZMdY3YswrIO37SThOF5EyKIWcXTnolTopg1JYedtK/4Bhl+5PO3SboXWZ0eXgIaWM6ejnQog0YDVKmuRfGm63ahYPGCDIdTaryV5Em8n35fu+daPYYmmpCJjNGk1JVkzN2Ux4rEZqalvaqs2mfM3jYjUKNlnhA50CQxqxcYLJpTq7NCt3nMtm8kkHnhcreLv+UTacm0LFF2qxBnjvPSV2uHm7RvpkK+WvK6pt/YZw7FYrQtcJSLOCRUNDkDBVw/2b5dzXuIJDpuGkGfI4MWEmmjkChCAlRSlYT54MVVUdZxO+JnvrGY45czoOHF3Vs7qme/UN4TI5dvmbx2azytabjyc0DbtT0LhFcvjUi3xS/zsakhK54f9ep6apFr0yn+j7Z5B//BC/vGM2tW++iWhUjfH5nwgCzsA52ciJAAOrC1fTaA5GInEedTJx4ERVUnO5qP3oQ/YGu0g8JDh79iyJVcf4fEhP3rcGM3zvCYpHazTsf5WHxqVjvzuX+uAo9tVV8MNByeRV5FEeqOFJtjCqcBfbbx7EyMCBTHGeRBgMkJbGgil2ZntqkFLyaLNNbn5lPnOum/OVmuDfxCDgRV//ctTJhBALgblSyilf/ZQuP74peRKvVy3iBQVqmjs7u2PZkaYm1csoLFQ77exsWLOmcwkTjweMBsm0iW4WLFUqtx2xlPySJwmSz7a56R+vsXEjjBjkIsjj4qFPnuBgvxSe2PkgDd4AXFwY2UwmSVAg/O1vkJPlJixKo+qYYNXKZve/Vivy+aMuHGMX06P+FLGNxYTNSCDAEkxTcipBS+xkZgk2b1Z6czZb58zCrmhVdVXP6qrQvfJ41B/PYgGj8ds+m6+Gi0Tqrsx6SClZXbgaR5mDtOg0FiXaEa0lFxYvpiG8D2deWYNjUjjG4yc59uTPWHT9423kTTImLGTt1uV8dKKAG8OT+N7zRXDyJOc+3c4zyVDw3SRO1p7iVM0pRvYbSZ+QPqy6bSVFv7ATvuEDaoxeNo3RiC85w6FQDwPOePhDejx13npuHncPJ2tO8dSMp3hjzxsUVRX5VYFdDS7sf7OzrTKfaX0See7MFIK3OxFjxsD3vw89erTqc175DKr2+NLyJN1ACTDhMh3rqkVNDZhMqkRTVaW+b595SKnKQzt3KjaSyQQnT3YuYRLZX/L3t9x85z6Nj7ZbeMCtSlwdzQvefTc89KBa5LOCNHIdiit+Z3UO4Qd0jgQOZonzEWoJ6fQaPB6BxwO33yGZMsXCR9tVIDRrAgztKMYWjd09rIw6o7Oh9/XcULmL7Sdi6L9Jp6TWRs47Ftxu1SNvaFBlrI60vDoq1bVfk7paIblivc/r6+Gtt+DJJ2HPHggIgMZGGD1aGcHPmqVM6K82dMKf7upC6aqv5s2CdZw21FFypoSZI2b6GUq+zCYgL48vxg/DeHw/5aOjcJ7ZxcOeGuyJdtVDkBKxZg0L8oq4f2ICofcsQex9HvLy6PHEz+iVBD2rtvNF/RlG9B1B8aliFk1cxEsFWfy+6U8cfrARowSP4Sz94o3c81kTh3uY2FdfydC+w3hn/1/oFdSLma/PxGAwMHv0bDISMhT9VwhKzpQQEmDm8NkyjAUBiDPn1W4wJEQxR/y3qjlTGJuOuV7ibnC1cUy8FK40P4+vzLYSQphQXh+VX/lsrnL4svjOSjSgylDbtsGwYUqNtplYQkpKCxHJbFaLpzVFMsKRyUoW0/utTEoOSbKzL2RoNTXB7NkwJVXy5vRMeHQxdpFJ5mrJqGg3Il+nMigOe8m/XTRwtEZNjeDjj5Vcu9GoAmF7WEIFvZ6w8+fpq9gy+XFeq5hC6JkythutbN6u0dQEAklQo4uCbZJTp1QTffnyC6+hdVbSnsIrvRJNKsbYpczWOiB1ffvYvh0GDFA70d271QU2NKh/d+9WPx8wQLEL/knQJaqplJieX8fjrx7m3i2nOeE+zmPvP9bCHGreVYjnnmPY3wrYsGQGy8fX0YQXs8kMKGXdx/5sZ/9fX6Qo4BS7NmSyTn8WmZGBXLWKmsXfY0nyMrLuyGLudXPpp/XjruF38YvcX/CTj35KqaURKcDTvBKeDG5iTSI8N8FDYuRExvQdzYjgQew/XUzF+Qrc9W62lm9tcz1CCEwGE3XBRpoSJrTw1J3OCyiDAlSP5cGbeWvZDDILV1+SJSWlpLq+mszCb49Z1RG6w7b6qIMfBwLDgD7Aost1Ulcz0tPVV2flmexsFTQMBtUgDg5W/1qtLdPcvlmpKePdPBClY5gaDet1GqfZyM+3+KXUfcd8+mnVr4jt5yZsn07NlGgsuo5hpo2mYLWafr4TGg1B4O3e9RQUKJdATbpBtpXfFW43GRkaM2628N//DTsn2Vm7xYanQeMGo2DeXMUSm2LQOdJkJWOfneEjhP8z1VlG0CZ7yFMe7cFOHbvVim1lW6/z9rgCVBvaYscOuPHGi/OOfTaRN9wAmzfDpEnfzLl9jehSM9ftJnh7Ef1HTOL6Q5/zsakf8b3bugj6pmNrzxwHTWNW5P0crT5KjUftZvRm7/Atgw4ybN8+zkwYieOUk/sbXKzbs84vpmhPtLNo4iJG9B3B7a/eTq2nttOts2z+eeGxQh44GEjkh06mRFv4XWId543nqThfQc6uHOwT7VgCLcy9bq6/7BackAGm4Ha6Qm2v2bPVwd4QN+NLBKv25+KOvwdL7wgktFXNbTaMyizKIvdwLqVnS5keO/1bYVZ1hO6UrQxcyLaqBv4MvC6l/PhyndTVBl9jOyfnwr5Fa7hcihFVW6sy2gcegH/7Nxg8WFFz09PVDl/XYXCU5LVXJQZSmFqRjzfZyt5yjalpLY12Xznns8/UQltSqnF8qBXzMQdMS0ML17CmCtbn2sk1eqn1dK++3tAAZ85I5tYre9n2DRmp62zxWFlrtOP1Cnr2EkSNtBAWpspyN0xy8/AQnYD4aIaV6Txmt7Ftt6WNKHBHaN2HTUtUHu1ERyN0HYvNBuLiH5orZhK9vh5uvbXrAytut3r80aNXZwmrFbrUzNU0hNVKgq5TN+uH3D850K9K6w82zWmoput8b6CXtZOO+pV1AVIGpbD58Gb6PzKXXW4XBWd3Y42ysm7nWtZuWU7UgBHklSt1XiNGbs25lYamhi5dQ62nlp8HbCEvMIbUrUeYNPB61k21EB82BL1Sx3adWsAXTVzEnGYhRSGEKlV15HXQbLRjTJ3K8L8eYFusAdtnAu39J5BWK5mJkrwKncTIBJZ+EowhP5/6pET0yELie8dTeraUkrMlpEWnfePMqo7QHbbV9V/jefghhLgVeAYwAs9LKX/T7vdBwMtAInAaeEBKefibOLeO4Cux+Kxdp0+/eK3dt/AbDOr3Vqui7UoJzz+v3nfWFOUHnlKm0zjRytM9VzJ6sgW2C7ZuVYyk1GbTQSnV/6WEoUMg6Kjk4EHJ0DTpf70mr6Dq+JdrzO7dCwXP5BMyNJpJeToi3aY+F7pOY2Q0hvU6Q++zcaDKwpNPwhtvqLLU0KGQv0tjQbIV4dQRqVYWZ2jMrbl0RtAmezBriKyrdPjjrbdUBO4OGhoUtzn96icvXlLV1VeWstkI0TQWAXPGP9w22DSnoSI6mrSyMhJ/8hRab+V/7vV6cZQ52F65ndIzpYzoO4KJAyeRPuYh/vSjW/jDngY+jtxB3x/9J2aTmT/k/17d3258FBqMsCPkC2ZPsHLTmd6URSTiOF2ENcqK2WTGVV+N1gCW1qWGjhqSmS02zFmJksIe8UzoP56pL+5BxETTuNVBYaiXU/Ica7b8kZs/Dmdkwi0EFThJW5BAwZHtzB33MLbr5lyU3tsGXzPt8IqaMBdCGIGVwHeAUcCDQohR7R62ADgjpRwC/AF48ps9y7bwlVji49X3JSWdr3GaBnFxKruIi1M/e+ghNUkeFqYa6c8+Cxnpasfef1I0ffbrTEgQOIsEgwerMtKAAYoSvGKFMkUSQpWu+oa4mVCXz+d1Q/Bsycd9wk1+vspshPhyNVIhYHvwNI7kl7G5zkpmtsbin2g4PFZMR8vwJlk5cFTDalUDjUuWqKb4gQPglYLAH7RM1wuD6PL8hv/zJwSudDty5VWoiPjkky0lqa7C5YLf/ObSj/snhC/YtFkYWzWxhNWKpTlwICUnT5SyvVm5dt+pffQ198VZ5UTU1GCtAFdEGOmuWJaMmk+WM4uff/QzGrq5h3LRwH8kuykxnkOkprJgylJW3b6KjIQMspyZvLVsBvtnz0BeTE+nVR3Ws9WB8+AWIiOHUnBuDw3JE6GsDNOUNMbEJlF4tJCzhkbeCTtJ4+FDiJQUFnwezKq/CxYVGQjtTuD4mrV+LkvwEEJECSEGX4ZDTQYOSilLpJQNwOvA3e0eczfwUvP/1wM3iW+ReuB7b5eXw9y56u/U2RpXU6NINrNmqSBjt6tSV3Iy7N/f0mOrERqB06wk9C1j0lIri36s5jqqqhTz6ejRFrl2H6vIYoHENI1PzFZGamWY0qxo/cykJbioOuJFdrPX4YOUgtW181g/6SmeN2SQ6xBERkK2N52ap1aSlm1n1XPCX806eVL1cWbNUkyymtqWTnhTExw6pBr8XXvt5vf/o4LMHIvS8rpa0NSkWFVfBnv2dP0mfdu4mM5OV567ejV873vwxz8qrnt7NGcn8tlncc26WzWKm98Y/X7yC/59bx+OVx9jRN8RnHKfJK1PApZe4Qz1YFUqAAAgAElEQVS7cx63BY8h5rZ03IGwsWQjNd66L3WJlYG1PPVQDO5H0hEGA5YAjZqzJyjct5nxxef4PLgaz1aHvzzp05vyer1Kd6qVvp1pShqJQ9OU7MjgVIK+vwRWrULY7cxPWEBMrxj6mPvyzrQI6p/5PdhsiPx8AmLjEd3R7GlPO/watH4uJ1VXXIbjDQQqWn1fCSR19hgppUcIcQ7VsD/V+kFCiAwgA2Dw4MsR1zpGdxq0vkDjcKjHxcerEtSzz6rv/T02S0s6H9x80NaquzU1zR7lWS1WtprWbCI1Mx1NS1cSIFlZLCjSsY1P5JN3v8ue81Hdvr7RoyR/HJVFoFOnKcJKpjeDgHVZzAnVMb9tRSyy+wcaMzNVRtTUdCHjrKlJBcl9+5Ra8LZtlx5xuGJpt12By6V2Ct0tW4GKui4X9Ox5+c/rcuKrDtX4pBYqK2HTJvXcZcvaHENKiau+Guf/2TFu2443JYm0f1+NyMvDMGAA849I7nzwdfr2jaYxcyVB7zgRn69BLlzIy6PqyD1ZiOfdAkrPln7pyzQIA2PiktECW97o5rw85pUWICuqGF0ZivFHj4KmtVCUy/Mw1tThCQli4sBJLFn4Aww2mxp8BL/ZVGtvm9CgUOZPmI+jzEHSwCS03mrY9ksNYl6mAc6L3pfLdJxfNX99VXT0zmu/penKY5BSZkkpJ0opJ/br1+8ynFrn6Kqsvi/QZGaqLKW8XP1dQ0NVr6ONdmK7g/q+NRhAM0tqjlezcHY1CRMkhYWQlSkhKxPtp49Svy4beey4v1YcvNvJT+/cg9lQ263r0gy1PLHoHFONOuPvVN4gYZ4T3NNf57QWjceh4zru9pdWdV2V4IxGVbFpXbY/XCqp2OuiV0/Jvn1K/+6Sr38l0m67CotFzXF8GXg8V0eUvBy7W69X7YYCA1VNttUxfAvx0vULcDs24hkYiSG/AHeDS+1G1q/H4PUSER6Lsa6O4AInDB5M41YHrrMncJwuYkCPgWw/sp3eQb2+9GVKKVvUfF0uyM2lsV8Y0cXHcA61UNIbTsycgUQ5AjoO53J37nHufOYfJP7VyfJtz7B8xwpk80awdXmutSquj2SQNCgJZ5WTrKIstbB9GSMb32LzNRrgXC5J9l9KKf/nMhyqEmi9PR4EHO3sMc0zJj2BLy7Da3cPXzJdF0IFC7sdnnqq2egJiXC7sGiyDTnjgsNLiTxfjSN9NcfGzeDYuBn0eG01MYO97N50nMaP89heNZiK/32JA3c9hvR4/Cvv/WtuJrhncPeuUUD5mR78fpsVR04ZOlbG3BjOLouVUVoZ+cLK4p9oHSrPv/OO6sf45jRiP8jk+aDF3HMyk6FDlDJwV+7VVWsAZTSqAcAvg9Gjr47J8w6ie7ckwi0WmD8fhgyBqCiljdNqh+CbFRnYfxifxVswVh7Bm5KkMgDfNK7JpIKPpiGtVvbv3Ei2pYScQ2+TMjCF8nPlJPSfwHV/2UbU+S/3BhodPhqT0aQ+jDk5UFqKcavO7liNiPNeHNHwo7yfkVmYySufvkLVsYMEby/CO3gQg/dUcF3oEL+JVWt0pIpb46mhqKqImGYhRXej+8ubPn3Z53URV5qH+Q5gqBAiFjgCzAYeaveYvwBzgXzgPuAj+U1PzHzFdF3KVu6xKRK7yFT1zOZjSQSrV7co6y5apAIMmZl4NuUy6KODiPo6zp8VDPXmYnq/gSRjISV19VQdOEiPQMlB9yBi6ysI+N2T0L8/QULwj/fhhusl7ppLn2uQoZGkqYHkrKnhXGMGA/vZGIJG5sMC8bAd6bLx/57QiI4R/pKSr7QmpQoc/nLTTDeWbTq3LYom6l0d9zAbzz9v8fdJLkYIuWJot18GP/2pGgDsTtPcYlH87asB7Wq2EronvyGEenP7JBXaLXRagIZ1kBVHuYOpS37ChOZ5CIC6pESCCpxtlKvdj6TzdI9cIsLjOFThYHLkZACm9k4g9shHnA4RvGF2U9eNVc8SaOHfUpv/Hs2Zlpw+He+BYirtD/JxRS7FtZXc0jseR7kDKSWpI26mauwHPOwewpYbx6D1CiI1yopWLyFA+q+xI1Xcb1vssDvoduYhhOgthJgshEhr//VVT0ZK6QF+ALwP7AXelFLuEUL8UghxV/PD1gJ9hBAHgceAb/6T9hXT9dZPdzrceBxtj+WbB9mzR/3rcrU8yTQsnhCLgbN1wdQIMwUiiftiConreRptXyG7xHXsdsdyU/kLmIoK4O23/a87cSK8+y6Emes6LWGFUEvvXl7e/quR9Jo1LG9azOzzWUizRloaWHBhsYClvwVrqqDssCQtwYVmlv6F3kdB9m9Iw9UOtam0jKJgKwOGaui6ui4/IWS1RFZ/ycbrlYpZs1Q5pjsIDFQ76qsFrXa3XTUwag0JuIIEsrW8QKuUWyL9WYyP9ptZlEVGZCFrv5eAzMhQB3K50AI0EodOY+PhTRw4dYDsz7IZFDqInNK30QfDjcUNGEX3MrpAYyD3jrzX3/j2ZTc5vStoMAcyNi4Fo9HEptKN3NBnEmmDp1JeXYFn4XwCnsvkxv9cy3O3r8LuFAh/Kq6a/lq9xDoo5QLPjvSx6ay8beUVr33VnQnzYGAdcD8d9x2gWwzqjiGl/Dvw93Y/+3mr/9cBs77q63wlfIlmVGvKdZunp2mYRLtjuVqeoz5MbohoMbsIWTSPZa+nU1cvMPbQeHTSCgyrl1MeMoJE7yeEmOsJGtAfYURJ7c6Zg9dsYcUKJbn+778IYs2z9RyslHi9YKKJJgwMMxxk/qD3WVL4CMHBsB+d/T0jmR+p8/ir6URsykE0DwsKux17Bsyrz1TeJVktGVh7EgEouq35IRv1ORpl+QKrVV2bM9dNdJyZoJey8GxpVu296mpUnSAoCP7xDzU53pUNhqapx1+lA4Kd7pqlRLpcuANpo+XUqRVtXh4kJuJeNF85APaOJ3jdy3hcW2lKSSKv/w4G9BhI7iknsxvdWF5Q07nCaiV93kN8fPhjztSeIa8yj9IzpYQGhfLS5CDEmCaiwiIpr66gprEDvZ0Orue9h97jxU9fJK88j8QBicyf+whPh35MhBbB+5++yKm604wIG869W0/zcO52AqZMY84jK1UzvLm8YElIUMJuvg1isweB0JtVEx5ZqUpxXJi5XcnoTubxM+B6VMlIoDKE7wFbgUPAHZf75K5YdLMY355yDa2evkgg2h3LZwg1dozkybjVWB5bqCa6F2awNmEVyz5fRNToHgyZEMq8+QaCH1+CYdkS+g4No2dvA6N6V2Goa45UaWlIs8byZyTP/9HFsSqJs0gQ2i+YiAhBnzBYf/fL1E+awuaBc4js5+Glt8xgNjMs3sNttesJEB5+/l9eDq7LRUYNRuqqUY7bTbBTR/hG5H07RpcLgfSXm3x026xXLWTYhbrUDInl1UweL13MsA+WY5XKr+SfzkJw0iQlORIW1nn9zWJRv7/KpUk6dBCUEpmZyf7ZMy7QcurQijYvD06fRq5YgfHZVaT1nsCxYwexVoApOpbALfngcvHW529R56kjpM7bpgpgaRQkRyWz/4v99AjsQX9Lf3qH9Kbe24BXM9MjqCfvPvQuYSFhWDopCZkMJsJCwtg8dzOjwkeRV57H6drTrChYwaodq5ice5AJ/28tMzaWMiJsOJVVxaRWQECMotNaGoVSBvaXF5yKEulLxcH/O//jhbKqzT2cy+Aeg7ucuX2b6E7wuBf4JWr2AqBASvmClHIa8Clw6+U+uSsa3WhGdVTlavP0Do6Vng6rn3aRerClfuU+4cZRZCE6RmAywR/+0BxvjAbEsmUMe+e3JE2URMxKQyQlITe8jeuhDFzHXPR4LZNffbGYEY5MGuu9jBrswmSUTLtecMf6R6h/+x9sDH+Q0fU7EWuyqD7mRhiNNM28j+OnjNx15gUoKaXpg404GlNUozxbQ6ZYYeNGNbjyyisXDCZ15MprsYCocSN0nWHTo5k9xMmwBxOhvIy6RCvSfOXWeb8UJk1SwzmrV8OYMervHBCg/h0zRv386NGrOnD4cMGgXxstpxqcBxz+RbFDK9rERGRxMWXhQVRmPU3ar3NY/kUyw25/GLlxI1Wf6UT91UGAMOGscrLi83XIVjVSYbGwdPJSliUtZXjQQHoEhTJ/3Hysg6wEGAKIC4tjysBUsk9P44efhDDUHYyQEOAVCAkjeg9j3V3rOPKjI4zsN1KZQA1IpPhUMcGmYF7KX0XkrlJ6DBlDaqUgAgsLpi5l+J3zEeXlSKsVV4BsM9tBaqqanvVtEC+o6yqiQc6uHErPlrKxdCMpg1Ku6H4HdK9hPhjYI6VsEkI0Aq2vbB3wArDscp7cPws0Tanm+hrgmrm5FNWhB0LLvISpFv7zMPQKlPQxX1gti4ho+3TxztsEFBWAYxNy+nQyN4QT9EoWqZ5cUktK2eCezo2azulDdURUFhEbksh7FUuoqTVgCTUwyVjE+2XRRNTrLFuWztqbUjHpOp7xEzE4CtkaNB1vUwmveG2qUZ4PtifTsThyIT4euWULniaBaVjzQJPNhqZZOq7wNV+M0HUCpqWqrGpFDY5CDWuW+MqVqyvOECooqEU1s6lJZWn/DH4el4KmYZqSxsi/lqDHQeLQFl2mDvWvli6lvqmBI2+vIsoYRFFoHbEF2+Gpp9n/9vP81XyCUYcaeXbYWSIjh7LjSCHuec9hmTkTwsNBCAzAsk9DWFwwBE/SZOZWONhctpmoHlEIKVix+dfEffg+4/uG8eiLNfQadz31lYexLFqKcckP2zb+B1l5ZNw8ms6d49efLCfQGIgeBbcePUZwyg2suO95LME9EMkgbTYy92Wj//1R5TGycCE1989E6xWujKFaW1FnZOD2/U4I3A0u9Eqd6bHTKTlbgm2c7Yrud0D3gsdp8LsHVQDXAVuav+8LXdT6/heFEM1fqHmMzphavp36gAGw/i0Ld06YR/8DDhJmpxEcamnXS1BrkKaBcLtVdAoNBbMZjwd2bz7JIy6dz5riGStKmdy3hC2NSXzXUMjm8NOMaFzO+oESKZeBRePwACt9nTq7elrJdVo4vtzOu/U2/uEwM8GcxXd66eQHpjEm2ULRzuZgEGGBadOQuo6DNErKBNZynWHzrGDWcLsVHfmCIcp2jRG3WzRnVV99IPCKN4QyGq/8AcDLBaHKssPS0xnYruehft1O/8pgIOiHP+bAKC/7396AtVJgmp6GO8zC1lgj0YWCzQMl9UEmKs9XMqrPCMyrnldKnKmpzZOyKqsNjB2CJz+ffeOd9Nf6U3m+kgdHz6bna39jQlkDwXsrOdLHxNkAF8MXLUMsXaoa/w0u9Aqd/lp/Xtz5AqY1a7m1QlIfZuE1ayibpofwxNk76bn7AOKl1/xvMHeQUO6GPaPJK8+j3lOPs8p5AfNMSklmKyMre6K9Tb8oLTrtW1fM7Qq6Ezy2oQyf3gP+BPxKCBEKeIAfo3of19ABfAEhKqqZXSWU0mxHq6Qvu8jLg6RkwdtGO2m32UhZYlYfCk3DYhF4vUqAsLAQxo2DHz+mYUxLU+qMgPGGaXzhCGfDMSs3h+ocnTGX17AxJkkj3rSC8heWsyNiOJbJin8u3BayzXa29bVx+KTG6EECTxOsec1CRblky7l03u+bzkNzLSy1Cx+1Xn0g7HbcM22sfdzMkDQ3vy5JZ/mDFl7NEv4FvEOdv1Y83NbXnZio5ka+6v2+KifT/xkhBCI0tAPfyraQstkg6YUc5uqfUz/5QYJ+Ox8RGooGeBbMZ9XotRxqPEaop45+5r6Mf2sr57dvpee4yYi8vJZdSnO6Gzz1Bsb2M1JwZDvfGfId/mPCMg7++i+4AiXVRsGB3k2svbGB9YvmY2kOHCHGEDxeD299/hbmei8JpT3Y17OJu7/ox/4eMUoU8fkdEBOv3rAzZ0JERBtq8eQBk3FWOdvQcH0BoSOKriXQ8q1ayn4ZdCd4PIkqXQH8LzAE1QMxogLL9y/vqf3zwGxWQ8Pr10PSZA3jVCvkd8zUar0hV1IkollZNtNf95IZdlasECxfDnV1io27Y4fgjdcXYWjmzNdgwZgvaJxv5+VyG3/I0phoEM0ls0eoGuul+HgRcZWpPPEjjVQrJE4U5OkW4ofAkSNw152S2pMu7j+TjRWdc42JPPDgUgwGgUVrVRdCleLmezJxv5hPoMXKunV2inYqUcYXX1Sqw9OmdZ4FCAEZCyXe827yCzVWrBAXOA52Fd+AMsM1XGb4mFfO/bk8/tdShk2YTvD2Ipj3PUBl1vaJdtKvs+H1ellduJpX9OdIPRlEWZ8mxuzbh3HZspb0tvlDZNA0sqWdEzUnCA/ph6GmhmEzF1B15DccPX8U5zCNsz2D2pSqEiIT8Hg83DXsLvTyPP4RfpLrStycSJrCM99dw2t7XifHUorVeYhhlmjk449TPWkclkcf81OLA42BWAdZ0SsvnNfojJV2SRXiKwxfycO8WR49SEp5/vKd0uXHN+Vh3hlcrhazuKNH4blVF/qBXxTV1TBjhn+xdm34kMU/DeXIERVPoppn8nVdKdtCi+acr89it4PbpaTejQU6TZNTOHfPTH7yswhiYgyUlSmNrdWr4bnnoKFekkEm4846GFh3iDMijFGm/ZTdtZTU15cg1mS1rM5SIh1baCgu4W+104kLKGflqFWMTbFQUKB66dOnKzmWVas6yQKkpG55JjuW63wSYuWPNXaWLBXtpY66jCuu53ENF4WrwcXidxcT3WMwcW9txOaKI2BKmqp5ZmVdUINsamri6bynGPeTpxlT4qJu3GiGvL8dYVL74QssW1vXMlNS8D74IKsKn2PrF58wLfZ6bONsPPr3R4kKjeL9Q+9zwn2CWk8t0wanodV7Sf5gLxHFlWg33MwrSSEMDB3A+OyN3L/1LLt61VFqrGbD0puRmpnY3rGUnStj5W0rEUJ0mEl4vV6Ou4+jBWhYAi3UeGquyIzja/Mwl1LWA/Vf5Rj/CmgtiJiW1ix8eAlDow7R/MZqXeIZOxbOnFEN+X79mnsgZrVyClo+OM//0c0rL0t+eFDniIjixrfXEvTSJr438ibWHl6ENVUQGgqPP67m1N7OdpNYqnO8ZxwjjAfo59rHUctIpNOJ+/AJLL66kENN1RadjadnRQkR5kPs7D+NidM0MuxKfSI7WwlAXjQLcCvTp8D4aAbm61yXYqOw0MLx4xcSA7p6q66Vqq48dObD3Xo3PnDBXEzD09Uf0e1Wb3SfD4HNhtQ01uxcw+dlhYwWktIbEhDHjxN5/hSWsP4d+6f7psMHD8aTtwXDQw9xb9I8Hg7QCA0KBZSx1Lqd6yg9W0qQIZBoQxi3bDpMamkT9QdL2Td+EP12fIIYex1/L1nP7eXQMDSWMOcWPr55EPoXn5ARZ2fPyT1Yo6yd+m5IKclyZvHipy8ipSSudxwBxoBLTuVfaR7mFw0eQoh7pJQbunNAIUQkEC2l3PaVzuwqQld2uf6GeVf/5q0ParEoJUVf9LFY/MQdc4jkVJmbvtEaa9YI9DzJgqZMJjXqBJZbib9pISHPr6BPqZOE2lQ2NySxQD5PrDhAXXEVsaYKEv9qQ+sf6j+/ZctgwXwN0zorpTk62SXz0cLrGeEuoudEK1pMeCurvzTqaiXu5flUTJzHuz3T+dUfLET0F34dr0WLYI5NoqECWoczps0RcUKujutWK+ZADa8XnnjiCm16X8NF0dFC1+Gi7hf+bMW8Mpn9A3YkJ/tFEElKArPZ3zMYHDmC3UOLsFYcw2tNwdyzn19XS6/QibREkleex8wRM4kwh0NKCgfeXsfWaMFzr9/EF3VnSBqURPY92RgMBmzjbDjKHfQN6cOoDVuZUVHP+NoGwu+czfFjZ6g97aXWOhG0IG4bP4tDJQ6Sz4ez9bbRPDvhLElRKTye8ji1nhq0hrbv8tb3w93oxlHuwN3gxiu9bKvcxv2j77+ovezF7t23hUtlHiuFEL8AnkNJhXQqQCiEmArMAdKBH6H6IP/06Aqzp7VhVJcauM0HlbpOfaKVoCV2xKJFMGcO0qyR6WtEN+tiReg6tQlWcrfZie/vxpWt8154NENq8gh57zy3lmeys2YYKQ0fs5PxhIkvaJBGgjxuDHibTZdaXlu43YSGarDMzvBHbPR4TmPXLuh5nZu7f6zhrhVoGUoyXpo1XlwNb/adQ81pjQdvEYS3pxAjseRc/CZJBJnSjhMbCTdo/PYewU9/eq3pfTWis4Wus0axD/6av8vVwnjYsgUJNN5zF6bjp6g5ewJzr3B/lpLSrHml9Qona+ca9bOBKTQ2NbL+8/WEhYTx+PuPMyUqldn15zhVcxJLUBx7TxUwKnw0BZUFHHcfJzQoFC1AY9rgaWwr3siC2pHE33Q9gR9vQRw+TP9H/43Q+2di7hXOgebXiZ3/MAF6Aw8WmrjDOI7QmT/GYDBgeSEHqetKf+v7S0CINvcjIyGDtMFplJwpQUrJuIhxVLmqLqpldal7923gUsFjCPA4qjG+QgixFzUQeBJVruoNxAETUeq2DmCGlFL/2s74CkNXmD2dNXA7y1hktYvGjbl85o6nZrlOsbSxYJkFYbHgqlbN5/j4FuaWKS6astd0dh2z8UG1hldYuc+os6dfIvfGOAnoO4zxm3dwNCiakaKUU6Ej6VO9g5NBUUSmP0Kw74RbR8LERLyPLuHZFy3s3gOTk2DRDyysWeO7DoHdbsHthvxtYL3ZwgcfKFXtrKy28UG6lH6XKW4wwmfWHhp64X3MF0QPsZC/DWxzmu9ZniQt0Y1m7iRjaYVrfY4rA50tdB01in07crPJ3FL3b/WBkVOnkndwM7LwHYqH9yF38+OkRk8hIyGjJUupqaG60U3u4Vzie8ezpWILUkruGn4X7+x7hwExA3hj+zpGbTjFqQiN/rtKiRoYxt6TexnRdwQbPt/AtqPbSBmUAhLqg0ycuG4II48eR8ydCzNnIiIisDSzN/wZUr1EPPsoIjaWns7dUFur+n+5uRSFnKXmreUUj/Zyx/A70cvziG5WyrWNs6nm/zhFQdQCtEv2PK5EwcSLBg8pZQ3wSyHEr4HvArcAycAAIBg1+7EP5Tn+hpRy39d7ulceWgeGlJQWj/I2O+92Wk/+/t1qidPhJjFNUzIlQsmXO+w5RG4uJaC+lNNT5uJwasxuXhRzcqC0RHLsoJu7HzRjDLHi2aKztcmKRZNEhEi2hqRzNC6d5Js0QgxZ8HEujQNj2a/djLV2E8JzEne1hjnUSFBQqxP1RcJTp5DLl+P4WLL802UMHyFwOpVLYPtA6bv+3Fw1vhAfp/Sq3OkallChrjNbI+iQle/kv0jfvmB4JZuaOYvQLMJ/n9oHWItFSZh0pJ3VEa742Y5/IVyMTdSajgqK4ZRXnkeTbMJkMLVoOmVk4J51N8ZX30A6nXwxKpZfDyvhvh43tgSkAA0yM/Hm5bE9so6SIWWUni1l7ri5ICC/Mp/kqGQqzldQG2Tgiwkj6PfJfobfNZ9xgz7jlh4DqKquYmvlVuJ7x+MocyCEYEifoaybfJiJ057E8sYGeOwxmDoV5swBTUPU1GDRNAgArFZkXh5148fgMXiwvPQaTSUH6XnmMBXfSeTU889QXPEMaSP64bgFrINT/UHC12sBLplFCCHISMhg5oiZhJvDv/WSFXxFttXVgq+bbeUTAs3JaVm8MjJoNQtx4XNc1ZK3ZmQyvkbnE7OVWR/a0SyCEyUu9s9YjCdyMA37Snj9hkySpof6Zp9Y/H3Jd09lYtquUxVrpWl+Bhnpbhz2bNwb8zFID3HxRgY/lErwUrsKSNUu6tblYCzQMU1O4NALuQSV7sVsMdHn+nGKOWWxKGOep5+G1avxDB1B/v4+/GHoc3x6yMLSpUphoQPiS8v1Z0uCXsrEihoSFHY7Lrdg8WIYElHN5BcycPeLp19dOa8kryJxWltZdp9Lov+euVxK6iQ6Wkk5dErV6tZDr+EbQFeauz6GVaQlkvWfr+e+UfdR5api5W0ryfksR9F2c0pwRfShpqSYtQsmUBdsYlrMNBZNXIRwu5GLF7PdeIwju/N5xZ5McK++ZN6R6X9NX48he1c2+RU6U/sk4AkJ4qVdLwPw8NiHaZANFFUVkTIoBYHw02sXDpmNZ/qNBNbUKa2q5GSkwYDHIDGlpqmybXAw+Y/N4kzhVoqjNW4/35+h429if+E/+MOsKO5al0dQ7FCCjh5n2OsfEh4eq47VzfT4Yj2P9vf6cjbWL8a2ulxOgv/S8DWaW+/Kly+/uPe8hhsrOmUymuQmnRCvm8xM+MkvNIr7WDFVlRN0cxrL11n8i7Rmltw45jhhe/M4ERzNxAYd55YaamoF0wLzmW6L5OYeBcRYBxBcpCNq3KqX8GoodqedlyevxHXvPOoPlBPuOozxZBV1k6eoVbu6WvVZdn1Gw/hEDH3D8KakooVrLFmCf+aiIz1IX2PcbnNji1N6VT6/ZV9Gsa/Swieh04gxlvNBtZWwKCXLXl0NzzyjqMxZWe0+Uz5dl4MH1b9mc6cGXFe16+A/IVrPLHRmDuXLUI5WHyVpUJK/7g+oCe+IePQowdiGnky8bwlJw27EYDCAxC+RXp+USEPpIY6MjWZX9UGm9B5Pzq5sHv37o+R8luPf4S+auIhVdzzH7OTvkX9kG9NjpxPbO5Z6bz3Oo04SIhPISMggfZySQ184YSHf+8sCjpfuwn34AN6TJ6nv25vzuR/wD9enHF/1FHLhQhpnP0DcmxsJPVfHkJJz5Ec0UvzJh+ixAQwfOZWqsbGcP7Cb4uF96Nc3WhEBLrYwdILO5O7bG0p5vd4LDKa+LlxpZlBXLVqXXRIT1eR3TEznfRBh0Rg610rTOp18g5UPXtAodEJMjMCBnTt/YSM8VkMYfI0DicjKZO5uncZJTUSUHUY3pJI41YxmdiOsVgLzdA70TeL4X47iTU4lrVkexBfUjOP5q+QAACAASURBVG/kEPDRRwxoLGNv4HX0kycw3T5TrdoOB95DJezoMZ2GQ+Ucsj/Fw49HkFgr2izoF6PACoumJNVbNXd8Jbv0dEH2K3aec9ioGathOiZISYF162DFChg+3M/E9Huiu12gSRBNTS11KR/nt11dqqPS4DV8u7gUQ6h1Gat1zwNoQ9sNGGGjIRDy//4oMT1iWFO0Bke5g2kx08hY9AOKx0p2nCwka3sDUws/ISe0lOhZ09v0W3zBTErpP3bywGQKjxYS0ysG51Enz+541i8ncvfwuymscnK+ZzB1xjr6GQPZs/NvVA/0EnVOUF1fTdjA/gRs+Av1MYOILTnMm2P74Jk3i99Vfkpk/yEcPOaEm+MZcscUyjynmH3+VAvFvZsskM5Kge2DyswRM7+xxvq14NENXKwh234yvHV5p8NdsBDU2Oz8PtdGn8EaR52CxEQl+29NFYTHWdq+htuN1HUaIwcTUHGIoRueoqeIIPydLMQPVMPF/dRKfvVjM8Mmn2T/2XASa4Q/qDlz3djQCR43jAZ9BwPqTnB2VAoDIyyqMRkXx/G8Eo7tOUR5zDR27I7gvlrR4Xu70/vQyQrup+x+X+B+2OIvT/kcB4cPh+Jild1oWkuccH7s4lcFLxGhuRGHDsHQoeqrkw/etdmOKwtdYQi1XtRb/6y9VIcmJSkDklm++deUNp6grqkOk8FE+th0HkhawAOuB7C881OIHYx1Zyn68UNYh027oLHs9XqZHnMTD0bfSWhYf8XQKs8judcYCo4WEt0rhq1lW7kp5iZGx0zmYK93SXEF8Xl8T373cDyO00WMCgngV1XTGXL0NCI5mcEGA3WzHsFoDeCTYzvxBAkOfHGQtOg0DMKgymCDU9F69lM7S6ez2+lxhyKSXBhUws3h31hj/VrPo4vorMF9scdfivnj9ao1sKAAJk9W090+8c32z5FeiSM9k4EbX8SiQXHKXLKljccPP6rKROVlNC1fydqbcui7X+eLEVbmb7NjMIrmXbzEnJ1J0xYd45QUam6eiRYboTKbzEwaHTqvHLLytx7pqsexTNCsE3fhfbhYY7oLF+57SOsgm5jYUhrz9S+G9q9m9roZxAdUYGish+uvbzFLv9YRv+LR1dmEjh4HXDAhfvaZp9iU/St2xgXzzHV1/Ne0n9EjqAf5lflYB6Uotz5dR1qtuB9J9xss+Y7j9XpJfj4J63u7mXFc47Y5v0LY7dSvfpbAbYVsGdREVgJ8fmovZ+q+4GbLeP64yURwVBz7dm/mNuthGs1BRFoi+ejhTfRoMvobda4AyeK/P8rgHoPZWLKRqJ5R3BR7ExmJGSqj8s2u+MTbli4Fg6GlP9HMGvPZ+XanZ3Gt53GFw+1SzeDFexYT9FImbtfFg65vF3yxv11NDZhMcO+9Ss9w0SLVdG8NXzPa5RZky3Sq+8SwLSgNka8zeDDoWPGUlCGtVlavhr7FOrX9ohl+WqfmpNt/LppFkIWdxXIVWWIRWnwkwmjwZwumzFU0zLOj9Q8lwy6YN6+T+9BK5HHjRtWz8DuHepvnUxYvpm55pvq+9UVI2cYYKytLEQtWrfJ/loCWEuCBKgvHr5+NCA5UXhfBwfDUU9cCx1WCDs2hOkD7DMXV4Gqp2xeuRlZXg8tFD+duREw0CaV1zIyagT3BzpbyLUSFRpFb5uDYQ3chV65E2O3+eZHMHc/xo/ULySxcTenZUiqO7mNKpYHdwedxOz6EEycw5G+jcVAkUyuNDAseyOcn93B37nFufO49aPJiOH6c2Nts9AuPoXdwb0xGU4vEevO/WqAFa5SVkrMlIGB4n+HolTo1nhosARriRLPRVUyMKi/U1LT0K/72fRz/aUMuXozMzCSzcHW3ehbtPVQu8FT5mnCtbNVF+Brce2U0VnQ0bHBJndBLHLOVbAlcOETYTo4Hl9QoqzCQLP7EuZFJ7C3X6DfXjslmw43Gtu/D5BgrA8t0Gr5jVd7hzWg9R6HnqzkKf4lHCESohYwMieeci1f+pLFhgwog7ddpTVNDv7/9rYoHdrtiMW7bBmkJbuY7dXaejm6ZT1naLOrYnKq40+3ourho2bel+iXQQpYiVqBS/dTUL6dVcg3fGroi9te69JIyKAVXsyR6dI/BBK19CU+1g4CJkzFYrczUodo2l7sfeoysnWs49MUh8ivyAZj5xj3MGz8Pe0IGDaufxaBvY1zFNpKCLHwSX0q/3z9I1IARbB20mxn/v70zj4+qPBf/9wlhm5mwkwBVAlG2VtAmWGCi0VawLq1La6stoahoglDx1/aW+rtL27v1urS1SqEEl+KVWHvbX93a3tuLWglmQpTgUltFFklEYkAQTCYsWZ7fH++ZZGYyM5nJMpmQ9/v55DPbe855ZnLOed73WetG4CpYREnNkxyVbcze8hz7P3kmD7/zIhnNaczdd4qDmRmkDx5Kw7/9ANcnprBsxzDKasoomNyxZHpAUS6evdhEdu2vMGajdFf7RdzSAvv2mfPY7W5TmtOGTiKt4rf4513FkJe2UDUCsiecnTLJgNFIpIf5p4FLgGygFXgf2KKqlb0kW0ohHjfTb/SSU+YjvcCLeBK3JYZbdNqdye31n4LLkQdm+ZPPVHz/62ewKGdOTeeV1uvI0VqGNDeieMzMB8i/AMopZv6SQq75uyBnO0EO/WhJd6qc+nkJc0p8XHnKy29GF1NWJh1u7iJw7bVGeZx9tlEaTU0waxaUVbn5ymwvjSU+jkz3UrlNueH6hhAnoXtxIV6vp9OKt+3+izRTL8Vm/522BN94S98oZfXm1bRoCx/U7aGwRknXo6Zq5+23k7ZuHSM9Hhqa/FTsr6BgcgFP/O0JPOkejjcfZ8u+LWh9PbN/U4LnzLP41J56ys4fjvc9GNEyiG23VLLvy3uZctLF8bEZlP1hOX+Z72bIp4dwWA4zY+xMdjT52TdrHF859gl8k4VHtv8Q78F8ivKKKDw3esn04MiuJecuMeOCI1aqq83K2ZkAtSnNmnImzhgDlU/TOn8+uWdfQMX726L6LFKlxlWnPg+nVtUvgUV0TPFV4DXgelXd7Yyfoao7e0HWLtNjeR7dSGHuzFcQ6M8RmGAH8h/W/0I5dm8Jsxt81GYvIG2QsKDVRGi9u6iY6hppy2noTLzWFqX+JyVk/MVHWn6YEPX1aFExVR/lcPiVvdw1tYTrb8kIGdLaCgcPwtixTvjt2zBzpum3Xlnp5LfcqjzyQAODntiEVyqYvnSBscMGlVpBxOoCSwfaKuuOzGbf0X3cu+gesh7+NRIIxxs3ri2BR1VZv309G1/byEH/QRQly53FDefcwKu1O/hS2YeMefVt5k+Yi6Snk37hRUjgonIuRPV6WZ/byj0V91J/sp4pI6cwc9xM5k6ay83n3YQ0NrJyy2qyR02h+lg1665cF98qQBVtaKBhsMkY9pT8EtmxI+KFr6rU+ev47p/+junDPsGukwdYe+U6olXjTXaNqy5X1RWRkcCLmE6BdwLPAPucj6cAVwOrgW0iMhvT7+P3wPgekDv16EY4T2dlTBobjSk0PLy38Fo/r97ro2VGNjNqK5j+p7WMzyxkS6mb6goJmb3HEq+1FX7xYz9zSny4ZmaT6/MhwfaxTZvQvXs4t7YCmZpFweJNDCtabmYLDX5ah7spXCJUVkJuLkyfDhdcAIcOKt/4kp+l33A7GePCsluE5lcqSM/JRioq0J+v5eEThSEtZm1U1AAnwkwn2HyVPzmfLM+Etu5+4RFKAhTmXMPW6jIW5Sxiz9E9/PTSn5LlzmJD1Qbu+tQvGX72OL56/sUs/+Q3EMcBqfX1NL9URvqUHKSsjMLrfsyW6jImjziTw4dq+PdL7zXHBbQ5De+ZXsrf85E3KQ9XuivsK0RYAaiiJSW88+wveXJ0HQDXHsli+qVfQ4qKOsyWRIQsdxb52RcYhTA5P6a/IpVqXHXmML8TU7MqV1XvVdWdqnrS+dupqvcA52O6CT4FPAe82RVBRGSMiGwWkV3O4+go4/5HRI6KyO+7cpy+orMktmifezJdyNxcBu3fR+s8L5k5HtJGeCheLh2S9aDdN93a2p5PF0gc/8l6N6+5vDS+Xc3JvKCD+P20+ip49thF1B6APzQUMHRHBeJvQEtKaCpawbF7Syh/SZkwwVzH554Lhz9UbtUShn57Be7SEtNil/Z8D6kxX8YvHqfFrCno6Pcn4Qe3pC7BURNByXIRHexpaSaaIvhkd7b3fOt7FFcJNcequSj7IiZ4JpCWlsbiOYuZOjqH/Fmfp+JAJf6hxkasqpS8vYlN7j3UPV2K7t2L5zdPc3F2AbOe3MrqX1WTVfo04jTDkVtvpWjrceZOyGVH7Q427NjQ5sAOT85rs+D4/TS/VMabw+uZ/fZRZr99lL+6Gmje/rKZIUYg3sACaFew1ceq+7zGVWc+j2uBu1S1OtoAVX1XRO4GfgKUAjd3UZY7gedV9S4RudN5/b0I4+4FXEBxF4/TJ3SWxCZiajkVXuPHnRnUwObBDWTW7KBi9FyO5xdREJQ7ET57D1yT5eXGN5eebhTR8ePm/eEu4T5/Md8uLuS8m9wMRczKwu2mfraXlifLeWvUAlr2f0D9zV5GKLyz0cffGrIZ/CcfJ04U8voRD5ddZsr9HD/k58A1Pv7YmM2sd31MX1yIZHg6fFk3Yjv7WdqJsQyP6GAPP9md7SU7mwv37WPmHT9kfObUtpuuZ4iHi6Zc1CHXoeFUA2U1W5n5hQL2/O23jLmggCEVFRRfczfNDS+R/ukcE+p71VW0/PIRBr1/gNbNmxlz1VSyCy8Lmek3nGpoK8QYsgJwu0m/oIBznt3DkzNHAXDtRxmkLyzocOKHr1ziWUFEy/foCzpTHtlAVRz7qQJUVZd0Q5argYud549izGUdlIeqPi8iF4e/3x+IafVyMsg9YU2/m8t8vNWYzblSxdqtjdR92RM14ChwTU6aZNofXHedieRqbW1PxCsqFk4N8VBUbFqDLF/uOPq+U8yzrxSy5RUX+Rf4uboI/Ljx4eWcFh+b/F6mnuvmnV1mfw89BIu/bj7P1TJ8WsAncLfHnwV9WaHz7G9bEXcAEVYFU10u07s8jpuhquIfrLid7bee0cLDvh+SN2kut3/mdtLS0sz5NmMxhbNNrkcg92HTG5vY+9Fe9rTuJt87l/T9tcbBmJlJy4J5pFdWoV4vD7/zBJ89spesjz7m1NB0pu46yJYPdpN71nyGDxpO/cl6Hnv9MXYf2W0KMZ67tH0FIIIUFzN98WJWDjarEU+TtJnNgr9HV30XqdKutjOzlR8YE8d+RgNHuylLlqrWAjiPmd3ZmYgUich2Edl+6NChbooWRFDOQo/uL9DDIND0u6gINm0i/UIvs9zVvDrcS6O4Wb06rCxOkDyBa/LAAdM358ABk3x40UXGyf3Nb5ougT/6Ebz4ojlMQ4PZTdog4aEnPCy/TfhsbSm7L1uJq3QDJ5YUsWbWWnbMXMwHH5hM8ZkzjagAOTlKg1/JydGYKwoRc8/w+zv+dFGsGF3+KVXDX1hSisDKdN06tKiIkh0b4spraDMV/XElJXlK/U/vYn1eK4caP+SBygd4oPJ+9OOPoaQEWbkSzy9L2yJ8Gk41UFZdxueyP0cryvpc5ZFb8mi99VZKXn2QoonbefiWXBpu/DplR17l9ctz+WiYMrgVWlWZdua5VB2oYslTS7j1mVu5t+Jejjcdp7m1matnXB0QsO2CkowMMoaNIGPYCCQjo8OMKFqtqv5EZ8rjZUyDp874hjM2JiLynIi8GeHv6niETQRV3aCqc1V17vjxPeS/76m7XKT9lZaaZI69e81nZ50FFRVI4WKmb17HFU8Vkz64PT/C7+8oj6AUF5se5I891l4JAYzJ+JZb4OWXobkZPvwQPvgg9CscPw67XvPz6eM+3vJn01zmo7XeT8F7pTw4ZAUbZt9P1vhWXnjBiOoRPwWDK5j7lbNZQEVMZ0asny7citEVn0jI/tcbp2WP/Z8sPY+zMvU3N8Z3E1XF/1Gd6YsxMpvy93w8suu/2H1kD9sPbGf6mGmM2PgEzbcuM7OiyZPbTiZVpfSNUt49+i6b393Mh40f8tbht3lo1xPUNR40xx81hbLDO0AE7+R8/jhvDNWzJvHk/JF83OLnv1//f4wdPpbK/ZVM8Eyg/mQ9AIcbD/Od//2OSWYMP+diTGBSyXfRVTpTHj8DviQiPxaRIeEfisgQEfkxcA1wX2cHU9WFqnpOhL+ngTonLDgQHnww8a/Ty/TEXS7C/nRyNk1lPnRxIbq+hBM3LEVratoaW0iGaevawaEeQZ6Atej48fborYqK9qq8589qIE2UsWM75tu53ZBXYJzqs1zVbG02WetT3i+nseYwc15cw/dH3c95E2op/HqryXXxetlXVk3pu15KNrkj36dV8dc14CvXNlEDiy3VnqmIG/xTVJWZ5lM99n+y9A6quE8q3jMWxL6JOjMD9/9ZzbJXWqg+uo/ciblUvl/JoqmLmDJqCpm4yd8vpJ893Wyzd2+bSazOX4dvv4+FUxcyZdQUxg4fS5qYW1/4TdwzxENxbhE/u/xn5F3/LaacHE7z/HlUNx3if9/4HWOGjebDxg9ZlLOIGeNmkOnO5KzRZ1G1q4zml8oIOcFjTGAScZKnKvHkefw98K+Yxk+bCQ3VXQSMBX6gqv/WLUFE7gUOBznMx6jq6ihjLwb+TlW/EM++ezTPoyc7DgXC+jb68OHl5NJiFKHCZxL5lq0KTfTr4BeIII9icihcw5VH1vgpq3LjzReKblXKCkvwb/bxXKOXR4cWc+nnhccfN/sK1JpqW9H4/az4rpvDh2H+y/ezijUczZyGq2YnQ4fBiM8vQDZtosEvfKvIz4Sz3CE5JyFCr1+PlpVRRgEPpy/Hm2/qbQUXyIXu+TxCfgqnPa/YzlCpS9A/LLgWVXDIa9sJ4fe3NWvR6moa7rubTXuf4tHXHwVg6ZylFM5ZjGfj4+Z/vmABFBaibjclOzaENpv6xALSGo/z50MvU+D0BVFVDjYeJHP4eNIaG6HUaSN7fi6ls5UXDlUy++ltXPqBh9fPcnPFj58i052Fv8lP6RulpvBhUG2tNp/lypUhDWbUySrvzLeTKkmAEDvPI67CiCLyWUw+RwEw3Hn7OKbt7L2q+kIPCDkW+C9MrkgN8BVVPSIic4HlqnqLM24rMBNTG+QwsExV/xRr3z3aDKqHPbsN9dp2892z19xUzz47gYZGQfK0qrBmDVRtV5a1lHDhIB+n5prEPP9BPzsWrOBvDdmMPFbNj6euY3quhw0b2ptYNTebboD5+U6y3xo/z29zM+8zyqq0NchLW9E/b0FmzkA+qIXycjRrQmx9Wl8PixaZWj4uF/4nN6OejPDrqkfyPkL+NVgPfEoTq3tX+KSoqCikTHXDTYvbihDuPbqXki+UmK58gSzWzExIS4ucdFj6NPh8nAzvL15TzrJXWijYp/Duu+z45Gga977D2//8Ta7/1PXULr2Wt4Y3Muu4m+lPbDZ+DMJu9NB+zkHIdwj4drpSJDKiQk3SOd3twoiq+mdVvRwYAUwAJgIjVPXynlAczjEOq+olqjrNeTzivL89oDic1xeq6nhVHa6qZ3SmOHqceCoeJoDbI+Rd5KG6RigoMBFQCZlvHHkU4YEHTJZ6Q52ftEofzZOyGVZlmkK5M920zvdyJtX8JcNL+kg3BQVmFz4fTMhSXi9vYOIExVeunFxTQsGmIi7ZXcLQYYKsWoU88ghply6E99/n1JxcdNz4YN9n7Am+KoL56Tye3mncFPKv6eH/k6WHiWWrDDfHNjaGnGSBIoQ1H9dQkO3UmVI1Cmb1avOoiivdRe7EXPYd3WeSDvEgTojv0MoqGj6qo7a+lhfffZGzBk9AfBWcyj6DUy1NnNz1FkfOm8HWwztoHCpM+8KNXDlsNtO/eKOJnHIIKUIYfM6FXRjx+nYCjvTJIyZTVl1GwyknoqWn/a09gC3JngIETyggxuQixsyjocF04/vwQ3j7LeWh80v43HAfErQc0Faloc6Puow5LHANlPyilYa7HmDq4SreGZ/P+FVf58ZfXcr7u/yI282/XriZ+x7KwO1STvzsF9Tf9xDHGtM5cOlNFJQuDzGtRfxyJSUmZrigoF0WuzAY2ARFJpnJD6Ez+A7mWGKXHQ9byejatZTsLMX3no+8iXkmjFfEVH32+dgyqYnv5ezhA38d6kxsllelkb9f2D1jPFsvnEyzaxgttJJGGnMn5bHqU8tIixA5Fd/XTaA8/fYSNr6+EYCl5y5ta7nbF32WbUn2FCeuSXInM4/ARO7IERg3Xnjns8WwNnQ5IGlCxkQPI0YKgWtAUJbWr6HwyBo+NeEw+ZRz/Rf9DBoEbrdw8qQJ+3W54OEH/Oy4fysfHzqJO+0E6RVlNNT5Y0fEBmZgGzaEyiLgcSvit+G0A47AubxypfEvhGdrQ8isXaFDNnfwjF9VaRisaNBKxj+Etpl+VW0Vjc2Nbeei/2f3mFDfUw0c8h/i2ImjaEMDH3zti6y8EnZedzEtHhc//Ow/k0YaR44f5uGtD7Dmr4/QqtqxrW4cYeFRHeRh24qIyZAfNZWFUxdSsb/CrFJSsM+yVR4pREz90Emkl4hJwjvrLPj856Fim+CXOMw2fj/D3qziRPYMRh/ciZyfhycnC1m6lLEFn+LMf1zKsjs8NDZC2XYXLjeMbjpI00f1vDW2gE1PujvI2+FaiqQdU3AZbkkSYeey/+jBjiadoHMmVk5EeO6Hrl0bYtrqEMUlgnt0FgVTLsI12EWaCMVVwn3PnuKcZyqYnTOfWv8HeM9YwNT08cyd8Gnm/e5l7nvmFBkbf8WaygdCc1ISOI879NmIsm0gQ77m45p22eO2DycPqzxSiJj6we1GvV6a9pjGT239WoPu0h638rnPNFBTrfFPTtxuJN9Ldu44Rv7TKi54YpVpErV8OfLggwy7w5il3G4omNtIfWM6fxh/E0fOnsdLUwp54c8SHFJPayvcf7/JXL//fvM68S9r6Y9opFl5JMJm0e5RpnXqPicEN7wAYUg47RleVLXtGCGKZX9FWx2rQJb5uivWUpRbhL/J37aNiLB87nJeWPoCd8//Pl84PIbs2ReytHEamy4tYd0VaymuEtK++U1W/Wwbd2xTxjXC/JoWXt3zEpNHTG5XYt05j6NsG3WVEsVEEffv3sPYZlApRFjVhpCbvyKUaDFVWkieuilWQposUVSEbNjAsh0+Cud6GVoUZ+y4M6ORwkKGBTsgwmqpiMCyVW5OkE/WEz58XMzJwR5q3oX33jNl2V0uWLPGOO1dLiOaCBHb2cb6stYf0v9IqNyGCFpUhP+r1+AelYmkpVGUW8TJ5pNU1VaxYceGkO1DGi29voni3xdTMLmA4rnFHXp4uwe722b04vPh9nopyVN8TnOm4twipLERcbvJGJrBN/JvI/26oQx7eQdygRf1eODoQbS8nKascQz+3dOM/FQes3fvosJ7Bm831vD2u/u58dwbzbEGE/2i7YwY10C8JUiSXaI9GOswTzGi3Tg7RDbe04Bn9YrQJjOrV/eYQy3qDVwVbfBT1+Dmu6tNxvvu3XDffeZwK1eazPWKChNuP2FCDFEiHKSnU2ksySE4LLaz3heRbnj+Jn+n29efrGfRY4vwn/LjHuJm85LNZAzxoA0N+IfQnicSdLE0vbuHFVcoEyacTfXRfWyoncswp4ZVm1I5YwHFM03htZIdG/DVlFPwp7eZsfMwWcPGMm3sdJpOHqfyw9c4fN4Mfp0/kg1XPWjCg80X6vpsR7Wj/L30u3cF6zDvR0Rznnfwl2U6b+zZYx4zM2M61AIWruBS7dGIacYVact4z883h0tLg+99z3RD9HpN5vrll5vHmJOxCF/WWrP6J4mU24jkw+iwfbor6onadoN1bKSyYkVIHavgiyX9ggLyphVQfayagnF5DK2sguxsml8qo+qdLUwbMtHIMFTawmknZkziP2Yd5k/fuoof3JxDw4/+mcHD3QzPmcGYV9/mc5nzQm/QYedxImYkBUp2lhqfTZw9y4PpyzInduWRokSazHRIglu/vj0EdvlyMyjCDEjV1HuqKvPjx82gdGnrVhhpohMtfytcJlWoqwtd8Kxdaz5zuUx4fqKTMbvy6L/EmxkdzdTStn26CwlKCmwP7zbdA8uqyyiYfCHLfafauwyOHWuKugUnGjona1uYb9B+dcECyqrLSNv2Mq0L5lHw75vaEwbf89HU0sTej/YiItw4ZylFVbDr94+y9YwWmm6+icLzlkRs2pSIGSnQRXD15tXdWjn0ZkZ6tzPM+zv9TXnEdQONlaEbPrRe+c2iEuY0+HjyAy9NNxdT+4EpJRKo/hCupMKPD5Fl6o2bvfV5nP7EvOHFOLfbtjupyMqVJrFp5064/XZ01Sr8zY2xb6KBk0sVXbmSpjMmMnh/LRLU3tbf5Ke1tZXlf1hOzqgcaj6u4Z6Fd/NPz36brMwcntv3PDmjcyiYXMDiOYtDlEi8ZqSAkgkpnZJkn0U8WLNVPyMu000Ccd9u/Hjx8R6Tucy9hcPVDXi9ZnUQyTwVKSowmkyJRBDGEQ7ftk+bHH560yFsNZgY53bbdoEyBePGwapV6O23m9Luv7+Nh7fej7a2RjYfBU4ujwfxehmyv9Yk0gba2zr7zxiaQUF2gQmXPcOLa7CbvGkXseeoqXqdMyqHja9vpOjZohBzU7xmpIDpbsqoKQySQdyz6J6UUxydYVceKUjcs/l4p+iq6Pr1tDzyKGlpcOprNzJ0VTH+Rok7abUrK4zwzPnA9nl5cPvtxldisUQknnM7aExDk58Vv7+NL5cdZsxrO5l73e08Om9oe5RVpBtzJ8cIKJ9Nb2yiYn8FC85YwOLZi3n8L49TVlPG3o/2snDqQmo+rglZYcRjRurLKKlEsGarfqY8IEoF3S7Ycto27mFHwgAAFF9JREFUa61HlhdDTg7U1DhVPj0JKYRERAhXNoEio0FWBu64w64uLD2DqvLw1vuZ8f01uM6aweyTI1l5BSbKKo7or2ilTyJFgbkHu0OUSldv/qlUPTcasZSHzfNIUULSLOKZ9ncW9rrAQ3FBgSkZnZcHLlebySlWe9ioMnVCuJlr8WJz2AceMP7NqiozJgnleSx9TRKcWCLCsgtWcfIrYiKqLvCSN609vyOa+Sh8BVCUW8SGoOq3RblFHfJIRISMoRksn7ucJecu6dLNvz8ojs6wyqM/EH4nLiwMvetGUS4hm1UIhT8vwnPiBGzf3lZrSkS6fgOPcVMIz3/yeMxqQ9Uojvz8lCjPY+ltkhg+J2lpDFuxCpaac7IYKOzk5h4eNnzNzGtCXhfOKaQ4r5jCOYVdvtFHWtkEysAXjMtj2QWrkH5ow+1/Eg9EnDuxVldzIs+LusLuulG82R38jvhNH9p4kygieLjb3mo1NwVdsYITD5SY10FEcqSnpRlT1S9+YUNwBwzJTtwJiraI6ZR3CHdwZ7oyOzi8I+2nQzHHKOb/SOP8TX58NeV8uewwM76/hpO/WNMva7vZlUd/QAQtKubhE4WUbXfj3SChN9+AcvH5OJnnZajLlLUOMUu5FCnZZNpz7t1r6onEmvpHmDEq0vZWQa6fm6t8vHo4m8YHfOzUQpbd4QlRCJHMXImYviynAbFq7qQAgdInwSuLeFYa4SuWwjmFEX0qkca5B7spGJfHmNeMf2ZoZZVZLfWzC8OuPPoJ/kahbIeH7CnScQIXUC656yjaXkzJBgkJu/V4QBr9pmbIJZfAmWfC178ee+ofYcYY/FZZlZv62V4ad1ZzZIaXsiq3zQa3dCSRWO4eJJEs7/CVRVdWLK50V8TjRQrdDfhnzv/KKnKbxrWFCvdVgcOuYlce/YTOJnD+RmFLlYdJk6C8vKNbpG0HGzea16WlsHx5W8/zDm6LCAd0E/RWvpBxazE7hxS29UlPsUmlJVXo5nIzUedyMsJgg1cornRXiJM9vKhjUW4R18y8hkxXZvv7Yf6ZQM+SVA/dDcaG6vYjYgWttLYoy27wU1blZt58YdOmsDwKVVOx8FvfMk3Sa2rQtesoKfVE92WGlHgwSia87EikkiU9EVhjs8wt0DVF0NvFAhM5XrzyJ1vmeLEZ5v2cTjOzVTn18xJu3rGCe6eVkD5IaWwM20FJialemJZm2nR6vdQ1uGP7Mp0ZY8DXsWKFCdJyudoqPIRkg8csqJjg97V9oiwQuYhiZ8RdLDDekgfdOF688vdlgcOuYs1WKU7gRlpeDi0tkJ4eYZXg9zO0yodrRjbjd/oouLwQtzto1hLsrKiuRu++h5KnsihfLbS0dF7hJNz9ceIE7NjRUY7OIorjpaf2Y+n/ROzX0QlxOb17MIQ41vHilT9eR30qkTIrDxEZIyKbRWSX8zg6wpjzRKRCRP4qIm+IyPXJlLGHJioJEbiRTpoElZUwcWLkLoPi9ZI7rprzV3lZtsodch2oy21CfAP9nT1Z+CqEKVNg0CDTCqSoqH01EU5wyG9ensnTiLRa6ak2yynYrtnSR0TtqhfHdjGd3j0cQhzteInIH4+jPpVIGZ+HiNwDHFHVu0TkTmC0qn4vbMx0QFV1l4hMAqqAWap6NNa+e8Ln0VelwuNaeQQGRivHXgK+cqUgz8+yVebz4O9SVGTMUfEksLtcscdan4elX2Br/8dFv6htJSI7gYtVtVZEJgIvquqMTrZ5HbhOVXfFGtcTyiOBCug9TvCNO9EeGeFyR+q34febMRMnQm1t59+ttRUOHjT9p/phYqzFYrAzlE7pLw7zLFWtBXAeM2MNFpHPAEOAPUmQrU9NKQGndFpa4qXKg+VesMBE6AYc34FrxuWC5mb47W/No8sVfX+qZtvVq81jisw9LJbEsbX/u0VSlYeIPCcib0b4uzrB/UwEHgNuUtXWKGOKRGS7iGw/dOhQD8jeJ7lO3SZY7sLCyGbexkbj+7juOvMYEqkVhm0Ta0mYZDgLW1tNKHprxNtBv0vA6w8kVXmo6kJVPSfC39NAnaMUAsrhYKR9iMgI4A/AP6rqthjH2qCqc1V17vjx43tE/lScqMRzXYq0r5QirZ7cblOosLa284KF1pltSYhkxF23tpqZUX6+eQxTIPHWobIkRiqZrZ4BljrPlwJPhw8QkSHAk8B/qupvkihbShLvdRkYt3Kleb52bcfV0+LF5v1YUVfQ+QqsLyLSLClMMpaqBw+2hyJWVprXwSJ0IVfE0jmppDzuAhaJyC5gkfMaEZkrIg85Y74KFAA3ishrzt95fSNu3xPvddk2brKyo6wBQdtu+sGKpbS0e5PESMrMKpMBTjKWqpmZMG+eWTrPm2deB4vQgwl41vzVTspEW/Ump0t5knDijTZUhZL1ytBHS/DiY/qNXsQZHByNtWePGXv22dEjyqIeU5WGOj8rvusme4q0RXaVltpoyAFPMqKaOgkB7InmS52VGjkdGjyF01+irSwJEq8TXwSKC/0U5viYvjDbdBOM0POjoMD8xZokRlztOBrFvXoFy1pKqN6neL1mvHWuW5LiLExLgwkTosaOx5WAF2mZHPReLPPXQPSr2PIk/Zx4C5aKx83ggo5lecNb0QIsWRJ9khixuq+jUSQ7m4JqH3n3FOLOMkKlcCsHi6WdSEtqCHnPXdSxJW2AePt7nE5Ys9VAoofMBx12E8N+1ukhbaKWpReJ25QUKQsYOrynbnfE/SWjDHxfEMtsZVceA4keauPXYTfhy5egiybmIW2JCEsvEvcNPRDZsWCBaZgWvEwOWzoHzF/h9MfCht3F+jwsPUNX7No249DSi8QVohscbigSGseeYGZwfyts2F2s8rD0HTbj0NKLxBWiGz6BCSiNAKmYGZwiWJ+HpW+xPg9LL9Kpz8OaTmPSL6rq9iZWeVgslqj0WCCJUVSudBeNzY2nhe/DOswtFoulBwlf0QQ755tbmxkkg8ifnH/aRF1Fwvo8kogt1WGxpBhdKNwYKSEw4Jyf6JlI5f5KJmVMOu3raFnlkSSSUVy0K1iFZhnQdCHiL1IUV8A5f6D+AHkT8zhQf6DbdbRSHas8kkQqRqWmqkKznJ7EU1Qw6YUHuxDxFymKS0Qoyi0ib1IeQwYNIW9SHkW5RaetyQqszyNpRCzr0ceEK7TCwuS11rUMLOJJ2OuTLO0YCa7RN4mcENjY3MiO2h1MHT2VHbU7aGxuPK1LlNiVR5JIxU6ENs3CkiyCTT3lNeXU+es6rC76rO9GF3I5IiUE9mTp9/6ADdUd4Ng0C0syCKwqymvKadEW0tPSO6wuemXlkeQTPDgKC+j3JdptnodVHhZLn6Oq1PnrWL15Ndkjs6k+Vs26K9eFmHbiLWQY17g+TACMqAih383UbD8PS+9gQ7UsCSAiZLmzYpp24qkPFXfvjD6MUulggjvVcNpFp1jlYekaNlTL0gUCzuZ1V67rslkqbt9IHzr1Ovg/TpF64ZbdxEZbWbqGDdWydJFoZc3jJXBjjtSUKexACUdS9RQdIrIg9cItu4n1eVi6hi0oZ+lDutMvvM96jffD6BTrMLfKo3fohxeD5fQkEUf76djxr7ewDnNL72B7HVhSgLgd6PRhLslpSMooDxEZIyKbRWSX8zg6wphsEakSkddE5K8isrwvZLVYLKlDIgqhs0S+7pRHSXpplT4mlRzmdwLPq+pdInKn8/p7YWNqAa+qnhQRD/CmiDyjqgeSLazFYkkN4nagE7vXeHdMWgPRHJYyKw/gauBR5/mjwDXhA1T1lKqedF4OJbXkt1gsfUCi4b/Rckm6Y9IaiOawVLr5ZqlqLYDzmBlpkIicKSJvAO8Bd0dbdYhIkYhsF5Hthw4d6jWhLRZL3xNPcmFndKc21UCrawVJjrYSkeeACRE++gfgUVUdFTT2I1Xt4PcI+nwS8BTwRVWti3VcG21lsVjioV+GAPciKdOGVlUXRvtMROpEZKKq1orIROBgJ/s6ICJ/BS4EftvDoloslgFIdxIYu5v82N9IJbPVM8BS5/lS4OnwASJyhogMd56PBvKBnUmT0GKxWCxAaimPu4BFIrILWOS8RkTmishDzphZQKWIvA5sAX6sqn/pE2ktFotlAJMyobqqehi4JML724FbnOebgTlJFs1isVgsYaTSysNisVgs/QSrPCwWi8WSMFZ5WCwWiyVhrPKwWCyWMAZanaquYJWHxWKxBJFIld6BjFUeFovFEsRArFPVFazysFgsliAGYp2qrmA7CVosFksYp2Odqq6QMrWtLBaLpT8w0OpUdQVrtrJYLBZLwljlYbFYLJaEscrDYrFYLAljlYfFYrFYEsYqD4vFYrEkjFUeFovFYkkYqzwsFovFkjADIklQRA4B1X0sxjjgwz6WIRKpKhdY2bpKqsqWqnKBlS0a2ao6PtIHA0J5pAIisj1apmZfkqpygZWtq6SqbKkqF1jZuoI1W1ksFoslYazysFgsFkvCWOWRPDb0tQBRSFW5wMrWVVJVtlSVC6xsCWN9HhaLxWJJGLvysFgsFkvCWOVhsVgsloSxyqOXEJExIrJZRHY5j6MjjDlPRCpE5K8i8oaIXN+L8lwmIjtFZLeI3Bnh86Ei8mvn80oRmdJbsnRBtm+LyN+c3+h5EclOFdmCxl0nIioiSQmpjEcuEfmq87v9VUQeT4Zc8cgmIpNF5M8i8qrzP70iSXI9IiIHReTNKJ+LiDzgyP2GiOQmQ644ZVvsyPSGiPhE5NxkyRYVVbV/vfAH3APc6Ty/E7g7wpjpwDTn+SSgFhjVC7IMAvYAOcAQ4HXgk2FjVgDrnec3AL9O0u8Uj2yfBVzO89tSSTZnXAZQBmwD5qaCXMA04FVgtPM6M1V+M4wD+Dbn+SeBfUmSrQDIBd6M8vkVwH8DAswHKpMhV5yyeYP+l5cnU7Zof3bl0XtcDTzqPH8UuCZ8gKq+o6q7nOcHgINAxGzObvIZYLeq7lXVU8ATjnzR5P0tcIkkp/9mp7Kp6p9VtdF5uQ04IwlyxSWbw79iJgsnUkiuW4G1qvoRgKoeTCHZFBjhPB8JHEiGYKpaBhyJMeRq4D/VsA0YJSITU0E2VfUF/pck9xqIilUevUeWqtYCOI+ZsQaLyGcwM7U9vSDLJ4D3gl7vd96LOEZVm4FjwNhekKUrsgWzDDM7TAadyiYinwbOVNXfJ0mmuOTCrGqni0i5iGwTkctSSLYfAoUish/4I3B7ckTrlETPxb4imddAVGwP824gIs8BEyJ89A8J7mci8BiwVFVbe0K28ENEeC88RjueMb1B3McVkUJgLnBRr0oUdMgI77XJJiJpwH3AjUmSp+3QEd4L/83SMaarizGz1K0ico6qHk0B2b4GbFTVn4jIAuAxR7beOPcToa+ugbgRkc9ilMcFfS2LVR7dQFUXRvtMROpEZKKq1jrKIaLZQERGAH8A/tFZKvcG+4Ezg16fQUdTQWDMfhFJx5gTYi3xkykbIrIQo5QvUtWTSZArHtkygHOAFx0L3wTgGRG5SlW396FcgTHbVLUJeFdEdmKUySu9KFe8si0DLgNQ1QoRGYYp/pcs01o04joX+woRmQM8BFyuqof7Wh5rtuo9ngGWOs+XAk+HDxCRIcCTGDvrb3pRlleAaSIy1TnmDY580eS9DnhBHe9cL9OpbI5pqAS4Kom2+05lU9VjqjpOVaeo6hSMLbq3FUencjk8hQk0QETGYcxYe3tZrnhlqwEucWSbBQwDDiVBts54BviGE3U1HzgWMD33NSIyGfgdsERV3+lreQAbbdVbfxh/wfPALudxjPP+XOAh53kh0AS8FvR3Xi/JcwXwDsan8g/Oe/+CudmBuYB/A+wGXgZykvhbdSbbc0Bd0G/0TKrIFjb2RZIQbRXnbybAT4G/AX8BbkiV3wwTYVWOicR6Dbg0SXL9ChPR2IRZZSwDlgPLg36ztY7cf0nW/zJO2R4CPgq6BrYnS7Zof7Y8icVisVgSxpqtLBaLxZIwVnlYLBaLJWGs8rBYLBZLwljlYbFYLJaEscrDYrFYLAljlYfFEgURudGplHt2nOOfFZE1vS1XHHIMF5FaEflKX8tiOX2xysNi6QFEpABYBNzV17Ko6nFMocb/EJHBfS2P5fTEKg+LpWf4LvCsqr7f14I4bMSU2ri2j+WwnKZY5WGxdBMRmYTpsfB42PvjRaRERN4RkUYReU9EHheRTiu1isgPRaRDBq+IbBSRfZ1tr6Z895+AW+L+IhZLAljlYbF0n0WYJkgvhb0/BtPj4/9iCgF+F1OcsNwpBtjblAEXJelYlgGGraprsXSf+cABVQ0p7qeqO4E7Aq9FZBCmplMNZqXyZC/L9SqmR0wu4OvlY1kGGHblYbF0n0lEqQorIreJyOsi0gA0YxQHwIwkyBWQaVISjmUZYFjlYbF0n2FAhx4jInI7sA5TFfhLmBat84O26W2OO4/Dk3AsywDDmq0slu5zGJga4f0bgOdV9TuBN0Qk0rhInHDGD1HTCzxAIq2BxziPHyawjcUSF3blYbF0n7eBM50OjMG4MP0Zgrkpzn1WO4/nBN4QkVGANwG5AopqZwLbWCxxYZWHxdJ9yjBmqDlh7/8P8HkR+XsRWSgiP8KsRkIQkYtEpFlEvhH09n8Dx4AHReQLIvJlTOhtQ4Ttd4vI8xHkmge8r6rJ6CBoGWBY5WGxdJ+tmF7XXwx7/18w7XO/hYmsmgN8PsL2ggn1bbseVfUo8AWgFfgv4D+ANcCfI2yf7mwfzpXAEwl8D4slbmwnQYulBxCRHwKLgemaAheViMzDhOfO0lTpeW05rbDKw2LpAURkJKb/+22q+tsUkOdJ4CNVvbmvZbGcnthoK4ulB1DVYyKyhPYIpz7DySh/FXiwr2WxnL7YlYfFYrFYEsY6zC0Wi8WSMFZ5WCwWiyVhrPKwWCwWS8JY5WGxWCyWhLHKw2KxWCwJ8/8BYLOjbkCkflwAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -678,7 +556,7 @@ }, { "cell_type": "code", - "execution_count": 24, + "execution_count": 19, "metadata": {}, "outputs": [], "source": [ @@ -706,7 +584,7 @@ " # add commands to schedule\n", " schedule = pulse.Schedule(name='cr_rabi_exp_amp_%s' % cr_drive_amp)\n", " \n", - " schedule += cr_rabi_pulse(system.controls[0])\n", + " schedule += cr_rabi_pulse(pulse.ControlChannel(0))\n", " schedule += measure_and_acquire << schedule.duration\n", " \n", " schedules.append(schedule)" @@ -714,28 +592,31 @@ }, { "cell_type": "code", - "execution_count": 25, + "execution_count": 20, "metadata": {}, "outputs": [], "source": [ - "cr_rabi_qobj = assemble(schedules, backend_real, \n", - " meas_level=1, meas_return='avg', \n", - " memory_slots=2,\n", - " shots=shots)" + "cr_rabi_qobj = assemble(schedules, \n", + " qubit_lo_freq=qubit_lo_freq,\n", + " meas_lo_freq=[0.,0.],\n", + " meas_level=1, \n", + " meas_return='avg', \n", + " memory_slots=2,\n", + " shots=shots)" ] }, { "cell_type": "code", - "execution_count": 26, + "execution_count": 21, "metadata": {}, "outputs": [], "source": [ - "sim_result = backend_sim.run(cr_rabi_qobj, backend_options=backend_options).result()" + "sim_result = backend_sim.run(cr_rabi_qobj, system_model, backend_options).result()" ] }, { "cell_type": "code", - "execution_count": 27, + "execution_count": 22, "metadata": {}, "outputs": [], "source": [ @@ -750,12 +631,12 @@ }, { "cell_type": "code", - "execution_count": 28, + "execution_count": 23, "metadata": {}, "outputs": [ { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -793,7 +674,7 @@ }, { "cell_type": "code", - "execution_count": 29, + "execution_count": 24, "metadata": {}, "outputs": [], "source": [ @@ -804,14 +685,14 @@ "T1_exps = []\n", "for kk in range(len(t1_times)):\n", " schedule = pulse.Schedule(name='T1_{}'.format(kk))\n", - " schedule |= pi_pulse(system.qubits[qubit].drive) << schedule.duration\n", + " schedule |= pi_pulse(pulse.DriveChannel(0)) << schedule.duration\n", " schedule |= measure_and_acquire << int(t1_times[kk]) + schedule.duration\n", " T1_exps.append(schedule)" ] }, { "cell_type": "code", - "execution_count": 30, + "execution_count": 25, "metadata": {}, "outputs": [], "source": [ @@ -821,30 +702,40 @@ }, { "cell_type": "code", - "execution_count": 31, + "execution_count": 26, "metadata": {}, "outputs": [], "source": [ - "t1_qobj = assemble(T1_exps, backend_real, \n", - " meas_level=1, meas_return='avg', \n", - " memory_slots=2,\n", - " shots=100)" + "t1_qobj = assemble(T1_exps, \n", + " qubit_lo_freq=qubit_lo_freq,\n", + " meas_lo_freq=[0.,0.],\n", + " meas_level=1, \n", + " meas_return='avg', \n", + " memory_slots=2,\n", + " shots=100)" ] }, { "cell_type": "code", - "execution_count": 32, + "execution_count": 27, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dpuzzuoli/Documents/projects/qiskit-aer/qiskit/providers/aer/openpulse/qobj/digest.py:215: UserWarning: Noise models are an untested feature, and therefore may not behave as expected.\n", + " warn(warning_str.format('Noise models'))\n" + ] + } + ], "source": [ - "sim_result_t1 = backend_sim.run(t1_qobj,\n", - " backend_options=backend_options,\n", - " noise_model=noise_model).result()" + "sim_result_t1 = backend_sim.run(t1_qobj, system_model, backend_options, noise_model).result()" ] }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 28, "metadata": {}, "outputs": [], "source": [ @@ -860,12 +751,12 @@ }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 29, "metadata": {}, "outputs": [ { "data": { - "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYsAAAEkCAYAAADeqh2wAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4xLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy8QZhcZAAAgAElEQVR4nOzdd3gVVfrA8e+bRgIpEAIxIYGE3gVCt9FkERBFWZFVVESxgK4rlkUsWBdxXVwRxY74U7GACqwICkRFJEgXQu+h14QQAinv7497gyGkc5Ob8n6e5z73zsyZmfeEcN/MnDPniKpijDHG5MfD3QEYY4wp+yxZGGOMKZAlC2OMMQWyZGGMMaZAliyMMcYUyJKFMcaYAlmyMMYYUyBLFsYYYwpkycKUWyKiRXzd4dyvmYg8KyLfisjubNu93FylYhORXiLyubM+qSJyXESWiciTIhJUwL79RSRWRBJFJFlE4kTk9tKK3ZQPYk9wm/JKRMblsvohIAj4L3Aix7ZvVHW1iDwETAQygC1AFOALeKtqeokFXAJEpArwHnArcBqYC2wG/IEeQHPgIHCdqsblsv8oYBJwFPgcOAsMAiKAV1X1kVKohikHLFmYCkVEdgL1gGhV3ZlHmSZAdWCtqp7Otk95TBYfAMOAlcD1qron2zYBRuJInElAjKpuz7Y9CtgInHJu2+lcXwP4HWgAdFXV30qjLqZss9tQptJR1U2qGqeqp11xPBEJE5HJIrJTRM6KyGERmSkiMbmUvSPrlpiIdHfe/jkpIkki8j8RaVaE816OI1EcB/pnTxQA6vAG8AqO5PifHIe4E6gCvJE9sarqceAl5+K9hY3HVGyWLIy5CCISDSwH7ge2Aa8C84B+wBIR6Z/Hrv2B+Tj+4p8C/AL0BX4SkZBCnv5u5/u7qro/n3IvA2eAASISnm19D+f797nsMzdHGVPJWbIw5uJMAcKBJ1W1p6qOUdVbge6AJ/CRiPjnst/1QB9VHaCqj6pqP2A8UAvHX/yFcbnz/cf8CjmvFFYAkm0fgCbO98257LMfx+2pCBGpWsh4TAVmycKYYhKRCKA3sBuYkH2bqi4BPgOCgRty2X26qi7Ise4d53vHQoYQ5nzfk2+p88tEZFuX1UsqMY99EnOUM5WYJQtjiq+t8/0XVU3LZfvCHOWyW57Luqwv9BpFjKMwvVTE+e5bhONm7WO9YIwlC2MuQtZf3Hm1F2Str57LtpzdesnWE8uzkOc/4HyvW4iyWVcUh7OtK+jKIdD5nlTIeEwFZsnCmOLL+rK9JI/tYTnKudpi53uv/Ao5u8Jm9cxakW3TJud741z2CQOqAQmqmnKRcZoKwJKFMcW3yvl+eR5Pf3d3vq8sofNntXHcJSKh+ZR7BEcX2Y2qmj2WrNtkfXLZ55ocZUwlZ8nCmGJS1QTgBxxPgD+UfZuIdAL+huMZiK9L6PyLgak4GtHnOBvczyMi9wKP43ha/aEcmz/E0aV2lPMBvax9agBPOBenuDpuUz6V27FwjCku53MM/862Kuu5hvdFJKsxd7yqbizE4e4FfgVeEZHeOBquI4G/ApnAMFU96ZrI8zy/N3ALsElE5uIYwqQajiubls44HlTVedl3VNUdIvIo8DqwXERyG+7Dnt42gCULUzn5A7kNlHdbts9TcQyFkS9V3S4i7YEncTxU1w1Hg/D3wIuq+vvFBlvA+c8At4rIRzge0usKDMCRQMBRh1tVdUUe+09yDnfyCI76ewDxOJ4b+agkYzfli40NZUwFJCJ1gDgcPZ2uVtWlbg7JlHPWZmFMBaSqe3EMKQIwV0Rye9bDmEKzKwtjKjARuQpH28URYLLaf3hTTJYsjDHGFKhCNnCHhIRoVFRUsfY9deoU1apVc21AZZzVuXKwOlcOF1PnFStWHFHVWrltq5DJIioqiuXLcxt6p2CxsbF069bNtQGVcVbnysHqXDlcTJ1FZFde26yB2xhjTIEsWRhjjCmQJQtjjDEFqpBtFsYYU1LS0tJISEggNTXV3aHkKigoiA0bNuRbxtfXl4iICLy9vfMtl50lC2OMKYKEhAQCAgKIiopCRAreoZSdPHmSgICAPLerKkePHiUhIYHo6OhCH9duQxljTBGkpqZSs2bNMpkoCkNEqFmzZpGvjNyaLETkAxE5JCLr8tguIvK6iGwVkbUi0q60YzTGmJzKa6LIUpz43X1lMZXcJ17Jcg3QyPkaAbxVCjEZY4zJwa3JQlV/Bo7lU+Q6YJo6LAWqO6d7NMaYSishIYHrrruORo0aUb9+fUaNGsWZM2cAePXVV2nYsCFNmjRh3rx5BRyp8Nw+NpRzhq45qtoyl21zcExCs9i5vAB4XFUveDxbREbguPogNDQ0Zvr06cWKJzk5GX9//2LtW15ZnSsHq7NrBAUF0bBhQ5cesyhUle7du3PXXXdx6623kpGRwYMPPki1atW48847GTZsGLGxsezfv58BAwawatUqPD09LzjO1q1bSUw8f3r47t27r1DV9rmdt6z3hsrtxlqu2U1V38E5J3H79u21uI+72/AAlYPVuXIoiTpv2LAh395GJW3BggVUq1aN++6779y6N954g3r16hEeHs6gQYMICQkhJCSExo0bs2HDBrp06XLBcXx9fWnbtvAj15f1ZJGAY4rKLBHAPjfFYowx53l29nri9yW59JjNwwN55toWeW5fv349MTEx560LDAwkKiqKuLg4rrvuunPrIyIi2Lt3r0vicncDd0FmAbc5e0V1BhJVdb+7gzLGGHdR1Vx7M6kquTUruKrnlluvLETkMxxzFoeISALwDM65g1V1CvAdjnmNtwIpwDD3RGqMMRfK7wqgpLRo0YIZM2acty4pKYmDBw8yePDg864kEhISCA8Pd8l53d0baoiqhqmqt6pGqOr7qjrFmShw9oIaqaoNVLVVbg3bxhhTmfTs2ZOUlBSmTZsGQEZGBqNHj2bUqFEMGDCAGTNmcObMGXbs2MGWLVvo2LGjS85b1m9DGWOMyUZE+Prrr/nqq69o1KgRNWvWxMPDg7Fjx9KiRQsGDhxI8+bN6dOnD5MnT861J1RxlPUGbmOMMTlERkYya9YsAJYsWcKQIUNYsWIFMTExPProozz33HMuP6clC2OMKce6du3Krl15TnDnMnYbyhhjTIEsWRhjjCmQJQtjjDEFsmRhjDGmQJYsjDHGFMiShTHGlDN5DVF+9OhR+vXrh7+/P6NGjXLpOS1ZGGNMOaKq3HDDDVx//fVs2bKFLVu2cPr0aR577DF8fX158skn+fe//+3y81qyMMaYcmThwoX4+voybJhjqDxPT08mTpzItGnTUFW6dOmCr6+vy89rD+UZY0xxzf0nHPjDtce8pBVcMz7PzfkNUb5161YaNGjg2nic7MrCGGPKkfyGKC9JdmVhjDHFlc8VQEnJb4jyJk2akJ6eXiLntSsLY4wpR/IbotzPz6/EzmvJwhhjypH8higHaNmyJQ8//DBTp04lIiKC+Ph4l5zXbkMZY0w5k98Q5evWrSMgIMDl57RkYYwx5ZgNUW6MMabMsGRhjDGmQJYsjDHGFMiShTHGmAJZsjDGGFMgSxbGGFPOeHp60qZNm3OvnTt3snz5ch588EEAYmNjWbJkiUvPaV1njTGmnPHz82P16tXnrYuKiqJ9+/acPHmS2NhY/P396dq1q8vOaVcWxhhTAcTGxtK/f3927drFlClTmDhxIm3atOGXX35xyfHtysIYYy5Ct27dLlh30003cf/995OSkkLfvn0v2H7HHXdwxx13cOTIEQYNGnTettjY2ALPefr0adq0aQNAdHQ0X3/99blt9erV495778Xf359HHnmkaJXJhyULY4wpZ3K7DVXSLFkYY8xFyO9KoGrVqvluDwkJKdSVRFlgbRbGGFPBBAQEcPLkSZce05KFMcZUMNdeey1ff/21NXAbY0xllpycfMG6bt260a1bN06ePEnjxo1Zu3atS8/p9isLEekjIptEZKuI/DOX7XVFZJGIrBKRtSJyYdcCY4wxJcqtyUJEPIHJwDVAc2CIiDTPUexJ4AtVbQvcDLxZulEaY4xx95VFR2Crqm5X1bPAdOC6HGUUCHR+DgL2lWJ8xhhzAVV1dwgXpTjxizsrLSKDgD6qepdzeSjQSVVHZSsTBswHagDVgF6quiKXY40ARgCEhobGTJ8+vVgxJScn4+/vX6x9yyurc+VgdXYNf39/QkNDCQoKQkRcemxXyMjIwNPTM8/tqkpiYiIHDx68oO2je/fuK1S1fW77ubuBO7efdM7sNQSYqqqvikgX4GMRaamqmeftpPoO8A5A+/btNbenKgsjNjY21ycyKzKrc+VgdXaNtLQ0EhIS2Lt3r0uP6yqpqan4+vrmW8bX15dLL70Ub2/vQh/X3ckiAYjMthzBhbeZhgN9AFT1NxHxBUKAQ6USoTHGZOPt7U10dLS7w8hTbGwsbdu2dflx3d1m8TvQSESiRcQHRwP2rBxldgM9AUSkGeALHC7VKI0xppJza7JQ1XRgFDAP2ICj19N6EXlORAY4i40G7haRNcBnwB1a3luXjDGmnHHZbSgRqQ/8CKiqNijsfqr6HfBdjnVPZ/scD1zmqjiNMcYUnSvbLLyBKC5soDbGGFPOuTJZbAPKbquPMcaYYnNZsnC2P+xy1fGMMcaUHe7uDWWMMaYcsGRhjDGmQIW+DSUi2wtZtEi9oYwxxpR9RWmz8CD3nk5BQHXn531A2sUGZYwxpmwpdLJQ1ai8tolIQ+B1HAP9/eXiwzLGGFOWuKTNQlW3AjcAdYBnXHFMY4wxZYfLGrhVNRX4AccoscYYYyoQV/eGSgcucfExjTHGuJnLkoWIhAADgT2uOqYxxpiyoShdZ5/OY5MXjjkprsPRM2qMC+IyxhhThhSl6+y4ArYnAS+o6oTih2OMMaYsKkqy6J7H+kzgOLDROT6UMcaYCqYoz1n8VJKBGGOMKbtsbChjjDEFsmSRg83YaowxF3Jl19n6IrJdRLa56pilbfaafTy/NJXUtAx3h2KMMWWKK68ssqZVjXLhMUtVjao+bE/MZNLCLe4OxRhjyhRXJousaVXru/CYperyRiFcUceLKT9tZ/2+RHeHY4wxZYYrx4ZKV9Vdqlqup1btX+cM1f28eXzGWtIzMt0djjHGlAnWwJ3N0aNHefiB+2iw81vW7U3ivcU73B2SMcaUCZYssgkODqZ9+/Z8+cFk6uyNZeIPm9lx5JS7wzLGGLcryhPciEg14H4cExzVAarkUqzcTqsqIjz44IN4eHjw7SevEjGoCv+cUZ3P7u6Mh4e4OzxjjHGbogwkWB1YDDTHMQ5UIJAI+AB+zmLlflpVT09PPv30U3r16sWyb17hJ58gPmsTzi2d6rk7NGOMcZui3IZ6EkeiGA7UcK6bCPgDXYGVOHpENXNlgO7g5+fH7NmzGXLzYC5r14rx321kf+Jpd4dljDFuU5RkMQD4WVU/1GyPOavDUqAv0BQY6+IY3SI4OJhp06Yx8fYrOZt2hkc++sme7jbGVFpFSRaROK4esmSSrc1CVQ8Bc4GbXRNa2VC3ZlX8l7zFl8/fw/TFG9wdjjHGuEVRkkUKkH0cjEQunEL1II6G7wrl5aceJf34PkYMvZn9R5PcHY4xxpS6oiSLPTiuLrLEA1eKiGe2dZcDB1wRWFnSq2cPXnnjbZJ3/cGVfW8gI8PGjjLGVC5FSRY/AVeJSFYf0s+BBsD/RGSkiHwJdAa+c3GMZcLoe+9kwD1j2LpsAbfc83d3h2OMMaWqKM9ZfISjm2wEjquMKUAP4Hqgt7PMrzh6TRWaiPQB/gt4Au+p6vhcytyEY1pXBdao6t+Kcg5X+eKN52mx+zAbq11K8pl0/KsU6TEVY4wptwp9ZaGqK1X1PlXd41xOV9UbgA7AEKALcJWqnijsMZ23sCYD1+DoljtERJrnKNMIGANcpqotgIcKe3xXq+LlyedvTSCxajgT5m5g/fr17grFGGNK1UUP96GqK1T1c1WNU9WijrzXEdiqqttV9SwwHbguR5m7gcmqetx5vkMXG/PFiKlXg9u7RDF5yhQubdOGefPmuTMcY4wpFe4eG6oOjltaWRK4sDdVY6CxiPwqIkudt63c6tG/NKFh5z741a7HjTfeyIoVK9wdkjHGlChx54NmIvJX4C+qepdzeSjQUVUfyFZmDo4hRG7C0V7yC9Ay5+0uERkBjAAIDQ2NmT59erFiSk5Oxt/fv8By646kMz52P0nTH8Ur8yyTJk2iTp3y2Wu4sHWuSKzOlYPVuWi6d+++QlXb57pRVd32wtHOMS/b8hhgTI4yU4A7si0vADrkd9yYmBgtrkWLFhW67MOfr9bIEW9rUPUa2qRJEz1z5kyxz+tORalzRWF1rhyszkUDLNc8vlfd3Z3nd6CRiEQDe3E8/Z2zp9M3OBrQp4pICI7bUttLNco8PNW/GT9tPkTdYS/xYJea+Pj4uDskY4wpEW5ts1DVdGAUMA/YAHyhqutF5DkRGeAsNg84KiLxwCLgUVU96p6Iz1e9qg/PDmhJgk8kJ0LbARAXF0daWrkeeNcYYy7g7isLVPU7cjzIp6pPZ/uswMPOV5nTt9Ul9G4eyqvzN9OoSjK9L7+c2267jffee48/n180xpjyzd29oco9EeH561vi4+XB22tSGDNmDB988AFPP/10wTsbY0w5YcnCBUIDfRnbtxlLtx+jab/hDB8+nBdeeIEpU6a4OzRjjHEJlyULEckQkTMi8pGINHXVccuLwR0i6VK/Jv/6biPjXn6Nfv36MXLkSFauXFnwzsYYU8a58spCAG9gKLBORGa48NhlnojwrxtakZaZybg5G5k+fTpvvfUWbdu2dXdoxhhz0VyWLFTVQ1U9gDY4GqMr3bRyUSHVePjqxvy44SCx25MYMWIEIsLmzZvZsMEmTjLGlF8ub7NQ1bWq+rqqDnL1scuDOy+LpnVEEONmref4qbNkZmZy44030qdPH/bt2+fu8IwxplisgdvFvDw9ePnG1pxISeP5/8Xj4eHBRx99xLFjx7jmmmtITEx0d4jGGFNklixKQLOwQO7r1oCZK/cSu+kQ7dq1Y+bMmcTHxzNw4EDOnDnj7hCNMaZI8nwoT0QWFvOYqqo9i7lvhTGqR0O++2M/Y79ex7x/XMnVV1/Nhx9+yNChQ5kwYQJPPfWUu0M0xphCy+8J7m7FPGala9jOTRUvTyYMas2gKb/x73mbGDegBbfeeivVqlWjTx+3j7JujDFFkudtqKzeTcV4eZZmBcqymHrB3N4lio9+28mKXccAGDhwIH5+fiQmJvLFF1+4N0BjjCkka7MoYY/+pQnhQX48PuMPzqRnnFs/fvx4Bg8ezGeffebG6IwxpnAsWZSwalW8eHFgS7YeSmbywq3n1j/zzDNcddVV3H777SxYsMCNERpjTMGKlSxEJEJEOonIlbm9XB1kedetSW1uaFuHN2O3sWF/EgC+vr588803NGnShIEDB7J69Wo3R2mMMXkrUrIQkd4ish7YBSzBMb9Ebi+Tw1P9mxPk583jM9aSnpEJQPXq1Zk7dy5BQUGMGDEiayZAY4wpcwqdLESkEzAHqA68gWMsqJ+Bd4GNzuXZwHOuD7P8q1HNh3EDWrA2IZEPf915bn1ERATz589nxowZNv+FMabMKsqVxRNAKo75r//uXLdIVe8FWgLPA72Ar1wbYsXRv3UYvZqF8uoPm9h19NS59c2aNSMyMpKMjAxee+01UlJS3BilMcZcqCjJogswS1WzD3DkAY6n8FT1GRxToz7rwvgqFBHhhetb4u3hwT9n/HHBbae4uDgefvhhhgwZQnp6upuiNMaYCxUlWQQBu7MtnwWq5SjzK2AN3Pm4JMiXMX2b8dv2o3z++57ztnXt2pVJkyYxa9YsBg8eTHJyspuiNMaY8xUlWRwCauRYbpCjjDfgd7FBVXQ3d4ikc/1gXvxuAweTUs/bNnLkSCZOnMg333xDly5d2LZtm5uiNMaYPxUlWWzm/OSwFLhaRBoDiMglwI3AFteFVzF5eAjjb2jN2fRMnvpm3QW3ox566CHmzZvH0aNHOXLkiJuiNMaYPxUlWXwPXCUiwc7l/+K4ilglIr/j6BFVC3jNtSFWTFkTJc2PP8jcdQcu2N6rVy+2b99Op06dAIiNjbWutcYYtylKsngbR3tEGoCq/gr8FdiBozfUfuA+VZ3m6iArquGXR9OqThBPf7uOEylnL9ju6+sLwE8//UT37t255ZZbrKeUMcYtCp0sVDVJVeNU9WS2dV+raktV9VPVZqr6TsmEWTGdN1HSnLynXb3yyit58cUXmT59Opdddhm7du0qxSiNMcbGhnK75uGB3HNVfWasTODnzYdzLSMiPPHEE8yZM4cdO3bQvn17Fi2yB+WNMaXHkkUZ8ECPRtSvVY0xM//g1Jm8n6/o27cvy5Yto1atWuzZsyfPcsYY42pFHRvqKhGZIyKHRCRNRDJyednTZEXk6+3Jyze2Zu+J0/x7/qZ8yzZu3JhVq1Zx2223AbB48WJOnz5dGmEaYyqx/GbKO4+I9AO+ATxxPJy3CbDE4CIdooK5rUs9pi7ZSf/W4cTUq5Fn2SpVqgBw8OBBevfuTYsWLZg5cyaRkZGlFa4xppIpypXFOBw9ofqoapSqXqGq3XN7lUyoFd9jfZoSFujLP2esPW+ipLyEhoby6aefsnHjRtq3b8/ixYtLIUpjTGVUlGTREvhcVeeXVDCVnX8VL14c2Ioth5LpPfFnxsxcy9erEth7Iu/bTNdffz1xcXEEBQXRvXt33nrrrVKM2BhTWRT6NhSQDBwrqUCMQ/emtXn1r5fy3R/7mbN2P58tczRk16nuR6f6wXSKDqZjdE2ialY9N6R58+bNWbZsGbfccosND2KMKRFFSRYLcIw8a0rYjTER3BgTQUamsunASeJ2HGXZjmP8tOkwM1fuBaB2QBU6Rv+ZPBrVDmLWrFnnnvJes2YNtWvXJiwszJ1VMcZUEEVJFo8Dy0TkSeBFtbEnSpynh9A8PJDm4YEMuywaVWXb4VMs23GMuB1Hidt+jDlr9wNQo6o3HaKC6RgdTPu61Rl8000kJyczc+bMc0OGGGNMcRUlWTwDrMcxX8WdIrIaOJFLOVXV4YU9qIj0wTHOlCfwnqqOz6PcIOBLHJMvLS9C3BWGiNCwtj8Na/vzt051UVUSjp8mbscx4rYfZdnOY8yPPwiAV/eHSJrxApdfcQVjXnyVJ/8xEh8ve6zGGFM8RUkWd2T7HOV85UaBQiULEfEEJgNXAwnA7yIyS1Xjc5QLAB4E4ooQb4UnIkQGVyUyuCqDYiIAOJCYyrKdx4jbXpfFdd5i2ftP8/xjDzLpi/n0vvNxOjesTaf6wbSNrIGfj6eba2CMKS+KkiyiS+D8HYGtqrodQESmA9cB8TnKPQ9MAB4pgRgqlEuCfBlwaTgDLg2Hga04+EBP7n/oEdb+sY6TZ9J5feEWdAF4ewqtI6rTMToYv5PpxKSmEeDr7e7wjTFllLiz6cF5a6mPqt7lXB4KdFLVUdnKtAWeVNUbRSQWeCS321AiMgIYARAaGhozffr0YsWUnJyMv79/sfYty9LT0/Hy8mL3gcOs3XWYlOoN2XQsg51JmWQoCFAv0IMmNTxoEuxJ4xqe+PuIu8MuMRX13zk/VufK4WLq3L179xWq2j63bUW5sigJuX0bncteIuIBTOT8W2C5co54+w5A+/bttVu3bsUKKDY2luLuWx7cdNNNzJ49m3fffZc377mVlLPpTJ39E6mBkcRtP8qiPSeYt8vxYH6T0ABu7VyXWzvXO9dNt6Ko6P/OubE6Vw4lVeeiDPdRtxDFMoEkVU0q5GETgOxjVEQA+7ItB+B4GDDW+WV1CTBLRAZU1kbui/XGG29w6NAhhg4dyqpVq3j55ZdpXtOTbt0aA3AmPYO1CYks23GMBRsO8tS36/llyxFeGXQpQVXtNpUxlVVRusfsxDHRUX6vXcBxEdknIpNEJKSAY/4ONBKRaBHxAW4GZmVtVNVEVQ1xDi8ShWMqV0sUF6F27dr88MMPPPDAA/znP/+hT58+JCYmnttexcuTDlHBjOzekK/u7crYvs1YuPEQfV//hZW7j7sxcmOMOxUlWUwDfsZx6ygR+An4wvme6Fz/E/AdcBYYiaN3U628Dqiq6cAoYB6wAfhCVdeLyHMiMqDo1TGF4e3tzeuvv84HH3zAoUOH8PTMvVeUh4dw95X1+fLeLojATVN+4+2ftpGZaY/YGFPZFCVZ/Au4FBgPRKpqD1Udoqo9cNxKmuDcPhqoj+N5jHrAmPwOqqrfqWpjVW2gqi861z2tqrNyKdvNripcZ9iwYaxcuRJ/f39SU1OZO3duruXa1q3B/x68gl7NQvnX3I3c+dHvHE0+U8rRGmPcqSjJYjywRlWfUNVT2Teo6ilV/SewFhivqpmq+iywGrjWdeEaV/PycjRbTZw4kb59+zJmzBgyMi4c8TbIz5u3bm3H89e1YMnWo/R9/Rfith8t7XCNMW5SlGRxJbCkgDJLgKuyLS/F0WhtyrjRo0czYsQIxo8fT//+/Tl+/ML2CRFhaJcoZt7flao+Xgx5dymTFmwhw25LGVPhFSVZVMHRGyk/Yc5yWZKxCZLKBR8fH95++22mTJnCggUL6NixIxs2bMi1bMs6Qcx+4HKuvTScV3/YzG0fxHHoZGopR2yMKU1FSRZrgMEi0jK3jSLSGrgJx62nLFHA4WJHZ0rdPffcw8KFC/Hw8MDDI+9fD/8qXrw2uA0TbmzNil3H6fvfX/hli/1TG1NRFSVZPAf44ujh9K6I3CEi1zjf38MxbpMvjqE5EBE/oDfwq6uDNiXr8ssvJz4+niZNmqCqjB49mt9///2CciLCTR0imTXqcmpU9eG2D5bxyryNpGdkuiFqY0xJKnSyUNV5wC1AKo6BAt8H5jjf73SuH+osB+ADDAaecmXApnRkdafdu3cvn3zyCR07dmTYsGEcOHDggrKNQwOYNepyboqJZPKibQx5dyn78pndzxhT/hRpzGpV/RxHN9mhOIbh+AB4DbgNqKuqn2Urm6iq81R1p+vCNaUtIiKCzZs38/jjj/Ppp5/SqFEjJkyYwJkz5xfiL4gAACAASURBVHed9fPx5OVBrXltcBvi9yXR9/VfWLDhoJuiNsa4WpEnOFDVZFX9RFUfUdW7VXW0qv6fqp4siQCN+wUGBjJ+/HjWr19Pjx49eO2110hLS8u17PVt6zD7gcsJD/Jj+EfLeWFOPGfT7baUMeWdzYZjCq1hw4Z8++23rF69Gn9/f86ePctdd93F+vXrzytXv5Y/M+/vym1d6vHe4h38dcoS9hxLcVPUxhhXyHMgQRG5zfnxa1U9mW25QKo67aIjM2VW7dq1AVi/fj0zZsxg6tSp3H///YwbN47g4GAAfL09ee66lnSpX5PHZqyl7+u/8PKNrenbyuYEN6Y8ym/U2ak4hgtfCpzMtpwfcZaxZFEJtG3bli1btvD0008zefJkPvnkE55//nnuueeecw3k17QKo2WdIEZ9tor7P1nJ0M71GNuvGb7eNkufMeVJfsniThxf/Pudy8NKPhxT3oSEhPDmm29y77338tBDD/Hee+9xzz33nFcmMrgqX97ThVfmbeTdX3awfNdxJv+tLfVrVa5JaYwpz/JMFqo6NcfyRyUejSm3WrduzYIFCzh27Bienp4cO3aMf/zjH4wbN47o6Gh8vDwY2685nevXZPSXa+g/aTEvDWzF9W3ruDt0Y0whWAO3cRkRoWbNmgAsX76cr776imbNmjF27FiSk5MB6NkslLl/v4IW4YE89PlqHvtqDafPXjhwoTGmbLmoZCEiA0TkNRH5r4jc6KqgTPnXu3dvNm/ezE033cRLL71E48aN+fjjj1FVwoL8+Ozuzozq3pAvVyQw4I3FbD5oPa+NKcvyTRYicq2I/CwiV+Wy7UPga+BB4AHgCxGZUTJhmvKoTp06TJs2jSVLlhAREcHMmTPPzeXt5enBI39pwrQ7O3I85SwD3ljMF7/vQdVGsDWmLCroymIA0A7HuE/niEh/4HYgBXgBeBzYDlwvIkNKIE5TjnXp0oWlS5cydepUADZv3sydd97J/v37uaJRLb77+xW0q1uDx2as5aHPV5N8xgYqNqasKShZdAR+U9Wc409n9ZQa5pzV7hXgChzjQ93i+jBNeefh4UFQUBAAcXFxfPLJJzRu3Jjx48cT6A0fD+/E6KsbM3vNPq6dtJh1exMLOKIxpjQVlCwuAbblsv5K4ARw7raTqh4A/ge0dVl0pkIaOnQo69evp2fPnowZM4YWLVrw3f/m8EDPRnx2d2dSzqZzw5tLmPbbTrstZUwZUVCyqAEcy75CROoCwcBivfB/8g6gpuvCMxVVw4YN+eabb5g/fz6+vr7ExsYC0Kl+Tb578Aq6NqzJ09+u577/W0ni6dzHoTLGlJ78HsoDx5PbOadFjXG+r8pjH5syzRTa1VdfzZo1azh79iwAixYtYubMmfz7mXHMbFCTCd9v4prXfubOy6P5a/tIgvy83RyxMZVTQVcWfwD9RCT7o7YDcbRXLM6lfDR/PvFtTKF4eXlRtWpVAFasWMGbb75JkyaNSV83j0/v6kBYdT9e+N8GuvxrAWO//oMt1s3WmFJXULL4BMetqJ9E5EEReQNHA/YBYFH2guLoE3k5EF8SgZrK4ZFHHmH16tVceumljBw5kuHX9eChlhnMeeBy+rYK48sVCVw98Wf+9u5S5q0/QEamtWkYUxoKShbvA/NwNFpPBO4H0oG/q2rOx2574mgQ/9HVQZrKpVWrVixYsICZM2dy6tQp1q5dS8s6QbxwbRN+GNWRR//ShJ1HTnHPxyu4csIipvy0jeOnzro7bGMqtHyThapmAv1wzIw3BcczFZ1U9atciocA/wVmuTpIU/mICAMHDiQ+Pp4777wTgI8++ojWTeqz6evXeWdAGFNubUdksB/j526k878W8NhXa1i/z7rcGlMSCmrgzkoYnzhf+ZWbDkx3UVzGAODr63vuc4cOHejfvz9Tpkxh0qRJ9OjRg5EjR/LMtT2Z9ttuvl6VwBfLE+gQVYPbu0bxlxaX4O1pw58Z4wr2P8mUG+3ateOTTz4hISGBF198kS1btvDKK6/QLCyIf93QigUPdGZs32YcSEpl1KeruOLlRUxasIUjyWcKPrgxJl+WLEy5U7t2bZ544gm2b9/OV1857ogePXqUZg3rseDNJ3i+kxfv3RZDo1B/Xv1hM13/tZB/fL6a1XtOuDlyY8ovSxam3PLy8qJOHcd8GBkZGQwfPpzvv/+e7t2u4uGbe3NZ2iq+vSeGIR0jmb/+ANdP/pXrJv/K16sSSLNeVMYUiSULUyHUrl2biRMnsnfvXt599108PT2577778EtL4tnrWvLzI1cw7trmnDydxj8+X8Po2NP8Z/4mDibZM6TGFIYlC1OhVKtWjbvuuouVK1eybt06GjduDMA9d97OtKeGc2/dw3wwtC3RQR5MWrSVy8YvZNSnK1m+85iNQ2VMPixZmApJRGjRosW55c6dO7Nt2zYGD76Job07ELzuc764tSl3dI3i582HGTTlN/pPWswXy/eQmmYz9xmTk9uThYj0EZFNIrJVRP6Zy/aHRSReRNaKyAIRqeeOOE359sgjj7B9+3a+/fZbWrVqxdSpU5n9+Uc82b85S/7ZnRevb0l6hvLYV2vp8q8FjJ+7kb0nTrs7bGPKDLcmCxHxBCYD1wDNgSEi0jxHsVVAe1VtDXwFTCjdKE1F4enpyYABA/j+++/5+OOPeeCBBwD48fvvGH93f66rso73hrSgU3RN3vl5G1e8vJB7Pl7Okm1H7BaVqfQKfCivhHUEtqrqdgARmQ5cR7bxpVQ1+xhUS4FbSzVCUyFFRERQq1YtAPz8/PDx8WHkyJEEBARw22238f6td7LsRFWmL9vNvPUHaRIawNAu9RjQJpxAXxv51lQ+4s6/mERkENBHVe9yLg/FMZzIqDzKvwEcUNUXctk2AhgBEBoaGjN9evEeJk9OTsbf37/gghWI1RlUlQ0bNvDNN98QGxtLrVq1+L//+z/SMmHpvjQW7MlgV1Im3h4QE+rJZeFetAjxxMM5p3h5YP/OlcPF1Ll79+4rVLV9btvcnSz+CvwlR7LoqKoP5FL2VmAUcJWq5vtIbvv27XX58uXFiik2NpZu3boVa9/yyup8vsOHD7Njxw46duxIamoqnTt35vrrr+eyfoP5ZV8Gs9bs40RKGrUDqjCwbR1ujImgcWhA6VagGOzfuXK4mDqLSJ7Jwt23oRKAyGzLEcC+nIVEpBcwlkIkCmMuVq1atc7dojpy5AhhYWE8++yzeDz/PF27duWmfv2IuqIPC3en8/7iHbz983Za1QnixnZ1GNCmDsHVfNxcA2Ncz929oX4HGolItIj4ADeTY9RaEWkLvA0MUNVDbojRVGIRERHMnTuXLVu2MHbsWJKTkxk7ZgyN/NN47/b2TB0YxqBLjpGedpZxs+Pp9NKPjJi2nHnrD3A2PdPd4RvjMm69slDVdBEZhWPODE/gA1VdLyLPActVdRbwCuAPfOmYX4ndqjrAbUGbSqlhw4Y899xzPPfcc+zZs+fcMCPTP3qfyZMnExgYSNerelCtYUeWbWjM/PiDBFfzYcCl4dzYLoKWdQKRctS+YUxO7r4Nhap+B3yXY93T2T73KvWgjMlHZOSfd05ffvllevfuzZw5c5gzZw77Z39DeHg4035cwcyV+5i2YA0f/rqDJpcEMCgmguvb1KF2oG8+RzembHJ7sjCmPKtWrRoDBgxgwIABZGZmsmrVKhISEujZ7BJ6NA2l7j+vJzVD2da4M08tbc2/6rbiquaOq42rm4fi6+3p7ioYUyiWLIxxEQ8PD2JiYoiJiQEgPT2dp556ktmzZ/Pjj3NITf0KH7+q/Hz1XcRu6k2Arxf9W4czKKYO7erWsNtUpkyzZGFMCfH29mbEiBGMGDGClJQUFi5cyOzZs7nhhn74N2jHlJkL+O/f/8GU+h1oEHMlQ/tewY0xEUTUqOru0I25gCULY0pB1apV6d+/P/379z+3LqNzGPFfVGXlz9NY8fM0Vr9fm6cadqDHkPu4pVtr+rYKo1oV+y9qygZ3d501ptK68sorWbF8+bk5OHp07UDGll85ckZ49Ku1NL7lGXrfO47ZS+PJtMmajJtZsjDGzcLDw7nrrruYP3cOiccO88sT1/DVvV2ouutXfnj7WQZ0aUlQVHP63P535v4U5+5wTSVlycKYMsTLywsRoX1UMJuXLWLpsuX87f7R+Hp5Mm/a69x45yiGvLOUJVuP8PrrrzN//nxOnLC5xU3JsxuixpRRIkKnDjF80iEGeIU/tuzkyyWb+D4hmZsnL2TPf/8B6nhKvEmTJnTq1Ik77riD7t27uzdwUyFZsjCmnGjVKIpWjaJ4Ii2DL5fvYVLgTHZtWkeN5F1UP7WL77//nssuu4zu3buzdetW7rjjDjp16kSnTp3o3LmzzclhLoolC2PKGV9vT4Z2iWJwh7p8vaotkxdtY/exFNoM8Kd2TDQZmUpiYiKqyptvvsl//vMfAIKDg/nf//5H586dSUxMxMPDg4CAsj9arikbrM3CmHLKx8uDwR3qsnD0VUwcfCnpmcpDX/7B1RN/Yieh/PTzLyQmJvL777/zxhtvEBMTQ716jlmJ33vvPYKCgmjZsiXDhw/nnXfeYc2aNWRm2uCHJnd2ZWFMOefl6cHAthEMuLQO3687wKSFWxj95RpeW7CZ+7s15IZ2bWnfvj0tWrQgLCwMgJ49ezJu3Dji4uL49ttv+eCDD/Dy8iIpKQk/Pz/mzp1LSkoKnTp1IiIiws01NGWBJQtjKghPD6Ff6zD6trqEBRsOMWnhFsbM/IPXF2zh3qsaEJbxZ5tFmzZtaNOmDeCYJXD79u1s3LgRPz8/AF599VUWLFgAOLr2du7cmV69enHfffeVfsVMmWDJwpgKRkTo1TyUns1q88uWI0xauIVnZq0nqIqwy3s7f+tU97wnw0WEBg0a0KBBg3Pr5syZw+rVq4mLizv3SklJOZcsBg0aREBAAE2aNKFp06Y0bdqU+vXr4+NjEz9VVJYsjKmgRIQrG9fiikYhxO04xnMzlvHidxt4M3Yrwy+P5rauUQT6eue6r6+vL507d6Zz587n1p09exaAjIwMUlJSWLJkCVOnTj23ffjw4bz33ntkZmbyxBNP0LhxY5o2bUqTJk2oWbNmidbVlDxLFsZUcCJC5/o1eayDHwHRlzJ50Vb+PX8zb/+8nWFdoxh2WTQ1CjEVbNZVg6enJ99955iCJjExkc2bN7Nx40aioqIAOHDgABMnTjyXXABCQkIYP348w4cPJzk5mdjYWJo0aUJ0dDReXvY1VB7Yv5IxlUhMvRp8cEcH1u1N5I2FW3l94VbeX7yDW7vU4+4r6hPiX6VIxwsKCqJDhw506NDh3Lrw8HBSUlLYuXMnGzduZNOmTeclkzVr1nDttdcCjpF5GzZsSNOmTRkzZgwdOnQgJSWFs2fPUr169VzPeTI1jY0HThK/L4m9J04TU68GVzQKoaqPfZ2VJPvpGlMJtawTxJShMWw6cJLJi7by7s/b+WjJToZ0rMs9VzbgkqCLm83P09PzXDtIv379ztvWtm1bfvvtt/MSycaNG0lLSwMc7SWDBw8mNDSUqAaNqFknCu/gCAJb9WDnKS92H0v58zwewjs/b8fHy4PLGtR0tNU0Db3o+M2FLFkYU4k1uSSA14e05aFejXgzdhvTftvFJ0t389f2Edx7VQMig10/t0bVqlUvaA85k57BloPJfLF8Dz8fqUrrG0ayZ/sWVu9KIG3lGjJTT9J5zKW0a9GYSxJiWf79F7Ro3owWzZqi/iHsTavK5gOeLNp0mLGso3VEED2bhlI9JQNVrfATS50+m8Gq3cdZuuMYNU9nlMg5LFkYY6hfy59///VS/t6zEW/9tI0vlyfw+e97GNi2Dvd3b0h0SDWXneto8hk27D9J/P5Ex/u+JLYdTibdOQy7n7cXTXsOof+tgTQLC6R5eCAhXmeIuKQ2Hh4efFVlO6k7V7Exfh1z58wiIyMDESE1NZWdx88w6qHRLJo6jx/8gvH0D2Hsa1Np06whj/79fjrXD4aMdHx8fMp1AklKTWPFzuPE7TjGsh1HWZuQSHqm4iEwtFnJ9EizZGGMOScyuCovDWzFAz0a8s7P2/k0bjczViZw7aXhjOzekMahhR8eJCNT2Xn0FPH7ktiwP4n4/Y73g0lnzpW5JNCX5uGB9Gpem+ZhQTQLC6BezWp4euT9RT5o0CAGDRoEOKauPXDgAPv378fHx4fGoT4M6d2FoPTj7Ni5my3bVrNv/TEO/l6ddQHtqebjScp34zkQ/zuRkZHUqxtJZGQkLVq0YPTo0QDs3r2bwMBAgoKCykxCOXbqLMt2HHO8dh4lfl8SmQrenkLriOrcfWV9OkYHE1OvBiuX/loiMViyMMZcICzIj2eubcH93Rry3i/b+XjpLr5dvY8+LS5hVI+GtKwTdF75U2fS2XggiXjnlcKG/UlsOnCS02mOWyJeHkLD2v5c1iCE5uGOK4ZmYYEEF6IXVn68vLyIiIg47ynzYcOGMWzYMABiY2O57LLL2HfwMNuSPfkh/hBfbOiCt1Rn78nDHN26n+Wr/2DV2nXnksXAgQNZuXIl/v7+547drVs3xo4dC8Cvv/5KUFAQkZGRBAYGlkhCOZiUeu6qIW77MbYcSgagipcH7erW4IEejegUHUzbujXw8/F0+flzY8nCGJOnWgFVGNO3Gfde1YAPf93Bh0t28v36A/RoWpu2kdXZcCCJ+H1J7DqWQtagtkF+3jQLC2BIx7o0CwugeXggDWv7U8WrdL7UcvL29qZeRDj1gB5NQ3nx+pdYty+RH+MP8sOGQ2zYn8QxzaTHv2Pp1TyUIfc+zM0n9rN3bwIJCQns2bOH3bt3nzvewIEDOXz4MAD+/v5ERkZyyy23nEsmEyZMICgoiJCQEEJCQqhVqxbh4eF59u5SVRKOnyZuxzHith9l2c5j7DrqaMT3r+JFTL0aXN+2Dp3rB9OyTpDbfo6WLIwxBapRzYeHezdh+BX1+fi3nby/eAcLNx6iXs2qNA8L5IZ2ETQPC6RZeCDhQb5l5vZNbjw8HLduWkdU5+HeTUg4nsLCjYf4If4gH/66g7SM6tSoWovuXXpxZ/NQrmxcC/9sT7x/88037Nmz51wiSUhIODdMSlpaGo8//vgF53z44Yd59dVXOXXqFDExMfgH1QC/QFI9qnE8swoZEW3xjWhBoI9S3+Mo17SLpvulDWjX4BK83ZQccrJkYYwptCA/b0b1aMTdV9YnLUPP+xItryJqVOW2LlHc1iWKk6lp/LLlCD/GH2ThpkPMXLUXH08POjeoSa9mtenZLJSuXbvmeSxvb29SU1M5evQohw8f5siRIxw8eAjPGmF8+OsOflm3k4Neoew8cILM0wfgdBIZpxMZfH8DnnnoSvTEPpo1u5Zvncfz9fUlJCSECRMmMGTIEHbv3s2rr7567ool6+qldevWBAcHl+jPqfz/SxtjSl0VL08qQJ64QICvN31bhdG3VRjpGZms2HWcHzcc5McNh3j62/U8/e16mocF0qt5KL2a1aZleBAeORrjPby8OZjux7IT/izbc5bfd6aTlHoKiKdOdT+GPfVfOtUPpmN0TaJqOromZ2Rk4OXlxclq4cyaNetcojly5AiHDx+mTp06AOzbt4+pU6eSlJR03jlnzpzJwIEDS/RnUwH/uY0x5uJ5eXrQqX5NOtWvydh+zdl2OJkf4w/y44aDvLFwC68v2EJoYBXH1UaDmuw4fIq4HcdYsev4uYb9+rWq0a91GB2jg+kQFUxEjdyfW8ka8iQgIODc0+25yZq46uzZs+ddvbRs2dL1P4CcMZb4GYwxpgJoUMufBlf5c89VDTh26iyLNh7ixw0H+XbVXj6NczSAN70kgJvaR9AxuiYdomtQO6BkniT38fEhLCzs3PwkpcGShTHGFFFwNR9ujIngxpgIzqRnEL8vieiQalSvWnGHaLdkYYwxF6GKlydt69ZwdxglzubgNqY8OZMMaanujsJUQnZlYUxZkpoIJ3Y7X3uc77sg0fn59HFHuWq1oXokBEU63+uev+wblP95jCkiSxbZpZ9FMktmxEZjUHV82Z/Y/eeX/3lJYTecSTx/H++qzgRQF+q0dySCjHRIdJY/8AdsmgsZZ87fzzfoggRS61AS7A1wrK8WAmX4wTlT9rg9WYhIH+C/gCfwnqqOz7G9CjANiAGOAoNVdWeJBLPsba76+UlY6u/4z1Yl0PF+wSu39dX/3Mer4jZymXyoQsoxx5XABQnBmRTOnjx/Hx9/RyKoXhfqdv7zc/VIqF4PqtYs+Es9MxNOHf7zfIl7HOdK3APHd8KOX+DsSVoAxE9w7OPll+PKxJmQspYDwsCjbDw5bMoGtyYLEfEEJgNXAwnA7yIyS1XjsxUbDhxX1YYicjPwMjC4RAKK7MyOqL8RHRYMqScctwRSEyH5ABzZBKlJjmUt4OrDy6+QCcb5qpJj2dsmbimTVB1fyuclgBxJIS3l/H2qBDq+9GtEQfSV2b6QnUnBr8bF/4Xv4QEBoY5XRPvc4049wfIfv6Z9o9A/E0lW7PvXQMqRHMf0gsBwR+znJRTne1AEeBVtVj1Tvrn7yqIjsFVVtwOIyHTgOiB7srgOGOf8/BXwhoiIatawZS4U2YFdUaeI7tYt7zKqcPbUn4kk63XGmUiyJ5nUREeCSTkKx7b/uS4zLf84PH0cr1JyeUY6LHH3r0LpKladM846Xtn51XB8edZsCA16Oq8I6v6ZFPxyHzyuVImAXw2SA+pD0265lzl7ChITnIlkd7aEsgd2/ARJ+4Ds/+XEcYusjN/Kqoy/25dE3wF0c/lx3f1TrAPsybacAHTKq4yqpotIIlATOO9PIREZAYxwLiaLyKZixhSS89iVgNW52JKAXRd/mNLh4n/nxIKLuF8l/N1+KYS/vVTcOtfLa4O7k0Vuf5bkvGIoTBlU9R3gnYsOSGS5quZyLV9xWZ0rB6tz5VBSdXb3cxYJQGS25QhgX15lRMQLCAKOlUp0xhhjAPcni9+BRiISLSI+wM3ArBxlZgG3Oz8PAhaWSHuFMcaYPLn1NpSzDWIUMA9H19kPVHW9iDwHLFfVWcD7wMcishXHFcXNJRzWRd/KKoeszpWD1blyKJE6i/2RbowxpiDuvg1ljDGmHLBkYYwxpkCWLLIRkT4isklEtorIP90dj6uIyAcickhE1mVbFywiP4jIFud7Ded6EZHXnT+DtSLSzn2RF4+IRIrIIhHZICLrReTvzvUVuc6+IrJMRNY46/ysc320iMQ56/y5syMJIlLFubzVuT3KnfFfDBHxFJFVIjLHuVyh6ywiO0XkDxFZLSLLnetK/HfbkoVTtqFHrgGaA0NEpLl7o3KZqUCfHOv+CSxQ1UbAAucyOOrfyPkaAbxVSjG6UjowWlWbAZ2Bkc5/y4pc5zNAD1W9FGgD9BGRzjiGx5norPNxHMPnQLZhdICJznLl1d+BDdmWK0Odu6tqm2zPU5T877aq2svRyN8FmJdteQwwxt1xubB+UcC6bMubgDDn5zBgk/Pz28CQ3MqV1xfwLY7xxypFnYGqwEocoyEcAbyc68/9juPogdjF+dnLWU7cHXsx6hrh/HLsAczB8RBvRa/zTiAkx7oS/922K4s/5Tb0SB03xVIaQlV1P4DzvbZzfYX6OThvNbQF4qjgdXbejlkNHAJ+ALYBJ1Q13Vkke73OG0YHx9gdNUs3Ypd4DXgMyHQu16Ti11mB+SKywjnMEZTC77a7h/soSwo1rEglUGF+DiLiD8wAHlLVJMl70LsKUWdVzQDaiEh14GugWW7FnO/lvs4i0h84pKorRKRb1upcilaYOjtdpqr7RKQ28IOIbMynrMvqbFcWfyrM0CMVyUERCQNwvh9yrq8QPwcR8caRKD5R1ZnO1RW6zllU9QQQi6O9prpzmBw4v14VYRidy4ABIrITmI7jVtRrVOw6o6r7nO+HcPxR0JFS+N22ZPGnwgw9UpFkH0bldhz39bPW3+bsRdEZSMy6vC0vxHEJ8T6wQVX/k21TRa5zLecVBSLiB/TC0ei7CMcwOXBhncv1MDqqOkZVI1Q1Csf/14WqegsVuM4iUk1EArI+A72BdZTG77a7G2vK0gvoC2zGca93rLvjcWG9PgP2A2k4/tIYjuNe7QJgi/M92FlWcPQK2wb8AbR3d/zFqO/lOC611wKrna++FbzOrYFVzjqvA552rq8PLAO2Al8CVZzrfZ3LW53b67u7DhdZ/27AnIpeZ2fd1jhf67O+p0rjd9uG+zDGGFMguw1ljDGmQJYsjDHGFMiShTHGmAJZsjDGGFMgSxbGGGMKZMnCVDgi4iUiKiI/ujGGBHHM7liuiMhLInJaRMKLsE+R6yoib4nIUREJLnqUxh0sWRiXEpEY5xf10jy2/825XUUkOpftfiKSKiIpIlLFxbG94Dzv5YUs3zBbrIV9FerYZZGI1AP+AbylzqeEL+JYdzl/HrfmUeQFHAMePn0x5zGlx8aGMq62Csew0O1FJFBVk3Js74HjgTlxfn4/x/bLgCrAD6p6pjgBqGNu92bAqeLsn80x4Nkc6zyAp3DU4blc9tntfL+K8jfu0DOAN/BKSZ9IVfeKyMfA/SLyiqruLelzmotjycK4lKpmikgsMBDHF+bsHEV64Bi3qDW5J4sezvcFFxlHfoOrFfYYx4Bx2dc5xxR6CshU1XG57Ja177aLPX9pct4OGgLM19Ib6uQj4G7na1wpndMUk92GMiUh64u+R/aVzuHCo53bfwK657LvBclCRKqLyGPimP1ur4icFcfMf9+ISMecB8itzUJEEoCxzsVfst02Ss+5vyvkdh8/+60ZcczKuFhEkkX+v71zC9GqiuL4769ZGZWZmkaaSJFimtYYFaRRWtFFE8sLaUQ3qTQzfAuiwAh8SYrKIsou9mC3hwiJKJ3xUhEFUioa3ZSkbExHM2FLUgAABY9JREFULKzUVg9rH+dwOt983zR+zEytHxw2Z+999t7nfMNes9dae201S3pBUp9Ur0HSKkl7Je1P73lmhX76SVoiaWuyNbTIT0qb1M4h34yHw1hZoR9JWiBpi6Q/0u/wpKSTS+quB55Pt68W1HSDs3pmtoHW8DNBFydWFkE9WJ3SiYX8ibnyfcA0SSPNbAtAmnjGAS344T0Zo3AddxO+UmkBhgJTgGslXWtm1YzZjwNTgfHAclrVRX9VfKJ+TAOux9/lWTyW1e3AUEkP42dRNOGrrvOAG4BhksZaLj5Psvmswb/FWmAVcFJq+31Jd5jZ8hrHlAmX9RXKnwLuxSOWPoefRjgVj3jaC/g9V/dFXIU3GY+K+kWurKiW3ADMlDTiaKwGgzrS2YGx4vpvXsBOfCIekMt7DdiP/5NyLq7Tn58rn5zy3i60dQrQr6SPocBPwJeF/GNSOx8U8h9N+Zd24L2ytg9VqfcD8HUh78707EH8TIIsvwcuQA2fZGcWnns5lV1XyF+fvvH0Qn5fPGjcb/nvX2W8u4E9FcompP6/Avrm8nvjAfmsjXedU6XfRane3M7+m42r7SvUUEG9WIMbsfOqpsuBdWZ2yMw24zH386qqUnuFmbWY2S/FDsxsO/A2MKo9rp5dgBXmKhjA7TzAinS70cyKqqBXUjo2y5DUgDsDrDSzN/KVzWwvbgM4AbcdtUkKad4PF7xl3JbSxantrJ8DwIPV2q9C1mepmi3oOoQaKqgXHwKzcQHwevJOOh1YmqvTCFwpqUeaMDNh8Q+VkqTxwAL8QJ/TgGMLVc6g+xxY9FlJXjb2z0vKMk+hwbm8S1LaV9IjJc8MTGnZaXlF+qd0b4XyC1LaVFK2lo6p8rLDh/q3WSvodEJYBPUiWx1MLKSrc3UagRnA+ZK2A6OBnWa2Ld+QpOn4SWgHcH3+t7iKJRMw43F32+7CvpK8QzWU9crlZWdHX52uSpxYw3gOpPT4CuV9UrqrWGBmf0qqJGRqoXdhDEEXJYRFUBfMbIekb4CzJQ3BJ/UWfB9GxpqUXgFsx9VWZS6zi3EDakOJIBmCC4v/G5lQmWdmz3SwrT3AYVoFUKW+BtLqGACA/FTJvvhv+2/I+vy5zVpBpxM2i6CeZBP/JHzPRVNSNwFH9kL8iAuLtvZXnAVsKhEUPXG9fa0cTmnPdjzTVcl2yHdYUKbfZBMwWH5UZ5HMM+2ykrIJlM8jtX7rESndWG2cQecSwiKoJ5nK6QHgVFpXEnka8QnvqnRfJiy2A8MlDcoyJAnfQT28HePJjOTd3phqZp8AHwMzJN1aVkfSGEm12gIa8Yn9wpKyzP32IaVzvlP7vYHHKrRX67e+GFezratxnEEnEWqooJ5k7qCjc/dF1uA7h4cB26w87MNS3M9/o6S38MllPHAO8C6+r6A941kiaQyuOvnLzCpNeF2dWbhwfUnSQtyNtQU3hI8FRuKT/+4a2noLuB+3fzTmC8xsraRlwD3AZklv0rrPoplyFdJHuOpwkaQBuTpPmNl+OLJrfBy+a/zXGt856CRiZRHUDTNrxv39wSesTSXV8quN0hAfZvY0vst3F+7GORv4HrgIP7i+1vFsSs83A/NwW0hZfKdugZntABpojVU1G7gP95T6DpgLbKmxrXX4bzVHUtm8MB9YiG+quxsXVKvwFeHBkvZ2AzcCW/ENh4vT1SdXbRbu1basljEGnYvMulussyAI6oGkW/A9HVPMrBjT62j3JdzZoRcwOm/LCromISyCIACOTOCf4raLBqvj5CDpJuAN4Boze69e/QRHj1BDBUEAQBIOdwHvAIOqVO8oxwH3h6DoPsTKIgiCIKhKrCyCIAiCqoSwCIIgCKoSwiIIgiCoSgiLIAiCoCohLIIgCIKqhLAIgiAIqvI313qiyw9wN7YAAAAASUVORK5CYII=\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -893,6 +784,13 @@ "plt.title('T1 on Q0', fontsize=20)\n", "plt.grid(True)\n" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { @@ -911,7 +809,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.4" + "version": "3.7.5" } }, "nbformat": 4, diff --git a/qiskit/providers/aer/backends/pulse_simulator.py b/qiskit/providers/aer/backends/pulse_simulator.py index dae26da427..12e803522b 100644 --- a/qiskit/providers/aer/backends/pulse_simulator.py +++ b/qiskit/providers/aer/backends/pulse_simulator.py @@ -9,7 +9,7 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -# pylint: disable=arguments-differ +# pylint: disable=arguments-differ, missing-return-type-doc """ Qiskit Aer OpenPulse simulator backend. @@ -19,8 +19,9 @@ import time import datetime import logging +from numpy import inf from qiskit.result import Result -from qiskit.providers.models import BackendConfiguration +from qiskit.providers.models import BackendConfiguration, PulseDefaults from .aerbackend import AerBackend from ..aerjob import AerJob from ..aererror import AerError @@ -52,23 +53,32 @@ class PulseSimulator(AerBackend): } def __init__(self, configuration=None, provider=None): + + # purpose of defaults is to pass assemble checks + self._defaults = PulseDefaults(qubit_freq_est=[inf], + meas_freq_est=[inf], + buffer=0, + cmd_def=[], + pulse_library=[]) super().__init__(self, BackendConfiguration.from_dict(self.DEFAULT_CONFIGURATION), provider=provider) def run(self, qobj, + system_model, backend_options=None, noise_model=None, validate=False): """Run a qobj on the backend.""" # Submit job job_id = str(uuid.uuid4()) - aer_job = AerJob(self, job_id, self._run_job, qobj, + aer_job = AerJob(self, job_id, self._run_job, qobj, system_model, backend_options, noise_model, validate) aer_job.submit() return aer_job def _run_job(self, job_id, qobj, + system_model, backend_options, noise_model, validate): @@ -77,7 +87,7 @@ def _run_job(self, job_id, qobj, if validate: self._validate(qobj, backend_options, noise_model) # Send to solver - openpulse_system = digest_pulse_obj(qobj, backend_options, noise_model) + openpulse_system = digest_pulse_obj(qobj, system_model, backend_options, noise_model) results = opsolve(openpulse_system) end = time.time() return self._format_results(job_id, results, end - start, qobj.qobj_id) @@ -106,3 +116,11 @@ def _validate(self, qobj, backend_options, noise_model): 'entry to configure the simulator') super()._validate(qobj, backend_options, noise_model) + + def defaults(self): + """Return defaults. + + Returns: + PulseDefaults: object for passing assemble. + """ + return self._defaults diff --git a/qiskit/providers/aer/openpulse/hamiltonian_model.py b/qiskit/providers/aer/openpulse/hamiltonian_model.py index e207f88248..acba05b280 100644 --- a/qiskit/providers/aer/openpulse/hamiltonian_model.py +++ b/qiskit/providers/aer/openpulse/hamiltonian_model.py @@ -11,7 +11,7 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -# pylint: disable=eval-used, exec-used, invalid-name +# pylint: disable=eval-used, exec-used, invalid-name, missing-return-type-doc "HamiltonianModel class for system specification for the PulseSimulator" @@ -19,26 +19,42 @@ import numpy as np import numpy.linalg as la from .qobj.opparse import HamiltonianParser +from ..aererror import AerError class HamiltonianModel(): """Hamiltonian model for pulse simulator.""" - def __init__(self, hamiltonian, qubits=None): + + def __init__(self, + system=None, + variables=None, + qubit_dims=None, + oscillator_dims=None): """Initialize a Hamiltonian model. Args: - hamiltonian (dict): Hamiltonian dictionary. - qubits (list or None): List of qubits to extract from the hamiltonian. + system (list): List of Qobj objects representing operator form of the Hamiltonian. + variables (OrderedDict): Ordered dict for parameter values in Hamiltonian. + qubit_dims (dict): dict of qubit dimensions. + oscillator_dims (dict): dict of oscillator dimensions. Raises: ValueError: if arguments are invalid. """ + # Initialize internal variables # The system Hamiltonian in numerical format - self._system = None + self._system = system # System variables - self._vars = None + self._variables = variables # Channels in the Hamiltonian string + # Qubit subspace dimensinos + self._qubit_dims = qubit_dims or {} + # Oscillator subspace dimensions + self._oscillator_dims = oscillator_dims or {} + + # The rest are computed from the previous + # These tell the order in which the channels are evaluated in # the RHS solver. self._channels = None @@ -48,100 +64,82 @@ def __init__(self, hamiltonian, qubits=None): self._evals = None # Eigenstates of the time-indepedent hamiltonian self._estates = None - # Qubit subspace dimensinos - self._dim_qub = {} - # Oscillator subspace dimensions - self._dim_osc = {} - # Parse Hamiltonian - # TODO: determine n_qubits from hamiltonian if qubits is None - n_qubits = len(qubits) if qubits else None - if not n_qubits: - raise ValueError("TODO: Need to infer n_qubits from " - "Hamiltonian if qubits list is not specified") + # populate self._channels + self._calculate_hamiltonian_channels() + + # populate self._h_diag, self._evals, self._estates + self._compute_drift_data() + + @classmethod + def from_dict(cls, hamiltonian, qubit_list=None): + """Initialize from a Hamiltonian string specification. + + Args: + hamiltonian (dict): dictionary representing Hamiltonian in string specification. + qubit_list (list or None): List of qubits to extract from the hamiltonian. + + Returns: + HamiltonianModel: instantiated from hamiltonian dictionary + + Raises: + ValueError: if arguments are invalid. + """ + + _hamiltonian_parse_exceptions(hamiltonian) - self._vars = OrderedDict(hamiltonian['vars']) + # get variables + variables = OrderedDict(hamiltonian['vars']) # Get qubit subspace dimensions if 'qub' in hamiltonian: - self._dim_qub = { + if qubit_list is None: + qubit_list = [int(qubit) for qubit in hamiltonian['qub']] + + qubit_dims = { int(key): val for key, val in hamiltonian['qub'].items() } else: - self._dim_qub = {}.fromkeys(range(n_qubits), 2) + qubit_dims = {} # Get oscillator subspace dimensions if 'osc' in hamiltonian: - self._dim_osc = { + oscillator_dims = { int(key): val for key, val in hamiltonian['osc'].items() } + else: + oscillator_dims = {} - # Step 1: Parse the Hamiltonian + # Parse the Hamiltonian system = HamiltonianParser(h_str=hamiltonian['h_str'], - dim_osc=self._dim_osc, - dim_qub=self._dim_qub) - system.parse(qubits) - self._system = system.compiled + dim_osc=oscillator_dims, + dim_qub=qubit_dims) + system.parse(qubit_list) + system = system.compiled - # Step #2: Determine Hamiltonian channels - self._calculate_hamiltonian_channels() + return cls(system, variables, qubit_dims, oscillator_dims) - # Step 3: Calculate diagonal hamiltonian - self._calculate_drift_hamiltonian() - - def calculate_frequencies(self, qubit_lo_freq=None, u_channel_lo=None): - """Calulate frequencies for the Hamiltonian. - - Args: - qubit_lo_freq (list or None): list of qubit linear - oscillator drive frequencies. If None these will be calcualted - automatically from hamiltonian (Default: None). - u_channel_lo (list or None): list of u channel parameters (Default: None). + def get_qubit_lo_from_drift(self): + """ Computes a list of qubit frequencies corresponding to the exact energy + gap between the ground and first excited states of each qubit. Returns: - OrderedDict: a dictionary of channel frequencies. - - Raises: - ValueError: If channel or u_channel_lo are invalid. + qubit_lo_freq (list): the list of frequencies """ - # TODO: Update docstring with description of what qubit_lo_freq and - # u_channel_lo are - - # Setup freqs for the channels - freqs = OrderedDict() - - # Set qubit frequencies from hamiltonian - if not qubit_lo_freq or ( - qubit_lo_freq == 'from_hamiltonian' and len(self._dim_osc) == 0): - qubit_lo_freq = np.zeros(len(self._dim_qub)) - min_eval = np.min(self._evals) - for q_idx in range(len(self._dim_qub)): - single_excite = _first_excited_state(q_idx, self._dim_qub) - dressed_eval = _eval_for_max_espace_overlap( - single_excite, self._evals, self._estates) - qubit_lo_freq[q_idx] = (dressed_eval - min_eval) / (2 * np.pi) - - # TODO: set u_channel_lo from hamiltonian - if not u_channel_lo: - raise ValueError("u_channel_lo cannot be None.") - - # Set frequencies - for key in self._channels.keys(): - chidx = int(key[1:]) - if key[0] == 'D': - freqs[key] = qubit_lo_freq[chidx] - elif key[0] == 'U': - freqs[key] = 0 - for u_lo_idx in u_channel_lo[chidx]: - if u_lo_idx['q'] < len(qubit_lo_freq): - qfreq = qubit_lo_freq[u_lo_idx['q']] - qscale = u_lo_idx['scale'][0] - freqs[key] += qfreq * qscale - else: - raise ValueError("Channel is not D or U") - return freqs + qubit_lo_freq = [0] * len(self._qubit_dims) + + # compute difference between first excited state of each qubit and + # the ground energy + min_eval = np.min(self._evals) + for q_idx in range(len(self._qubit_dims)): + single_excite = _first_excited_state(q_idx, self._qubit_dims) + dressed_eval = _eval_for_max_espace_overlap( + single_excite, self._evals, self._estates) + qubit_lo_freq[q_idx] = (dressed_eval - min_eval) / (2 * np.pi) + + return qubit_lo_freq def _calculate_hamiltonian_channels(self): """ Get all the qubit channels D_i and U_i in the string @@ -181,7 +179,7 @@ def _calculate_hamiltonian_channels(self): self._channels = channel_dict - def _calculate_drift_hamiltonian(self): + def _compute_drift_data(self): """Calculate the the drift Hamiltonian. This computes the dressed frequencies and eigenstates of the @@ -197,8 +195,8 @@ def _calculate_drift_hamiltonian(self): # might be a better solution to replace the 'var' in the hamiltonian # string with 'op_system.vars[var]' - for var in self._vars: - exec('%s=%f' % (var, self._vars[var])) + for var in self._variables: + exec('%s=%f' % (var, self._variables[var])) ham_full = np.zeros(np.shape(self._system[0][0].full()), dtype=complex) for ham_part in self._system: @@ -219,7 +217,20 @@ def _calculate_drift_hamiltonian(self): self._h_diag = np.ascontiguousarray(np.diag(ham_full).real) -def _first_excited_state(qubit_idx, dim_qub): +def _hamiltonian_parse_exceptions(hamiltonian): + """Raises exceptions for hamiltonian specification. + + Parameters: + hamiltonian (dict): dictionary specification of hamiltonian + Returns: + Raises: + AerError: if some part of the hamiltonian dictionary is unsupported + """ + if 'osc' in hamiltonian: + raise AerError('Oscillator-type systems are not supported.') + + +def _first_excited_state(qubit_idx, qubit_dims): """ Returns the vector corresponding to all qubits in the 0 state, except for qubit_idx in the 1 state. @@ -231,7 +242,7 @@ def _first_excited_state(qubit_idx, dim_qub): Parameters: qubit_idx (int): the qubit to be in the 1 state - dim_qub (dict): a dictionary with keys being qubit index, and + qubit_dims (dict): a dictionary with keys being qubit index, and value being the dimension of the qubit Returns: @@ -239,9 +250,11 @@ def _first_excited_state(qubit_idx, dim_qub): """ vector = np.array([1.]) # iterate through qubits, tensoring on the state - for qubit, dim in dim_qub.items(): - new_vec = np.zeros(dim) - if int(qubit) == qubit_idx: + qubit_indices = [int(qubit) for qubit in qubit_dims] + qubit_indices.sort() + for idx in qubit_indices: + new_vec = np.zeros(qubit_dims[idx]) + if idx == qubit_idx: new_vec[1] = 1 else: new_vec[0] = 1 diff --git a/qiskit/providers/aer/openpulse/pulse_system_model.py b/qiskit/providers/aer/openpulse/pulse_system_model.py new file mode 100644 index 0000000000..8b26f66069 --- /dev/null +++ b/qiskit/providers/aer/openpulse/pulse_system_model.py @@ -0,0 +1,133 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=eval-used, exec-used, invalid-name, missing-return-type-doc + +"System Model class for system specification for the PulseSimulator" + +from collections import OrderedDict +from qiskit.providers import BaseBackend +from .hamiltonian_model import HamiltonianModel +from ..aererror import AerError + + +class PulseSystemModel(): + """PulseSystemModel containing all model parameters necessary for simulation. + """ + def __init__(self, + hamiltonian=None, + qubit_freq_est=None, + meas_freq_est=None, + u_channel_lo=None, + qubit_list=None, + dt=None): + """Basic constructor. + + Raises: + AerError: if hamiltonian is not None or a HamiltonianModel + """ + + # default type values + self._qubit_freq_est = qubit_freq_est + self._meas_freq_est = meas_freq_est + + # necessary values + if hamiltonian is not None and not isinstance(hamiltonian, HamiltonianModel): + raise AerError("hamiltonian must be a HamiltonianModel object") + self.hamiltonian = hamiltonian + self.u_channel_lo = u_channel_lo + self.qubit_list = qubit_list + self.dt = dt + + @classmethod + def from_backend(cls, backend, qubit_list=None): + """Returns a PulseSystemModel constructed from a backend object. + + Args: + backend (Backend): backend object to draw information from. + qubit_list (list): a list of ints for which qubits to include in the model. + + Returns: + PulseSystemModel: the PulseSystemModel constructed from the backend. + + Raises: + AerError: If channel or u_channel_lo are invalid. + """ + + if not isinstance(backend, BaseBackend): + raise AerError("{} is not a Qiskit backend".format(backend)) + + # get relevant information from backend + defaults = backend.defaults().to_dict() + config = backend.configuration().to_dict() + + if not config['open_pulse']: + raise AerError('{} is not an open pulse backend'.format(backend)) + + # draw defaults + qubit_freq_est = defaults.get('qubit_freq_est', None) + meas_freq_est = defaults.get('meas_freq_est', None) + + # draw from configuration + # if no qubit_list, use all for device + qubit_list = qubit_list or list(range(config['n_qubits'])) + hamiltonian = HamiltonianModel.from_dict(config['hamiltonian'], qubit_list) + u_channel_lo = config.get('u_channel_lo', None) + dt = config.get('dt', None) + + return cls(hamiltonian=hamiltonian, + qubit_freq_est=qubit_freq_est, + meas_freq_est=meas_freq_est, + u_channel_lo=u_channel_lo, + qubit_list=qubit_list, + dt=dt) + + def calculate_channel_frequencies(self, qubit_lo_freq=None): + """Calculate frequencies for each channel. + + Args: + qubit_lo_freq (list or None): list of qubit linear + oscillator drive frequencies. If None these will be calculated + using self._qubit_freq_est. + + Returns: + OrderedDict: a dictionary of channel frequencies. + + Raises: + ValueError: If channel or u_channel_lo are invalid. + """ + if not qubit_lo_freq: + if not self._qubit_freq_est: + raise ValueError("No qubit_lo_freq to use.") + + qubit_lo_freq = self._qubit_freq_est + + if self.u_channel_lo is None: + raise ValueError("{} has no u_channel_lo.".format(self.__class__.__name__)) + + # Setup freqs for the channels + freqs = OrderedDict() + for key in self.hamiltonian._channels: + chidx = int(key[1:]) + if key[0] == 'D': + freqs[key] = qubit_lo_freq[chidx] + elif key[0] == 'U': + freqs[key] = 0 + for u_lo_idx in self.u_channel_lo[chidx]: + if u_lo_idx['q'] < len(qubit_lo_freq): + qfreq = qubit_lo_freq[u_lo_idx['q']] + qscale = u_lo_idx['scale'][0] + freqs[key] += qfreq * qscale + else: + raise ValueError("Channel is not D or U") + return freqs diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 9916f23d4d..994e09025b 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -11,7 +11,7 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -# pylint: disable=invalid-name +# pylint: disable=invalid-name, missing-return-type-doc """A module of routines for digesting a PULSE qobj into something we can actually use. @@ -24,99 +24,106 @@ from .opparse import NoiseParser from .operators import qubit_occ_oper_dressed from ..solver.options import OPoptions -from ..hamiltonian_model import HamiltonianModel # pylint: disable=no-name-in-module,import-error from ..cy.utils import oplist_to_array from . import op_qobj as op -def digest_pulse_obj(qobj_input, backend_options, noise_model): - """Takes an input PULSE obj an disgests it into - things we can actually make use of. +def digest_pulse_obj(qobj, system_model, backend_options=None, noise_model=None): + """Convert specification of a simulation in the pulse language into the format accepted + by the simulator. Args: - qobj_input (Qobj): Qobj of PULSE type. - backend_options (dict): backend simulation options - noise_model (dict): currently not supported - + qobj (PulseQobj): experiment specification + system_model (PulseSystemModel): object representing system model + backend_options (dict): dictionary of simulation options + noise_model (dict): noise model specification Returns: - OPSystem: The parsed qobj. - + out (OPSystem): object understandable by the pulse simulator Raises: - Exception: Invalid options - ValueError: Invalid channel selection. + ValueError: When necessary parameters are missing + Exception: For invalid ode options """ - # Output data object + out = OPSystem() - # take inputs and format into a single dictionary - qobj = _format_qobj_dict(qobj_input, backend_options, noise_model) + qobj_dict = qobj.to_dict() + qobj_config = qobj_dict['config'] - # post warnings for unsupported features - _unsupported_warnings(qobj) + if backend_options is None: + backend_options = {} - # Get the config settings from the qobj - config_dict = qobj['config'] - if 'backend_options' not in config_dict: - raise ValueError('Pulse Qobj must have "backend_options".') - config_dict_sim = config_dict['backend_options'] + # Temp backwards compatibility + if 'sim_config' in qobj_config: + for key, val in qobj_config['sim_config'].items(): + backend_options[key] = val + qobj_config.pop('sim_config') - # Parse config settings - if 'memory_slots' not in config_dict: + # post warnings for unsupported features + _unsupported_warnings(qobj_dict, noise_model) + + # ############################### + # ### Parse qobj_config settings + # ############################### + if 'memory_slots' not in qobj_config: raise ValueError('Number of memory_slots must be specific in Qobj config') - out.global_data['shots'] = int(config_dict.get('shots', 1024)) - out.global_data['meas_level'] = int(config_dict.get('meas_level', 1)) - out.global_data['meas_return'] = config_dict.get('meas_return', 'avg') - out.global_data['seed'] = config_dict_sim.get('seed', None) - out.global_data['memory_slots'] = config_dict.get('memory_slots', 0) - out.global_data['memory'] = config_dict.get('memory', False) - out.global_data['n_registers'] = config_dict.get('n_registers', 0) - out.global_data['q_level_meas'] = int(config_dict_sim.get('q_level_meas', 1)) - - # Attach the ODE options - allowed_ode_options = ['atol', 'rtol', 'nsteps', 'max_step', - 'num_cpus', 'norm_tol', 'norm_steps', - 'rhs_reuse', 'rhs_filename'] - ode_options = config_dict_sim.get('ode_options', {}) - for key in ode_options: - if key not in allowed_ode_options: - raise Exception('Invalid ode_option: {}'.format(key)) - out.ode_options = OPoptions(**ode_options) + out.global_data['shots'] = int(qobj_config.get('shots', 1024)) + out.global_data['meas_level'] = int(qobj_config.get('meas_level', 2)) + out.global_data['meas_return'] = qobj_config.get('meas_return', 'avg') + out.global_data['memory_slots'] = qobj_config.get('memory_slots', 0) + out.global_data['memory'] = qobj_config.get('memory', False) + out.global_data['n_registers'] = qobj_config.get('n_registers', 0) + + if 'qubit_lo_freq' not in qobj_config: + raise ValueError('qubit_lo_freq must be specified in qobj.') + qubit_lo_freq = qobj_config['qubit_lo_freq'] + + # Build pulse arrays *************************************************************** + pulses, pulses_idx, pulse_dict = build_pulse_arrays(qobj_dict['experiments'], + qobj_config['pulse_library']) + + out.global_data['pulse_array'] = pulses + out.global_data['pulse_indices'] = pulses_idx + out.pulse_to_int = pulse_dict + + # ############################### + # ### Extract model parameters + # ############################### - # Parse the hamiltonian - if 'hamiltonian' not in config_dict_sim: - raise ValueError('Qobj must have hamiltonian in config to simulate.') - hamiltonian = config_dict_sim['hamiltonian'] - # Get qubit number - qubit_list = config_dict_sim.get('qubit_list', None) + # Get qubit list and number + qubit_list = system_model.qubit_list if qubit_list is None: - qubit_list = list(range(config_dict_sim['n_qubits'])) - else: - config_dict_sim['n_qubits'] = len(qubit_list) - qubit_lo_freq = config_dict_sim.get('qubit_lo_freq', - config_dict['qubit_lo_freq']) - u_channel_lo = config_dict_sim.get('u_channel_lo') + raise ValueError('Model must have a qubit list to simulate.') + n_qubits = len(qubit_list) + + # get Hamiltonian + if system_model.hamiltonian is None: + raise ValueError('Model must have a Hamiltonian to simulate.') + ham_model = system_model.hamiltonian - ham_model = HamiltonianModel(hamiltonian, qubit_list) # For now we dump this into OpSystem, though that should be refactored out.system = ham_model._system - out.vars = ham_model._vars + out.vars = ham_model._variables out.channels = ham_model._channels - out.freqs = ham_model.calculate_frequencies(qubit_lo_freq=qubit_lo_freq, - u_channel_lo=u_channel_lo) out.h_diag = ham_model._h_diag out.evals = ham_model._evals out.estates = ham_model._estates - dim_qub = ham_model._dim_qub - dim_osc = ham_model._dim_osc + dim_qub = ham_model._qubit_dims + dim_osc = ham_model._oscillator_dims + out.freqs = system_model.calculate_channel_frequencies(qubit_lo_freq=qubit_lo_freq) # convert estates into a Qutip qobj estates = [op.state(state) for state in ham_model._estates.T[:]] out.initial_state = estates[0] out.global_data['vars'] = list(out.vars.values()) out.global_data['freqs'] = list(out.freqs.values()) + # Get dt + if system_model.dt is None: + raise ValueError('Qobj must have a dt value to simulate.') + out.dt = system_model.dt + # Parse noise - noise_dict = config_dict_sim.get('noise_model', {}) + noise_dict = noise_model or {} if noise_dict: noise = NoiseParser(noise_dict=noise_dict, dim_osc=dim_osc, dim_qub=dim_qub) @@ -129,17 +136,24 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): else: out.noise = None - # Build pulse arrays - pulses, pulses_idx, pulse_dict = build_pulse_arrays(qobj) - - out.global_data['pulse_array'] = pulses - out.global_data['pulse_indices'] = pulses_idx - out.pulse_to_int = pulse_dict + # ############################### + # ### Parse backend_options + # ############################### + if 'seed' in backend_options: + out.global_data['seed'] = int(backend_options.get('seed')) + else: + out.global_data['seed'] = None + out.global_data['q_level_meas'] = int(backend_options.get('q_level_meas', 1)) - # Get dt - if 'dt' not in config_dict_sim.keys(): - raise ValueError('Qobj must have a dt value to simulate.') - out.dt = config_dict_sim['dt'] + # solver options + allowed_ode_options = ['atol', 'rtol', 'nsteps', 'max_step', + 'num_cpus', 'norm_tol', 'norm_steps', + 'rhs_reuse', 'rhs_filename'] + ode_options = backend_options.get('ode_options', {}) + for key in ode_options: + if key not in allowed_ode_options: + raise Exception('Invalid ode_option: {}'.format(key)) + out.ode_options = OPoptions(**ode_options) # Set the ODE solver max step to be the half the # width of the smallest pulse @@ -151,12 +165,12 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): min_width = min(min_width, stop - start) out.ode_options.max_step = min_width / 2 * out.dt - # Convert experiments to data structures. - # convert estates into a qobj + # ############################### + # ### Convert experiments to data structures. + # ############################### + out.global_data['measurement_ops'] = [None] * n_qubits - out.global_data['measurement_ops'] = [None] * config_dict_sim['n_qubits'] - - for exp in qobj['experiments']: + for exp in qobj_dict['experiments']: exp_struct = experiment_to_structs(exp, out.channels, out.global_data['pulse_indices'], @@ -185,43 +199,19 @@ def digest_pulse_obj(qobj_input, backend_options, noise_model): return out -def _format_qobj_dict(qobj, backend_options, noise_model): - """Add additional fields to qobj dictionary""" - # Convert qobj to dict and add additional fields - qobj_dict = qobj.to_dict() - if 'backend_options' not in qobj_dict['config']: - qobj_dict['config']['backend_options'] = {} - - # Temp backwards compatibility - if 'sim_config' in qobj_dict['config']: - for key, val in qobj_dict['config']['sim_config'].items(): - qobj_dict['config']['backend_options'][key] = val - qobj_dict['config'].pop('sim_config') - - # Add additional backend options - if backend_options is not None: - for key, val in backend_options.items(): - qobj_dict['config']['backend_options'][key] = val - # Add noise model - if noise_model is not None: - qobj_dict['config']['backend_options']['noise_model'] = noise_model - return qobj_dict - - -def _unsupported_warnings(qobj_dict): +def _unsupported_warnings(qobj_dict, noise_model): """ Warns the user about untested/unsupported features. Parameters: - qobj_dict (dict): Formatted qobj_dict from _format_qobj_dict + qobj_dict (dict): qobj in dictionary form + noise_model (dict): backend_options for simulation Returns: Raises: """ # Warnings that don't stop execution warning_str = '{} are an untested feature, and therefore may not behave as expected.' - if 'osc' in qobj_dict['config']['backend_options']['hamiltonian'].keys(): - warn(warning_str.format('Oscillator-type systems')) - if 'noise_model' in qobj_dict['config']['backend_options']: + if noise_model is not None: warn(warning_str.format('Noise models')) if _contains_pv_instruction(qobj_dict['experiments']): warn(warning_str.format('PersistentValue instructions')) @@ -244,25 +234,25 @@ def _contains_pv_instruction(experiments): return False -def build_pulse_arrays(qobj): +def build_pulse_arrays(experiments, pulse_library): """ Build pulses and pulse_idx arrays, and a pulse_dict used in simulations and mapping of experimental pulse sequencies to pulse_idx sequencies and timings. Parameters: - qobj (Qobj): A pulse-qobj instance. + experiments (list): list of experiments + pulse_library (list): list of pulses Returns: tuple: Returns all pulses in one array, an array of start indices for pulses, and dict that maps pulses to the index at which the pulses start. """ - qobj_pulses = qobj['config']['pulse_library'] pulse_dict = {} total_pulse_length = 0 num_pulse = 0 - for pulse in qobj_pulses: + for pulse in pulse_library: pulse_dict[pulse['name']] = num_pulse total_pulse_length += len(pulse['samples']) num_pulse += 1 @@ -270,7 +260,7 @@ def build_pulse_arrays(qobj): idx = num_pulse + 1 # now go through experiments looking for PV gates pv_pulses = [] - for exp in qobj['experiments']: + for exp in experiments: for pulse in exp['instructions']: if pulse['name'] == 'pv': if pulse['val'] not in [pval[1] for pval in pv_pulses] and pulse['val'] != 0: @@ -285,7 +275,7 @@ def build_pulse_arrays(qobj): stop = 0 ind = 1 - for _, pulse in enumerate(qobj_pulses): + for _, pulse in enumerate(pulse_library): stop = pulses_idx[ind - 1] + len(pulse['samples']) pulses_idx[ind] = stop oplist_to_array(pulse['samples'], pulses, pulses_idx[ind - 1]) diff --git a/qiskit/providers/aer/openpulse/qutip_lite/operators.py b/qiskit/providers/aer/openpulse/qutip_lite/operators.py index 4812b050c1..3badefce16 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/operators.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/operators.py @@ -57,6 +57,8 @@ import scipy.sparse as sp from .fastsparse import fast_csr_matrix, fast_identity +# pylint: disable=no-member + # Spin operators def jmat(j, *args): diff --git a/qiskit/providers/aer/openpulse/qutip_lite/states.py b/qiskit/providers/aer/openpulse/qutip_lite/states.py index 3bfd4f4a2d..6bb9534273 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/states.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/states.py @@ -50,6 +50,7 @@ """ import numpy as np +# pylint: disable=no-name-in-module from scipy import arange, conj import scipy.sparse as sp diff --git a/qiskit/providers/aer/utils/__init__.py b/qiskit/providers/aer/utils/__init__.py index 8f1024d3bd..133948e85b 100644 --- a/qiskit/providers/aer/utils/__init__.py +++ b/qiskit/providers/aer/utils/__init__.py @@ -14,4 +14,3 @@ from . import qobj_utils from . import helpers -from . import pulse_sim_utils diff --git a/qiskit/providers/aer/utils/pulse_sim_utils.py b/qiskit/providers/aer/utils/pulse_sim_utils.py deleted file mode 100644 index a60dab4650..0000000000 --- a/qiskit/providers/aer/utils/pulse_sim_utils.py +++ /dev/null @@ -1,33 +0,0 @@ -# This code is part of Qiskit. -# -# (C) Copyright IBM 2018, 2019. -# -# This code is licensed under the Apache License, Version 2.0. You may -# obtain a copy of this license in the LICENSE.txt file in the root directory -# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. -# -# Any modifications or derivative works of this code must retain this -# copyright notice, and modified files need to carry a notice indicating -# that they have been altered from the originals. - -""" -Helper functions for the pulse simulator -""" - -from ..openpulse.qobj.digest import digest_pulse_obj - - -def lo_from_hamiltonian(qobj=None, backend_options=None, noise_model=None): - """Digest the pulse qobj and determine the qubit_lo_freq from the hamiltonian""" - be_options_copy = backend_options.copy() - be_options_copy['qubit_lo_freq'] = 'from_hamiltonian' - openpulse_system = digest_pulse_obj(qobj, be_options_copy, noise_model) - - return openpulse_system.freqs - - -def get_dressed_energies(qobj, backend_options=None, noise_model=None): - """Digest the pulse qobj and return the eigenenergies - of the Hamiltonian""" - openpulse_system = digest_pulse_obj(qobj, backend_options, noise_model) - return openpulse_system.evals, openpulse_system.estates diff --git a/test/terra/backends/test_pulse_simulator.py b/test/terra/backends/test_pulse_simulator.py index 2d0d86ba27..872cbfe7c5 100644 --- a/test/terra/backends/test_pulse_simulator.py +++ b/test/terra/backends/test_pulse_simulator.py @@ -18,6 +18,7 @@ import numpy as np from scipy.linalg import expm +# pylint: disable=no-name-in-module from scipy.special import erf import qiskit @@ -26,9 +27,13 @@ from qiskit.compiler import assemble from qiskit.quantum_info import state_fidelity -from qiskit.test.mock.fake_openpulse_2q import FakeOpenPulse2Q -from qiskit.pulse.commands import SamplePulse, FrameChange, PersistentValue +from qiskit.pulse.channels import (DriveChannel, ControlChannel, AcquireChannel, MemorySlot) +from qiskit.pulse.commands import SamplePulse, FrameChange +from qiskit.providers.aer.openpulse.pulse_system_model import PulseSystemModel +from qiskit.providers.aer.openpulse.hamiltonian_model import HamiltonianModel + +# pylint: disable=missing-return-doc, missing-return-type-doc, invalid-name class TestPulseSimulator(common.QiskitAerTestCase): r"""PulseSimulator tests. @@ -46,375 +51,94 @@ class TestPulseSimulator(common.QiskitAerTestCase): """ def setUp(self): """ Set configuration settings for pulse simulator """ - # Get a pulse configuration from the mock real device - self.backend_mock = FakeOpenPulse2Q() - self.system = pulse.PulseChannelSpec.from_backend(self.backend_mock) - self.defaults = self.backend_mock.defaults() - - # define the qubits - self.qubit_0 = 0 - self.freq_qubit_0 = self.defaults.qubit_freq_est[self.qubit_0] - - self.qubit_1 = 1 - self.freq_qubit_1 = self.defaults.qubit_freq_est[self.qubit_1] - - # 1q measurement map (so can measure the qubits seperately) - self.meas_map_1q = [[self.qubit_0], [self.qubit_1]] - # 2q measurement map - self.meas_map_2q = [[self.qubit_0, self.qubit_1]] - - # define the pulse time (# of samples) - self.drive_samples = 100 - - # Define acquisition - acq_cmd = pulse.Acquire(duration=self.drive_samples) - self.acq_0 = acq_cmd(self.system.acquires[self.qubit_0], - self.system.memoryslots[self.qubit_0]) - self.acq_01 = acq_cmd(self.system.acquires, self.system.memoryslots) - # Get pulse simulator backend self.backend_sim = qiskit.Aer.get_backend('pulse_simulator') - def single_pulse_schedule(self, phi, shape="square", gauss_sigma=0): - """Creates schedule for single pulse test - Args: - phi (float): drive phase (phi in Hamiltonian) - shape (str): shape of the pulse; defaults to square pulse - gauss_sigma (float): std dev for gaussian pulse if shape=="gaussian" - Returns: - schedule (pulse schedule): schedule for this test - """ - # define default square drive pulse (add phase only; omega_a included in Hamiltonian) - const_pulse = np.ones(self.drive_samples) - phase = np.exp(1j * phi) - drive_pulse = SamplePulse(phase * const_pulse, name='drive_pulse') - - # create simple Gaussian drive if set this shape - if shape == "gaussian": - times = 1.0 * np.arange(self.drive_samples) - gaussian = np.exp(-times**2 / 2 / gauss_sigma**2) - drive_pulse = SamplePulse(gaussian, name='drive_pulse') - - # add commands to schedule - schedule = pulse.Schedule(name='drive_pulse') - schedule |= drive_pulse(self.system.qubits[self.qubit_0].drive) - - schedule |= self.acq_0 << schedule.duration - - return schedule - - def frame_change_schedule(self, phi, fc_phi, dur_drive1, dur_drive2): - """Creates schedule for frame change test. Does a pulse w/ phase phi of duration dur_drive1, - then frame change of phase fc_phi, then another pulse of phase phi of duration dur_drive2. - The different durations for the pulses allow manipulation of rotation angles on Bloch sphere - Args: - phi (float): drive phase (phi in Hamiltonian) - fc_phi (float): phase for frame change - dur_drive1 (int): duration of first pulse - dur_drive2 (int): duration of second pulse - - Returns: - schedule (pulse schedule): schedule for frame change test - """ - # drive pulse (just phase; omega_a included in Hamiltonian) - phase = np.exp(1j * phi) - drive_pulse_1 = SamplePulse(phase * np.ones(dur_drive1), - name='drive_pulse_1') - drive_pulse_2 = SamplePulse(phase * np.ones(dur_drive2), - name='drive_pulse_2') - - # frame change - fc_pulse = FrameChange(phase=fc_phi, name='fc') - - # add commands to schedule - schedule = pulse.Schedule(name='fc_schedule') - schedule |= drive_pulse_1(self.system.qubits[self.qubit_0].drive) - schedule += fc_pulse(self.system.qubits[self.qubit_0].drive) - schedule += drive_pulse_2(self.system.qubits[self.qubit_0].drive) - schedule |= self.acq_0 << schedule.duration - - return schedule - - def persistent_value_schedule(self, omega_a_pv): - """Creates schedule for persistent value experiment. Creates pv pulse w/ drive amplitude - omega_a_pv. It does this by setting the omega_a term in the Hamiltonian = 1. Sets length of - the pv pulse = self.drive_samples. The product omega_a_pv*self.drive_samples, then, controls - the resulting state. - Args: - omega_a_pv (float): drive amplitude from the pv pulse - - Returns: - schedule (pulse schedule): schedule for pv experiment - """ - # pv pulse - pv_pulse = PersistentValue(value=omega_a_pv, name='pv') - - # add commands to schedule - schedule = pulse.Schedule(name='pv_schedule') - schedule |= pv_pulse(self.system.qubits[self.qubit_0].drive) - schedule |= self.acq_0 << self.drive_samples - - return schedule - - def schedule_2q(self): - """Creates schedule for testing two qubit interaction. Specifically, do a pi pulse on qub 0 - so it starts in the `1` state (drive channel) and then apply constant pulses to each - qubit (on control channel 1). This will allow us to test a swap gate. - Returns: - schedule (pulse schedule): schedule for 2q experiment - """ - # set up const pulse - const_pulse = SamplePulse(np.ones(self.drive_samples), - name='const_pulse') - - # set u channel - uchannel = 1 # gives omega1-omega0 (we will set equal, so don't need negation) - - # add commands to schedule - schedule = pulse.Schedule(name='2q_schedule') - schedule |= const_pulse( - self.system.qubits[self.qubit_0].drive) # pi pulse drive - schedule += const_pulse(self.system.controls[uchannel] - ) << schedule.duration # u chan pulse - schedule |= self.acq_01 << schedule.duration - - return schedule - - def create_ham_1q(self, omega_0, omega_a, qub_dim=2): - """Create single qubit Hamiltonian as given in class docstring - - Args: - omega_0 (float): qubit 0 frequency - omega_a (float): drive amplitude - qub_dim (int): dimension of qubit subspace - - Returns: - hamiltonian (dict): dictionary representation of single qubit hamiltonian - """ - - # Create the hamiltonian - hamiltonian = {} - hamiltonian['h_str'] = [] - - # Q0 terms - hamiltonian['h_str'].append('-0.5*omega0*Z0') - hamiltonian['h_str'].append('0.5*omegaa*X0||D0') - - # Q1 terms - # none - - # Set variables in ham - hamiltonian['vars'] = {'omega0': omega_0, 'omegaa': omega_a} - - # set the qubit dimension to qub_dim - hamiltonian['qub'] = {'0': qub_dim} - - return hamiltonian - - def create_ham_2q(self, omega_0, omega_a, omega_i, qub_dim=2): - """Create two qubit Hamiltonian as given in comment of interaction test - Args: - omega_0 (float): Q0 frequency - omega_a (float): Q0 drive amplitude - omega_i (float): interaction amplitude - qub_dim (int): dimension of qubit subspace (same for both qubits) - Returns: - hamiltonian (dict): dictionary representation of two qubit hamiltonian - """ - - # Create the hamiltonian - hamiltonian = {} - hamiltonian['h_str'] = [] - - # Q0 single qubit term (used to pi pulse Q0) - hamiltonian['h_str'].append('-0.5*omega0*Z0') - hamiltonian['h_str'].append('0.5*omegaa*X0||D0') - - # interaction term (uses U channels to get exponential piece) - hamiltonian['h_str'].append('omegai*Sp0*Sm1||U1') - hamiltonian['h_str'].append( - 'omegai*Sm0*Sp1||U1') # U1 gives diff omega_d1-omega_d0 - - # Set variables in ham - hamiltonian['vars'] = { - 'omega0': omega_0, - 'omegaa': omega_a, - 'omegai': omega_i - } - - # set the qubit dimensions to qub_dim - hamiltonian['qub'] = {'0': qub_dim, '1': qub_dim} - - return hamiltonian - - def backend_options_1q(self, omega_0, omega_a, qub_dim=2): - """Creates backend_options dictionary for 1 qubit pulse simulation. - - Args: - omega_0 (float): qubit 0 frequency - omega_a (float): drive amplitude - qub_dim (int): dimension of qubit subspace - - Returns: - dict: backend_options dictionary. - """ - hamiltonian = self.create_ham_1q(omega_0, omega_a, qub_dim) - backend_options = self.backend_mock.configuration().to_dict() - backend_options['hamiltonian'] = hamiltonian - backend_options['qubit_list'] = [self.qubit_0] - backend_options['dt'] = 1.0 # makes time = self.drive_samples - backend_options['ode_options'] = {} # optionally set ode settings - backend_options['seed'] = 9000 - return backend_options - - def backend_options_2q(self, omega_0, omega_a, omega_i, qub_dim=2): - """Creates backend_options dictionary for 1 qubit pulse simulation. - - Args: - omega_0 (float): Q0 frequency - omega_a (float): Q0 drive amplitude - omega_i (float): interaction amplitude - qub_dim (int): dimension of qubit subspace (same for both qubits) + # --------------------------------------------------------------------- + # Test single qubit gates (using meas level 2 and square drive) + # --------------------------------------------------------------------- - Returns: - dict: backend_options dictionary. - """ - hamiltonian = self.create_ham_2q(omega_0, omega_a, omega_i, qub_dim) - backend_options = self.backend_mock.configuration().to_dict() - backend_options['hamiltonian'] = hamiltonian - backend_options['qubit_list'] = [self.qubit_0, self.qubit_1] - backend_options['dt'] = 1.0 # makes time = self.drive_samples - backend_options['ode_options'] = {} # optionally set ode settings - backend_options['seed'] = 12387 - return backend_options - - def qobj_params_1q(self, omega_d0): - """Set params needed to create qobj for 1q tests - Args: - omega_d0 (float): qubit 0 drive (lo) frequency - Returns: - dict: contains memory_slots, qubit_lo_freq, meas_map for 1q qobj + def test_x_gate(self): """ - memory_slots = 1 - qubit_lo_freq = [omega_d0 / (2 * np.pi)] - meas_map = self.meas_map_1q - - return (memory_slots, qubit_lo_freq, meas_map) - - def qobj_params_2q(self, omega_d0, omega_d1): - """Set params needed to create qobj for 2q tests - Args: - omega_d0 (float): qubit 0 drive (lo) frequency - omega_d1 (float): qubit 1 drive (lo) frequency - Returns: - dict: contains memory_slots, qubit_lo_freq, meas_map for 2q qobj + Test x gate. Set omega_d0=omega_0 (drive on resonance), phi=0, omega_a = pi/time """ - memory_slots = 2 - qubit_lo_freq = [omega_d0 / (2 * np.pi), omega_d1 / (2 * np.pi)] - meas_map = self.meas_map_2q - - return (memory_slots, qubit_lo_freq, meas_map) - def create_qobj(self, shots, meas_level, schedule, qobj_params): - """Creates qobj for the specified pulse experiment. Uses Hamiltonian from class docstring - (except for 2q tests, which use Hamiltonian specified in comment of that test section). - Args: - shots (int): number of times to perform experiment - meas_level (int): level of data to return - schedule (Schedule): pulse schedule for the qobj - qobj_params (tuple): tuple of memory_slots, qubit_lo_freq, meas_map - Returns: - Qobj: qobj representing this pulse experiment - """ - # set qobj params - memory_slots = qobj_params[0] - qubit_lo_freq = qobj_params[1] - meas_map = qobj_params[2] + # setup system model + total_samples = 100 + omega_0 = 2 * np.pi + omega_d0 = omega_0 + omega_a = np.pi / total_samples + system_model = self._system_model_1Q(omega_0, omega_a) - # construct the qobj + # set up schedule and qobj + schedule = self._simple_1Q_schedule(0, total_samples) qobj = assemble([schedule], - self.backend_mock, - meas_level=meas_level, + backend=self.backend_sim, + meas_level=2, meas_return='single', - meas_map=meas_map, - qubit_lo_freq=qubit_lo_freq, - memory_slots=memory_slots, - shots=shots) + meas_map=[[0]], + qubit_lo_freq=[omega_d0/(2*np.pi)], + memory_slots=2, + shots=256) - return qobj + # set backend backend_options + backend_options = {'seed' : 9000} - # --------------------------------------------------------------------- - # Test single qubit gates (using meas level 2 and square drive) - # --------------------------------------------------------------------- + # run simulation + result = self.backend_sim.run(qobj, system_model=system_model, + backend_options=backend_options).result() + + # test results + counts = result.get_counts() + exp_counts = {'1': 256} + self.assertDictAlmostEqual(counts, exp_counts) def test_dt_scaling_x_gate(self): """ - Test that dt is being used correctly by the simulator + Test that dt is being used correctly by the solver. """ + total_samples = 100 # do the same thing as test_x_gate, but scale dt and all frequency parameters # define test case for a single scaling def scale_test(scale): # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2 * np.pi * self.freq_qubit_0/scale - omega_d0 = omega_0 - # Require omega_a*time = pi to implement pi pulse (x gate) - # num of samples gives time - omega_a = np.pi / self.drive_samples/scale - - phi = 0 - - x_schedule = self.single_pulse_schedule(phi) - x_qobj_params = self.qobj_params_1q(omega_d0) - x_qobj = self.create_qobj(shots=256, - meas_level=2, - schedule=x_schedule, - qobj_params=x_qobj_params) - x_backend_opts = self.backend_options_1q(omega_0, omega_a) - x_backend_opts['dt'] = x_backend_opts['dt']*scale - result = self.backend_sim.run(x_qobj, - backend_options=x_backend_opts).result() + omega_0 = 2 * np.pi / scale + omega_d0 = omega_0 + omega_a = np.pi / total_samples / scale + + # set up system model + system_model = self._system_model_1Q(omega_0, omega_a) + system_model.dt = system_model.dt * scale + + # set up schedule and qobj + schedule = self._simple_1Q_schedule(0, total_samples) + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=2, + meas_return='single', + meas_map=[[0]], + qubit_lo_freq=[omega_d0/(2*np.pi)], + memory_slots=2, + shots=256) + + # set backend backend_options + backend_options = {'seed' : 9000} + + # run simulation + result = self.backend_sim.run(qobj, system_model=system_model, + backend_options=backend_options).result() counts = result.get_counts() exp_counts = {'1': 256} self.assertDictAlmostEqual(counts, exp_counts) + # set scales and run tests - scales = [2., 1.3453, 0.1234, 10.**5, 10**-5] + scales = [2., 0.1234, 10.**5, 10**-5] for scale in scales: scale_test(scale) - def test_x_gate(self): - """ - Test x gate. Set omega_d0=omega_0 (drive on resonance), phi=0, omega_a = pi/time - """ - - # set variables - - # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2 * np.pi * self.freq_qubit_0 - omega_d0 = omega_0 - - # Require omega_a*time = pi to implement pi pulse (x gate) - # num of samples gives time - omega_a = np.pi / self.drive_samples - - phi = 0 - - x_schedule = self.single_pulse_schedule(phi) - x_qobj_params = self.qobj_params_1q(omega_d0) - x_qobj = self.create_qobj(shots=256, - meas_level=2, - schedule=x_schedule, - qobj_params=x_qobj_params) - x_backend_opts = self.backend_options_1q(omega_0, omega_a) - result = self.backend_sim.run(x_qobj, - backend_options=x_backend_opts).result() - counts = result.get_counts() - exp_counts = {'1': 256} - - self.assertDictAlmostEqual(counts, exp_counts) - def test_hadamard_gate(self): """Test Hadamard. Is a rotation of pi/2 about the y-axis. Set omega_d0=omega_0 (drive on resonance), phi=-pi/2, omega_a = pi/2/time @@ -422,27 +146,36 @@ def test_hadamard_gate(self): # set variables shots = 100000 # large number of shots so get good proportions + total_samples = 100 # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2 * np.pi * self.freq_qubit_0 + omega_0 = 2 * np.pi omega_d0 = omega_0 # Require omega_a*time = pi/2 to implement pi/2 rotation pulse # num of samples gives time - omega_a = np.pi / 2 / self.drive_samples + omega_a = np.pi / 2 / total_samples + + system_model = self._system_model_1Q(omega_0, omega_a) phi = -np.pi / 2 + schedule = self._simple_1Q_schedule(phi, total_samples) - had_schedule = self.single_pulse_schedule(phi) - had_qobj_params = self.qobj_params_1q(omega_d0=omega_d0) + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=2, + meas_return='single', + meas_map=[[0]], + qubit_lo_freq=[omega_d0/(2*np.pi)], + memory_slots=2, + shots=shots) + + # set backend backend_options + backend_options = {'seed' : 9000} - had_qobj = self.create_qobj(shots=shots, - meas_level=2, - schedule=had_schedule, - qobj_params=had_qobj_params) - had_backend_opts = self.backend_options_1q(omega_0, omega_a) - result = self.backend_sim.run( - had_qobj, backend_options=had_backend_opts).result() + # run simulation + result = self.backend_sim.run(qobj, system_model=system_model, + backend_options=backend_options).result() counts = result.get_counts() # compare prop @@ -454,62 +187,38 @@ def test_hadamard_gate(self): self.assertDictAlmostEqual(prop, exp_prop, delta=0.01) - def _analytic_prop_1q_gates(self, omega_0, omega_a, omega_d0, phi): - """Compute proportion for 0 and 1 states analytically for single qubit gates. - Args: - omega_0 (float): Q0 freq - omega_a (float): Q0 drive amplitude - omega_d0 (flaot): Q0 drive frequency - phi (float): drive phase - Returns: - exp_prop (dict): expected value of 0 and 1 proportions from analytic computation - """ - time = self.drive_samples - # write Hrot analytically - h_rot = np.array([[ - (omega_d0 - omega_0) / 2, - np.exp(1j * phi) * omega_a / 2 - ], [np.exp(-1j * phi) * omega_a / 2, -(omega_d0 - omega_0) / 2]]) - # exponentiate - u_rot = expm(-1j * h_rot * time) - state0 = np.array([1, 0]) - - # compute analytic prob (proportion) of 0 state - mat_elem0 = np.vdot(state0, np.dot(u_rot, state0)) - prop0 = np.abs(mat_elem0)**2 - - # return expected proportion - exp_prop = {'0': prop0, '1': 1 - prop0} - return exp_prop - def test_arbitrary_gate(self): """Test a few examples w/ arbitary drive, phase and amplitude. """ shots = 10000 # large number of shots so get good proportions + total_samples = 100 num_tests = 3 # set variables for each test - omega_0 = 2 * np.pi * self.freq_qubit_0 + omega_0 = 2 * np.pi omega_d0_vals = [omega_0 + 1, omega_0 + 0.02, omega_0 + 0.005] omega_a_vals = [ - 2 * np.pi / 3 / self.drive_samples, - 7 * np.pi / 5 / self.drive_samples, 0.1 + 2 * np.pi / 3 / total_samples, + 7 * np.pi / 5 / total_samples, 0.1 ] phi_vals = [5 * np.pi / 7, 19 * np.pi / 14, np.pi / 4] for i in range(num_tests): with self.subTest(i=i): - schedule = self.single_pulse_schedule(phi_vals[i]) - qobj_params = self.qobj_params_1q(omega_d0=omega_d0_vals[i]) - qobj = self.create_qobj(shots=shots, - meas_level=2, - schedule=schedule, - qobj_params=qobj_params) + system_model = self._system_model_1Q(omega_0, omega_a_vals[i]) + schedule = self._simple_1Q_schedule(phi_vals[i], total_samples) + + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=2, + meas_return='single', + meas_map=[[0]], + qubit_lo_freq=[omega_d0_vals[i]/(2*np.pi)], + memory_slots=2, + shots=shots) # Run qobj and compare prop to expected result - backend_options = self.backend_options_1q( - omega_0, omega_a_vals[i]) - result = self.backend_sim.run( - qobj, backend_options=backend_options).result() + backend_options = {'seed' : 9000} + result = self.backend_sim.run(qobj, system_model, backend_options).result() counts = result.get_counts() prop = {} @@ -517,6 +226,7 @@ def test_arbitrary_gate(self): prop[key] = counts[key] / shots exp_prop = self._analytic_prop_1q_gates( + total_samples=total_samples, omega_0=omega_0, omega_a=omega_a_vals[i], omega_d0=omega_d0_vals[i], @@ -524,43 +234,45 @@ def test_arbitrary_gate(self): self.assertDictAlmostEqual(prop, exp_prop, delta=0.01) - # --------------------------------------------------------------------- - # Test meas level 1 (using square drive) - # Note: the simulator generates approximate IQ data with the proper - # data structure; it should not, however, be compared with an actual - # device. - # --------------------------------------------------------------------- - def test_meas_level_1(self): """Test measurement level 1. """ shots = 10000 # run large number of shots for good proportions + total_samples = 100 # perform hadamard setup (so get some 0's and some 1's), but use meas_level = 1 # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2 * np.pi * self.freq_qubit_0 + omega_0 = 2 * np.pi omega_d0 = omega_0 # Require omega_a*time = pi/2 to implement pi/2 rotation pulse # num of samples gives time - omega_a = np.pi / 2 / self.drive_samples + omega_a = np.pi / 2 / total_samples + + phi = -np.pi / 2 + + system_model = self._system_model_1Q(omega_0, omega_a) phi = -np.pi / 2 + schedule = self._simple_1Q_schedule(phi, total_samples) - schedule = self.single_pulse_schedule(phi) - qobj_params = self.qobj_params_1q(omega_d0=omega_d0) - qobj = self.create_qobj(shots=shots, - meas_level=1, - schedule=schedule, - qobj_params=qobj_params) - backend_options = self.backend_options_1q(omega_0=omega_0, - omega_a=omega_a) - result = self.backend_sim.run( - qobj, backend_options=backend_options).result() + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=1, + meas_return='single', + meas_map=[[0]], + qubit_lo_freq=[omega_d0/(2*np.pi)], + memory_slots=2, + shots=shots) + + # set backend backend_options + backend_options = {'seed' : 9000} + + result = self.backend_sim.run(qobj, system_model, backend_options).result() # Verify that (about) half the IQ vals have abs val 1 and half have abs val 0 # (use prop for easier comparison) - mem = np.abs(result.get_memory()[:, self.qubit_0]) + mem = np.abs(result.get_memory()[:, 0]) iq_prop = {'0': 0, '1': 0} for i in mem: @@ -573,27 +285,6 @@ def test_meas_level_1(self): self.assertDictAlmostEqual(iq_prop, exp_prop, delta=0.01) - # --------------------------------------------------------------------- - # Test Gaussian drive (using meas_level=2) - # --------------------------------------------------------------------- - - def _analytic_gaussian_statevector(self, gauss_sigma, omega_a): - r"""Computes analytic statevector for gaussian drive. Solving the Schrodinger equation in - the rotating frame leads to the analytic solution `(\cos(x), -i\sin(x)) with - `x = \frac{1}{2}\sqrt{\frac{\pi}{2}}\sigma\omega_a erf(\frac{t}{\sqrt{2}\sigma}). - Args: - gauss_sigma (float): std dev for the gaussian drive - omega_a (float): Q0 drive amplitude - Returns: - exp_statevector (list): analytic form of the statevector computed for gaussian drive - (Returned in the rotating frame) - """ - time = self.drive_samples - arg = 1 / 2 * np.sqrt(np.pi / 2) * gauss_sigma * omega_a * erf( - time / np.sqrt(2) / gauss_sigma) - exp_statevector = [np.cos(arg), -1j * np.sin(arg)] - return exp_statevector - def test_gaussian_drive(self): """Test gaussian drive pulse using meas_level_2. Set omega_d0=omega_0 (drive on resonance), phi=0, omega_a = pi/time @@ -602,289 +293,250 @@ def test_gaussian_drive(self): # set variables # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2 * np.pi * self.freq_qubit_0 + total_samples = 100 + omega_0 = 2 * np.pi omega_d0 = omega_0 # Require omega_a*time = pi to implement pi pulse (x gate) # num of samples gives time - omega_a = np.pi / self.drive_samples + omega_a = np.pi / total_samples phi = 0 # Test gaussian drive results for a few different sigma gauss_sigmas = { - self.drive_samples / 6, self.drive_samples / 3, self.drive_samples + total_samples / 6, total_samples / 3, total_samples } + + system_model = self._system_model_1Q(omega_0, omega_a) + for gauss_sigma in gauss_sigmas: with self.subTest(gauss_sigma=gauss_sigma): - schedule = self.single_pulse_schedule(phi=phi, - shape="gaussian", - gauss_sigma=gauss_sigma) - qobj_params = self.qobj_params_1q(omega_d0=omega_d0) - - qobj = self.create_qobj(shots=1000, - meas_level=2, - schedule=schedule, - qobj_params=qobj_params) - backend_options = self.backend_options_1q(omega_0=omega_0, - omega_a=omega_a) - result = self.backend_sim.run( - qobj, backend_options=backend_options).result() + schedule = self._simple_1Q_schedule(phi, + total_samples, + "gaussian", + gauss_sigma) + + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=2, + meas_return='single', + meas_map=[[0]], + qubit_lo_freq=[omega_d0/(2*np.pi)], + memory_slots=2, + shots=1000) + backend_options = {'seed' : 9000} + + result = self.backend_sim.run(qobj, system_model, backend_options).result() statevector = result.get_statevector() exp_statevector = self._analytic_gaussian_statevector( - gauss_sigma=gauss_sigma, omega_a=omega_a) + total_samples, gauss_sigma=gauss_sigma, omega_a=omega_a) # Check fidelity of statevectors self.assertGreaterEqual( state_fidelity(statevector, exp_statevector), 0.99) - # --------------------------------------------------------------------- - # Test FrameChange and PersistentValue commands - # --------------------------------------------------------------------- - - def _analytic_prop_fc(self, phi_net): - """Compute analytic proportion of 0 and 1 from a given frame change. Analytically can show - that the 0 prop is given by `cos(phi_net/2)^2` - Args: - phi_net (float): net rotation on Bloch sphere due to the frame change schedule - Returns: - exp_prop (dict): expected proportion of 0, 1 counts as computed analytically - """ - prop0 = np.cos(phi_net / 2)**2 - exp_prop = {'0': prop0, '1': 1 - prop0} - return exp_prop - def test_frame_change(self): """Test frame change command. """ shots = 10000 + total_samples = 100 # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2 * np.pi * self.freq_qubit_0 + omega_0 = 2 * np.pi omega_d0 = omega_0 # set phi = 0 phi = 0 - dur_drive1 = self.drive_samples # first pulse duration + dur_drive1 = total_samples # first pulse duration fc_phi = np.pi # Test frame change where no shift in state results # specfically: do pi/2 pulse, then pi frame change, then another pi/2 pulse. # Verify left in |0> state - dur_drive2_no_shift = dur_drive1 # same duration for both pulses - omega_a_no_shift = np.pi / 2 / dur_drive1 # pi/2 pulse amplitude - schedule_no_shift = self.frame_change_schedule( - phi=phi, - fc_phi=fc_phi, - dur_drive1=dur_drive1, - dur_drive2=dur_drive2_no_shift) - qobj_params_no_shift = self.qobj_params_1q(omega_d0=omega_d0) - - qobj_no_shift = self.create_qobj(shots=shots, - meas_level=2, - schedule=schedule_no_shift, - qobj_params=qobj_params_no_shift) - backend_options_no_shift = self.backend_options_1q( - omega_0, omega_a_no_shift) - result_no_shift = self.backend_sim.run( - qobj_no_shift, backend_options=backend_options_no_shift).result() - counts_no_shift = result_no_shift.get_counts() - exp_result_no_shift = {'0': shots} - - self.assertDictAlmostEqual(counts_no_shift, exp_result_no_shift) + dur_drive2 = dur_drive1 # same duration for both pulses + omega_a = np.pi / 2 / dur_drive1 # pi/2 pulse amplitude + + system_model = self._system_model_1Q(omega_0, omega_a) + schedule = self._1Q_frame_change_schedule(phi, + fc_phi, + total_samples, + dur_drive1, + dur_drive2) + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=2, + meas_return='single', + meas_map=[[0]], + qubit_lo_freq=[omega_d0/(2*np.pi)], + memory_slots=2, + shots=shots) + + backend_options = {'seed' : 9000} + result = self.backend_sim.run(qobj, system_model, backend_options).result() + counts = result.get_counts() + exp_counts = {'0': shots} + + self.assertDictAlmostEqual(counts, exp_counts) # Test frame change where a shift does result # specifically: do pi/4 pulse, then pi phase change, then do pi/8 pulse. # check that a net rotation of pi/4-pi/8 has occured on the Bloch sphere - dur_drive2_shift = dur_drive1 // 2 # half time for second pulse (halves angle) - omega_a_shift = np.pi / 4 / dur_drive1 # pi/4 pulse amplitude - - schedule_shift = self.frame_change_schedule( - phi=phi, - fc_phi=fc_phi, - dur_drive1=dur_drive1, - dur_drive2=dur_drive2_shift) - - qobj_params_shift = self.qobj_params_1q(omega_d0=omega_d0) - qobj_shift = self.create_qobj(shots=shots, - meas_level=2, - schedule=schedule_shift, - qobj_params=qobj_params_shift) - backend_options_shift = self.backend_options_1q(omega_0, omega_a_shift) - result_shift = self.backend_sim.run( - qobj_shift, backend_options=backend_options_shift).result() - counts_shift = result_shift.get_counts() + dur_drive2 = int(dur_drive1 / 2) # half time for second pulse (halves angle) + omega_a = np.pi / 4 / dur_drive1 # pi/4 pulse amplitude + + system_model = self._system_model_1Q(omega_0, omega_a) + schedule = self._1Q_frame_change_schedule(phi, + fc_phi, + total_samples, + dur_drive1, + dur_drive2) + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=2, + meas_return='single', + meas_map=[[0]], + qubit_lo_freq=[omega_d0/(2*np.pi)], + memory_slots=2, + shots=shots) + + backend_options = {'seed' : 9000} + result = self.backend_sim.run(qobj, system_model, backend_options).result() + counts = result.get_counts() # verify props prop_shift = {} - for key in counts_shift.keys(): - prop_shift[key] = counts_shift[key] / shots + for key in counts.keys(): + prop_shift[key] = counts[key] / shots # net angle is given by pi/4-pi/8 - exp_prop_shift = self._analytic_prop_fc(np.pi / 4 - np.pi / 8) - self.assertDictAlmostEqual(prop_shift, exp_prop_shift, delta=0.01) - - @unittest.skip("PerisitentValue pulses are currently not supported.") - def test_persistent_value(self): - """Test persistent value command. """ - - shots = 256 - # set omega_0, omega_d0 equal (use qubit frequency) -> drive on resonance - omega_0 = 2 * np.pi * self.freq_qubit_0 - omega_d0 = omega_0 - - # Set omega_a = 1 and do pi pulse w/ omega_a_pv. Verify result is the |1> state - omega_a = 1 - omega_a_pv = np.pi / self.drive_samples # pi pulse - - schedule = self.persistent_value_schedule(omega_a_pv) - qobj_params = self.qobj_params_1q(omega_d0=omega_d0) - - pv_qobj = self.create_qobj(shots=shots, - meas_level=2, - schedule=schedule, - qobj_params=qobj_params) - backend_options = self.backend_options_1q(omega_0, omega_a) - result = self.backend_sim.run( - pv_qobj, backend_options=backend_options).result() - counts = result.get_counts() - exp_result = {'1': shots} - - self.assertDictAlmostEqual(counts, exp_result) - - # --------------------------------------------------------------------- - # Test higher energy levels (take 3 level system for simplicity, - # use square drive) - # `\sigma_x \rightarrow a+\dagger{a}`, - # `\sigma_y \rightarrow -\imag (a-\dagger{a})`, etc - # --------------------------------------------------------------------- - - def _analytic_statevector_three_level(self, omega_a): - r"""Returns analytically computed statevector for 3 level system with our Hamiltonian. Is - given by `(\frac{1}{3} (2+\cos(\frac{\sqrt{3}}{2} \omega_a t)), - -\frac{i}{\sqrt{3}} \sin(\frac{\sqrt{3}}{2} \omega_a t), - -\frac{2\sqrt{2}}{3} \sin(\frac{\sqrt{3}}{4} \omega_a t)^2)`. - Args: - omega_a (float): Q0 drive amplitude - Returns: - exp_statevector (list): analytically computed statevector with Hamiltonian from above - (Returned in the rotating frame) - """ - time = self.drive_samples - arg1 = np.sqrt(3) * omega_a * time / 2 # cos arg for first component - arg2 = arg1 # sin arg for first component - arg3 = arg1 / 2 # sin arg for 3rd component - exp_statevector = np.array([(2 + np.cos(arg1)) / 3, - -1j * np.sin(arg2) / np.sqrt(3), - -2 * np.sqrt(2) * np.sin(arg3)**2 / 3], - dtype=complex) - return exp_statevector + prop0 = np.cos((np.pi / 4 - np.pi / 8) / 2)**2 + exp_prop = {'0' : prop0, '1': 1 - prop0} + self.assertDictAlmostEqual(prop_shift, exp_prop, delta=0.01) def test_three_level(self): r"""Test 3 level system. Compare statevectors as counts only use bitstrings. Analytic form given in _analytic_statevector_3level function docstring. """ + def analytic_state_vector(omega_a, total_samples): + r"""Returns analytically computed statevector for 3 level system with our Hamiltonian. + Is given by `(\frac{1}{3} (2+\cos(\frac{\sqrt{3}}{2} \omega_a t)), + -\frac{i}{\sqrt{3}} \sin(\frac{\sqrt{3}}{2} \omega_a t), + -\frac{2\sqrt{2}}{3} \sin(\frac{\sqrt{3}}{4} \omega_a t)^2)`. + Args: + omega_a (float): Q0 drive amplitude + total_samples (int): number of samples to use in pulses_idx + Returns: + exp_statevector (list): analytically computed statevector with Hamiltonian from + above (Returned in the rotating frame) + """ + time = total_samples + arg1 = np.sqrt(3) * omega_a * time / 2 # cos arg for first component + arg2 = arg1 # sin arg for first component + arg3 = arg1 / 2 # sin arg for 3rd component + exp_statevector = np.array([(2 + np.cos(arg1)) / 3, + -1j * np.sin(arg2) / np.sqrt(3), + -2 * np.sqrt(2) * np.sin(arg3)**2 / 3], + dtype=complex) + return exp_statevector + + shots = 1000 + total_samples = 100 # Set omega_0,omega_d0 (use qubit frequency) -> drive on resonance - omega_0 = 2 * np.pi * self.freq_qubit_0 + omega_0 = 2 * np.pi omega_d0 = omega_0 # Set phi = 0 for simplicity phi = 0 # Test pi pulse - omega_a_pi = np.pi / self.drive_samples + omega_a = np.pi / total_samples - schedule_pi = self.single_pulse_schedule(phi) - qobj_params_pi = self.qobj_params_1q(omega_d0=omega_d0) + system_model = self._system_model_1Q(omega_0, omega_a, qubit_dim=3) + schedule = self._simple_1Q_schedule(phi, total_samples) - qobj_pi = self.create_qobj(shots=shots, - meas_level=2, - schedule=schedule_pi, - qobj_params=qobj_params_pi) + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=2, + meas_return='single', + meas_map=[[0]], + qubit_lo_freq=[omega_d0/(2*np.pi)], + memory_slots=2, + shots=shots) + backend_options = {'seed' : 9000} - # Set qub_dim=3 in hamiltonian - backend_options_pi = self.backend_options_1q(omega_0, - omega_a_pi, - qub_dim=3) - result_pi = self.backend_sim.run( - qobj_pi, backend_options=backend_options_pi).result() - statevector_pi = result_pi.get_statevector() + result = self.backend_sim.run(qobj, system_model, backend_options).result() + statevector = result.get_statevector() - exp_statevector_pi = self._analytic_statevector_three_level(omega_a_pi) + exp_statevector = analytic_state_vector(omega_a, total_samples) # Check fidelity of statevectors self.assertGreaterEqual( - state_fidelity(statevector_pi, exp_statevector_pi), 0.99) + state_fidelity(statevector, exp_statevector), 0.99) # Test 2*pi pulse - omega_a_2pi = 2 * np.pi / self.drive_samples - - schedule_2pi = self.single_pulse_schedule(phi) - qobj_params_2pi = self.qobj_params_1q(omega_d0=omega_d0) - qobj_2pi = self.create_qobj(shots=shots, - meas_level=2, - schedule=schedule_2pi, - qobj_params=qobj_params_2pi) - # set qub_dim=3 in hamiltonian - backend_options_2pi = self.backend_options_1q(omega_0, - omega_a_2pi, - qub_dim=3) - result_2pi = self.backend_sim.run( - qobj_2pi, backend_options=backend_options_2pi).result() - statevector_2pi = result_2pi.get_statevector() - - exp_statevector_2pi = self._analytic_statevector_three_level( - omega_a_2pi) + omega_a = 2 * np.pi / total_samples + + system_model = self._system_model_1Q(omega_0, omega_a, qubit_dim=3) + schedule = self._simple_1Q_schedule(phi, total_samples) + + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=2, + meas_return='single', + meas_map=[[0]], + qubit_lo_freq=[omega_d0/(2*np.pi)], + memory_slots=2, + shots=shots) + backend_options = {'seed' : 9000} + + result = self.backend_sim.run(qobj, system_model, backend_options).result() + statevector = result.get_statevector() + + exp_statevector = analytic_state_vector(omega_a, total_samples) # Check fidelity of vectors self.assertGreaterEqual( - state_fidelity(statevector_2pi, exp_statevector_2pi), 0.99) - - # ---------------------------------------------------------------------------------------------- - # Test qubit interaction (use 2 qubits for simplicity) - # For these tests, we use a different 2-qubit Hamiltonian that tests both - # interaction and control (U) channels. In the lab frame, it is given - # by `H = -\frac{1}{2} \omega_0 \sigma_z^0 + \frac{1}{2} \omega_a e^{i \omega_{d0} t} \sigma_x^0 - # `+ \omega_i (e^{i (\omega_{d0}-\omega_{d1}) t} \sigma_{p0} \otimes \sigma_{m1} + ` - # `+ e^{-i (\omega_{d0}-\omega_{d1}) t} \sigma_{m0} \otimes \sigma_{p1})`. First 2 terms allow - # us to excite the 0 qubit. Latter 2 terms define the interaction. - # ---------------------------------------------------------------------------------------------- + state_fidelity(statevector, exp_statevector), 0.99) def test_interaction(self): r"""Test 2 qubit interaction via swap gates.""" shots = 100000 - + total_samples = 100 # Do a standard SWAP gate # Interaction amp (any non-zero creates the swap gate) - omega_i_swap = np.pi / 2 / self.drive_samples + omega_i_swap = np.pi / 2 / total_samples # set omega_d0=omega_0 (resonance) - omega_0 = 2 * np.pi * self.freq_qubit_0 + omega_0 = 2 * np.pi omega_d0 = omega_0 # For swapping, set omega_d1 = 0 (drive on Q0 resonance) - omega_d1_swap = 0 + # Note: confused by this as there is no d1 term + omega_d1 = 0 # do pi pulse on Q0 and verify state swaps from '01' to '10' (reverse bit order) # Q0 drive amp -> pi pulse - omega_a_pi_swap = np.pi / self.drive_samples + omega_a_pi_swap = np.pi / total_samples - schedule_pi_swap = self.schedule_2q() - qobj_params_pi_swap = self.qobj_params_2q(omega_d0=omega_d0, - omega_d1=omega_d1_swap) - qobj_pi_swap = self.create_qobj(shots=shots, - meas_level=2, - schedule=schedule_pi_swap, - qobj_params=qobj_params_pi_swap) + system_model = self._system_model_2Q(omega_0, omega_a_pi_swap, omega_i_swap) - backend_options_pi_swap = self.backend_options_2q( - omega_0, omega_a_pi_swap, omega_i_swap) - result_pi_swap = self.backend_sim.run( - qobj_pi_swap, backend_options=backend_options_pi_swap).result() + schedule = self._schedule_2Q_interaction(total_samples) + qobj = assemble([schedule], + backend=self.backend_sim, + meas_level=2, + meas_return='single', + meas_map=[[0, 1]], + qubit_lo_freq=[omega_d0 / (2 * np.pi), omega_d1 / (2 * np.pi)], + memory_slots=2, + shots=shots) + backend_options = {'seed': 12387} + + result_pi_swap = self.backend_sim.run(qobj, system_model, backend_options).result() counts_pi_swap = result_pi_swap.get_counts() exp_counts_pi_swap = { @@ -895,21 +547,11 @@ def test_interaction(self): # do pi/2 pulse on Q0 and verify half the counts are '00' and half are swapped state '10' # Q0 drive amp -> pi/2 pulse - omega_a_pi2_swap = np.pi / 2 / self.drive_samples - - schedule_pi2_swap = self.schedule_2q() - qobj_params_pi2_swap = self.qobj_params_2q(omega_d0=omega_d0, - omega_d1=omega_d1_swap) + omega_a_pi2_swap = np.pi / 2 / total_samples - qobj_pi2_swap = self.create_qobj(shots=shots, - meas_level=2, - schedule=schedule_pi2_swap, - qobj_params=qobj_params_pi2_swap) + system_model = self._system_model_2Q(omega_0, omega_a_pi2_swap, omega_i_swap) - backend_options_pi2_swap = self.backend_options_2q( - omega_0, omega_a_pi2_swap, omega_i_swap) - result_pi2_swap = self.backend_sim.run( - qobj_pi2_swap, backend_options=backend_options_pi2_swap).result() + result_pi2_swap = self.backend_sim.run(qobj, system_model, backend_options).result() counts_pi2_swap = result_pi2_swap.get_counts() # compare proportions for improved accuracy @@ -926,25 +568,11 @@ def test_interaction(self): # Test that no SWAP occurs when omega_i=0 (no interaction) omega_i_no_swap = 0 - # Set arbitrary params for omega_d0, omega_d1 - omega_d1_no_swap = omega_d0 - # Q0 drive amp -> pi pulse - omega_a_no_swap = np.pi / self.drive_samples - - schedule_no_swap = self.schedule_2q() - qobj_params_no_swap = self.qobj_params_2q(omega_d0=omega_d0, - omega_d1=omega_d1_no_swap) - - qobj_no_swap = self.create_qobj(shots=shots, - meas_level=2, - schedule=schedule_no_swap, - qobj_params=qobj_params_no_swap) - backend_options_swap = self.backend_options_2q(omega_0, - omega_a_no_swap, - omega_i_no_swap) - result_no_swap = self.backend_sim.run( - qobj_no_swap, backend_options=backend_options_swap).result() + omega_a_no_swap = np.pi / total_samples + system_model = self._system_model_2Q(omega_0, omega_a_no_swap, omega_i_no_swap) + + result_no_swap = self.backend_sim.run(qobj, system_model, backend_options).result() counts_no_swap = result_no_swap.get_counts() exp_counts_no_swap = { @@ -953,5 +581,213 @@ def test_interaction(self): self.assertDictAlmostEqual(counts_no_swap, exp_counts_no_swap) + + def _system_model_1Q(self, omega_0, omega_a, qubit_dim=2): + """Constructs a simple 1 qubit system model. + + Args: + omega_0 (float): frequency of qubit + omega_a (float): strength of drive term + qubit_dim (int): dimension of qubit + Returns: + PulseSystemModel: model for qubit system + """ + # make Hamiltonian + hamiltonian = {} + hamiltonian['h_str'] = ['-0.5*omega0*Z0', '0.5*omegaa*X0||D0'] + hamiltonian['vars'] = {'omega0': omega_0, 'omegaa': omega_a} + hamiltonian['qub'] = {'0': qubit_dim} + ham_model = HamiltonianModel.from_dict(hamiltonian) + + u_channel_lo = [] + qubit_list = [0] + dt = 1. + + return PulseSystemModel(hamiltonian=ham_model, + u_channel_lo=u_channel_lo, + qubit_list=qubit_list, + dt=dt) + + def _system_model_2Q(self, omega_0, omega_a, omega_i, qubit_dim=2): + """Constructs a simple 1 qubit system model. + + Args: + omega_0 (float): frequency of qubit + omega_a (float): strength of drive term + omega_i (float): strength of interaction + qubit_dim (int): dimension of qubit + Returns: + PulseSystemModel: model for qubit system + """ + + # make Hamiltonian + hamiltonian = {} + # qubit 0 terms + hamiltonian['h_str'] = ['-0.5*omega0*Z0', '0.5*omegaa*X0||D0'] + # interaction term + hamiltonian['h_str'].append('omegai*(Sp0*Sm1+Sm0*Sp1)||U1') + hamiltonian['vars'] = { + 'omega0': omega_0, + 'omegaa': omega_a, + 'omegai': omega_i + } + hamiltonian['qub'] = {'0' : qubit_dim, '1' : qubit_dim} + ham_model = HamiltonianModel.from_dict(hamiltonian) + + + u_channel_lo = [[{'q': 0, 'scale': [1.0, 0.0]}], + [{'q': 0, 'scale': [-1.0, 0.0]}, {'q': 1, 'scale': [1.0, 0.0]}]] + qubit_list = [0, 1] + dt = 1. + + return PulseSystemModel(hamiltonian=ham_model, + u_channel_lo=u_channel_lo, + qubit_list=qubit_list, + dt=dt) + + def _simple_1Q_schedule(self, phi, total_samples, shape="square", gauss_sigma=0): + """Creates schedule for single pulse test + Args: + phi (float): drive phase (phi in Hamiltonian) + total_samples (int): length of pulses + shape (str): shape of the pulse; defaults to square pulse + gauss_sigma (float): std dev for gaussian pulse if shape=="gaussian" + Returns: + schedule (pulse schedule): schedule for this test + """ + + # set up pulse command + phase = np.exp(1j * phi) + drive_pulse = None + if shape == "square": + const_pulse = np.ones(total_samples) + drive_pulse = SamplePulse(phase * const_pulse, name='drive_pulse') + if shape == "gaussian": + times = 1.0 * np.arange(total_samples) + gaussian = np.exp(-times**2 / 2 / gauss_sigma**2) + drive_pulse = SamplePulse(phase * gaussian, name='drive_pulse') + + # set up acquire command + acq_cmd = pulse.Acquire(duration=total_samples) + + # add commands into a schedule for first qubit + schedule = pulse.Schedule(name='drive_pulse') + schedule |= drive_pulse(DriveChannel(0)) + schedule |= acq_cmd(AcquireChannel(0), MemorySlot(0)) << schedule.duration + + return schedule + + def _1Q_frame_change_schedule(self, phi, fc_phi, total_samples, dur_drive1, dur_drive2): + """Creates schedule for frame change test. Does a pulse w/ phase phi of duration dur_drive1, + then frame change of phase fc_phi, then another pulse of phase phi of duration dur_drive2. + The different durations for the pulses allow manipulation of rotation angles on Bloch sphere + + Args: + phi (float): drive phase (phi in Hamiltonian) + fc_phi (float): phase for frame change + total_samples (int): length of pulses + dur_drive1 (int): duration of first pulse + dur_drive2 (int): duration of second pulse + + Returns: + schedule (pulse schedule): schedule for frame change test + """ + phase = np.exp(1j * phi) + drive_pulse_1 = SamplePulse(phase * np.ones(dur_drive1), + name='drive_pulse_1') + drive_pulse_2 = SamplePulse(phase * np.ones(dur_drive2), + name='drive_pulse_2') + + # frame change + fc_pulse = FrameChange(phase=fc_phi, name='fc') + + # set up acquire command + acq_cmd = pulse.Acquire(duration=total_samples) + + # add commands to schedule + schedule = pulse.Schedule(name='fc_schedule') + schedule |= drive_pulse_1(DriveChannel(0)) + schedule += fc_pulse(DriveChannel(0)) + schedule += drive_pulse_2(DriveChannel(0)) + schedule |= acq_cmd(AcquireChannel(0), MemorySlot(0)) << schedule.duration + + return schedule + + def _analytic_prop_1q_gates(self, total_samples, omega_0, omega_a, omega_d0, phi): + """Compute proportion for 0 and 1 states analytically for single qubit gates. + Args: + total_samples (int): length of pulses + omega_0 (float): Q0 freq + omega_a (float): Q0 drive amplitude + omega_d0 (flaot): Q0 drive frequency + phi (float): drive phase + Returns: + exp_prop (dict): expected value of 0 and 1 proportions from analytic computation + """ + time = total_samples + # write Hrot analytically + h_rot = np.array([[ + (omega_d0 - omega_0) / 2, + np.exp(1j * phi) * omega_a / 2 + ], [np.exp(-1j * phi) * omega_a / 2, -(omega_d0 - omega_0) / 2]]) + # exponentiate + u_rot = expm(-1j * h_rot * time) + state0 = np.array([1, 0]) + + # compute analytic prob (proportion) of 0 state + mat_elem0 = np.vdot(state0, np.dot(u_rot, state0)) + prop0 = np.abs(mat_elem0)**2 + + # return expected proportion + exp_prop = {'0': prop0, '1': 1 - prop0} + return exp_prop + + def _analytic_gaussian_statevector(self, total_samples, gauss_sigma, omega_a): + r"""Computes analytic statevector for gaussian drive. Solving the Schrodinger equation in + the rotating frame leads to the analytic solution `(\cos(x), -i\sin(x)) with + `x = \frac{1}{2}\sqrt{\frac{\pi}{2}}\sigma\omega_a erf(\frac{t}{\sqrt{2}\sigma}). + + Args: + total_samples (int): length of pulses + gauss_sigma (float): std dev for the gaussian drive + omega_a (float): Q0 drive amplitude + Returns: + exp_statevector (list): analytic form of the statevector computed for gaussian drive + (Returned in the rotating frame) + """ + time = total_samples + arg = 1 / 2 * np.sqrt(np.pi / 2) * gauss_sigma * omega_a * erf( + time / np.sqrt(2) / gauss_sigma) + exp_statevector = [np.cos(arg), -1j * np.sin(arg)] + return exp_statevector + + def _schedule_2Q_interaction(self, total_samples): + """Creates schedule for testing two qubit interaction. Specifically, do a pi pulse on qub 0 + so it starts in the `1` state (drive channel) and then apply constant pulses to each + qubit (on control channel 1). This will allow us to test a swap gate. + + Args: + total_samples (int): length of pulses + Returns: + schedule (pulse schedule): schedule for 2q experiment + """ + # set up const pulse + const_pulse = SamplePulse(np.ones(total_samples), name='const_pulse') + + # set u channel + uchannel = 1 # gives omega1-omega0 (we will set equal, so don't need negation) + + # add commands to schedule + schedule = pulse.Schedule(name='2q_schedule') + schedule |= const_pulse(DriveChannel(0)) # pi pulse drive + schedule += const_pulse(ControlChannel(uchannel)) << schedule.duration # u chan pulse + + acq_cmd = pulse.Acquire(duration=total_samples) + schedule |= acq_cmd([AcquireChannel(0), AcquireChannel(1)], + [MemorySlot(0), MemorySlot(1)]) << schedule.duration + + return schedule + + if __name__ == '__main__': unittest.main() diff --git a/test/terra/openpulse/test_pulse_digest.py b/test/terra/openpulse/test_pulse_digest.py index de188dc6b0..3fd8c698c1 100644 --- a/test/terra/openpulse/test_pulse_digest.py +++ b/test/terra/openpulse/test_pulse_digest.py @@ -22,7 +22,8 @@ from qiskit.providers.aer.backends.pulse_simulator import digest_pulse_obj from qiskit.test.mock.fake_openpulse_2q import FakeOpenPulse2Q - +''' +# these tests no longer function but may be useful later class BaseTestDigest(QiskitAerTestCase): """Testing of functions in providers.aer.openpulse.qobj.digest.""" @@ -194,3 +195,4 @@ def _create_2q_ham(v0=5.0, if __name__ == '__main__': unittest.main() +''' diff --git a/test/terra/openpulse/test_system_models.py b/test/terra/openpulse/test_system_models.py new file mode 100644 index 0000000000..e1298afb58 --- /dev/null +++ b/test/terra/openpulse/test_system_models.py @@ -0,0 +1,123 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Tests for option handling in digest.py +""" + +import unittest +from test.terra.common import QiskitAerTestCase +import qiskit +import qiskit.pulse as pulse +from qiskit.pulse import pulse_lib +from qiskit.compiler import assemble +from qiskit.providers.aer.openpulse.pulse_system_model import PulseSystemModel +from qiskit.providers.aer.openpulse.hamiltonian_model import HamiltonianModel + + +class BaseTestPulseSystemModel(QiskitAerTestCase): + """Testing of functions in providers.aer.openpulse.qobj.digest.""" + + def setUp(self): + self._default_qubit_lo_freq = [4.9, 5.0] + self._u_channel_lo = [[{'q': 0, 'scale': [1.0, 0.0]}], + [{'q': 0, 'scale': [-1.0, 0.0]}, {'q': 1, 'scale': [1.0, 0.0]}]] + + def _simple_system_model(self, v0=5.0, v1=5.1, j=0.01, r=0.02, alpha0=-0.33, alpha1=-0.33): + hamiltonian = {} + hamiltonian['h_str'] = ['np.pi*(2*v0-alpha0)*O0', + 'np.pi*alpha0*O0*O0', + '2*np.pi*r*X0||D0', + '2*np.pi*r*X0||U1', + '2*np.pi*r*X1||U0', + 'np.pi*(2*v1-alpha1)*O1', + 'np.pi*alpha1*O1*O1', + '2*np.pi*r*X1||D1', + '2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)'] + hamiltonian['qub'] = {'0' : 3, '1' : 3} + hamiltonian['vars'] = {'v0': v0, + 'v1': v1, + 'j': j, + 'r': r, + 'alpha0': alpha0, + 'alpha1': alpha1} + ham_model = HamiltonianModel.from_dict(hamiltonian) + + qubit_list =[0, 1] + dt = 1. + + return PulseSystemModel(hamiltonian=ham_model, + qubit_freq_est=self._default_qubit_lo_freq, + u_channel_lo=self._u_channel_lo, + qubit_list=qubit_list, + dt=dt) + + +class TestPulseSystemModel(BaseTestPulseSystemModel): + r"""Tests for Hamiltonian options and processing.""" + + def test_qubit_lo_default_from_backend(self): + """Test drawing of defaults form a backend.""" + test_model = self._simple_system_model() + default_qubit_lo_freq = self._default_qubit_lo_freq + default_u_lo_freq = self._compute_u_lo_freqs(default_qubit_lo_freq) + + # test output of default qubit_lo_freq + freqs = test_model.calculate_channel_frequencies() + self.assertAlmostEqual(freqs['D0'], default_qubit_lo_freq[0]) + self.assertAlmostEqual(freqs['D1'], default_qubit_lo_freq[1]) + self.assertAlmostEqual(freqs['U0'], default_u_lo_freq[0]) + self.assertAlmostEqual(freqs['U1'], default_u_lo_freq[1]) + + # test defaults again, but with non-default hamiltonian + test_model = self._simple_system_model(v0=5.1, v1=4.9, j=0.02) + freqs = test_model.calculate_channel_frequencies() + self.assertAlmostEqual(freqs['D0'], default_qubit_lo_freq[0]) + self.assertAlmostEqual(freqs['D1'], default_qubit_lo_freq[1]) + self.assertAlmostEqual(freqs['U0'], default_u_lo_freq[0]) + self.assertAlmostEqual(freqs['U1'], default_u_lo_freq[1]) + + def test_qubit_lo_from_hamiltonian(self): + """Test computation of qubit_lo_freq from the hamiltonian itself.""" + test_model = self._simple_system_model() + + qubit_lo_from_hamiltonian = test_model.hamiltonian.get_qubit_lo_from_drift() + freqs = test_model.calculate_channel_frequencies(qubit_lo_from_hamiltonian) + self.assertAlmostEqual(freqs['D0'], 4.999009804864) + self.assertAlmostEqual(freqs['D1'], 5.100990195135) + self.assertAlmostEqual(freqs['U0'], 4.999009804864) + self.assertAlmostEqual(freqs['U1'], 0.101980390271) + + # test again with different parameters + test_model = self._simple_system_model(v0=5.1, v1=4.9, j=0.02) + qubit_lo_from_hamiltonian = test_model.hamiltonian.get_qubit_lo_from_drift() + freqs = test_model.calculate_channel_frequencies(qubit_lo_from_hamiltonian) + self.assertAlmostEqual(freqs['D0'], 5.101980390271) + self.assertAlmostEqual(freqs['D1'], 4.898019609728) + self.assertAlmostEqual(freqs['U0'], 5.101980390271) + self.assertAlmostEqual(freqs['U1'], -0.203960780543) + + def _compute_u_lo_freqs(self, qubit_lo_freq): + """ + Given qubit_lo_freq, return the computed u_channel_lo. + """ + u_lo_freqs = [] + for scales in self._u_channel_lo: + u_lo_freq = 0 + for u_lo_idx in scales: + qfreq = qubit_lo_freq[u_lo_idx['q']] + qscale = u_lo_idx['scale'][0] + u_lo_freq += qfreq * qscale + u_lo_freqs.append(u_lo_freq) + return u_lo_freqs + +if __name__ == '__main__': + unittest.main() From 9d5a6efd59bd9c78e55eec8863e12b67c8d1d09a Mon Sep 17 00:00:00 2001 From: Juan Gomez Date: Sun, 22 Dec 2019 22:58:16 +0100 Subject: [PATCH 19/24] Migrate ODE function solver to C++ (#442) * Calling c++ implementation of the numeric integrator solver function (just a basic scaffolding) * Adding C++ and helpers code (still not building) * Adding tests for the C++ helpers on Python C API * Adding my ordered_map to guarantee order insertion iteration (ala Python's OrderedDict) * Adding muparserx library for parsing hamiltonian math expressions * Now we can use both Cython and C++ func ODE solver depending on a config param: use_cpp_ode_func * Disabling Pulse simulator related tests for Python 3.5 --- CMakeLists.txt | 48 +- example/pulse_sim.py | 526 ----- example/pulse_sim_cy_fast.py | 272 +++ example/pulse_sim_fast.py | 271 +++ .../providers/aer/noise/errors/errorutils.py | 1 + qiskit/providers/aer/openpulse/qobj/digest.py | 5 + .../providers/aer/openpulse/qobj/op_system.py | 2 + .../providers/aer/openpulse/qobj/opparse.py | 2 +- .../aer/openpulse/qutip_lite/operators.py | 3 +- .../aer/openpulse/qutip_lite/states.py | 6 +- .../aer/openpulse/solver/monte_carlo.py | 20 +- .../providers/aer/openpulse/solver/opsolve.py | 21 +- .../aer/openpulse/solver/rhs_utils.py | 18 +- .../providers/aer/openpulse/solver/unitary.py | 25 +- src/simulators/open_pulse/CMakeLists.txt | 30 + .../open_pulse/eval_hamiltonian.hpp | 106 + src/simulators/open_pulse/iterators.hpp | 91 + src/simulators/open_pulse/log.hpp | 100 + .../open_pulse/numeric_integrator.cpp | 226 ++ .../open_pulse/numeric_integrator.hpp | 34 + .../open_pulse/numeric_integrator_wrapper.pyx | 31 + src/simulators/open_pulse/ordered_map.hpp | 130 ++ src/simulators/open_pulse/python_to_cpp.hpp | 509 +++++ .../open_pulse/test_python_to_cpp.hpp | 87 + .../open_pulse/test_python_to_cpp.pyx | 54 + src/simulators/open_pulse/types.hpp | 27 + src/third-party/headers/muparserx/mpError.cpp | 266 +++ .../headers/muparserx/mpFuncCmplx.cpp | 635 ++++++ .../headers/muparserx/mpFuncCommon.cpp | 272 +++ .../headers/muparserx/mpFuncMatrix.cpp | 249 +++ .../headers/muparserx/mpFuncNonCmplx.cpp | 126 ++ .../headers/muparserx/mpFuncStr.cpp | 180 ++ .../headers/muparserx/mpICallback.cpp | 141 ++ src/third-party/headers/muparserx/mpIOprt.cpp | 170 ++ .../headers/muparserx/mpIPackage.cpp | 51 + .../headers/muparserx/mpIToken.cpp | 325 +++ .../headers/muparserx/mpIValReader.cpp | 72 + .../headers/muparserx/mpIValue.cpp | 449 ++++ .../headers/muparserx/mpIfThenElse.cpp | 100 + .../headers/muparserx/mpOprtBinAssign.cpp | 249 +++ .../headers/muparserx/mpOprtBinCommon.cpp | 589 ++++++ .../headers/muparserx/mpOprtCmplx.cpp | 321 +++ .../headers/muparserx/mpOprtIndex.cpp | 117 ++ .../headers/muparserx/mpOprtMatrix.cpp | 182 ++ .../headers/muparserx/mpOprtNonCmplx.cpp | 423 ++++ .../headers/muparserx/mpOprtPostfixCommon.cpp | 112 + .../headers/muparserx/mpPackageCmplx.cpp | 102 + .../headers/muparserx/mpPackageCommon.cpp | 141 ++ .../headers/muparserx/mpPackageMatrix.cpp | 82 + .../headers/muparserx/mpPackageNonCmplx.cpp | 108 + .../headers/muparserx/mpPackageStr.cpp | 81 + .../headers/muparserx/mpPackageUnit.cpp | 119 ++ .../headers/muparserx/mpParser.cpp | 91 + .../headers/muparserx/mpParserBase.cpp | 1301 ++++++++++++ .../muparserx/mpParserMessageProvider.cpp | 181 ++ src/third-party/headers/muparserx/mpRPN.cpp | 186 ++ .../headers/muparserx/mpScriptTokens.cpp | 74 + src/third-party/headers/muparserx/mpTest.cpp | 1809 +++++++++++++++++ .../headers/muparserx/mpTokenReader.cpp | 1013 +++++++++ .../headers/muparserx/mpValReader.cpp | 347 ++++ src/third-party/headers/muparserx/mpValue.cpp | 804 ++++++++ .../headers/muparserx/mpValueCache.cpp | 105 + .../headers/muparserx/mpVariable.cpp | 395 ++++ src/third-party/linux/lib/libmuparserx.a | Bin 0 -> 3239354 bytes src/third-party/win64/lib/muparserx.lib | Bin 0 -> 4002360 bytes test/terra/__init__.py | 1 - test/terra/backends/test_pulse_simulator.py | 51 +- test/terra/openpulse/test_pulse_digest.py | 10 +- test/terra/test_python_to_cpp.py | 63 + 69 files changed, 14157 insertions(+), 581 deletions(-) delete mode 100644 example/pulse_sim.py create mode 100644 example/pulse_sim_cy_fast.py create mode 100644 example/pulse_sim_fast.py create mode 100644 src/simulators/open_pulse/CMakeLists.txt create mode 100644 src/simulators/open_pulse/eval_hamiltonian.hpp create mode 100644 src/simulators/open_pulse/iterators.hpp create mode 100644 src/simulators/open_pulse/log.hpp create mode 100644 src/simulators/open_pulse/numeric_integrator.cpp create mode 100644 src/simulators/open_pulse/numeric_integrator.hpp create mode 100644 src/simulators/open_pulse/numeric_integrator_wrapper.pyx create mode 100644 src/simulators/open_pulse/ordered_map.hpp create mode 100644 src/simulators/open_pulse/python_to_cpp.hpp create mode 100644 src/simulators/open_pulse/test_python_to_cpp.hpp create mode 100644 src/simulators/open_pulse/test_python_to_cpp.pyx create mode 100644 src/simulators/open_pulse/types.hpp create mode 100644 src/third-party/headers/muparserx/mpError.cpp create mode 100644 src/third-party/headers/muparserx/mpFuncCmplx.cpp create mode 100644 src/third-party/headers/muparserx/mpFuncCommon.cpp create mode 100644 src/third-party/headers/muparserx/mpFuncMatrix.cpp create mode 100644 src/third-party/headers/muparserx/mpFuncNonCmplx.cpp create mode 100644 src/third-party/headers/muparserx/mpFuncStr.cpp create mode 100644 src/third-party/headers/muparserx/mpICallback.cpp create mode 100644 src/third-party/headers/muparserx/mpIOprt.cpp create mode 100644 src/third-party/headers/muparserx/mpIPackage.cpp create mode 100644 src/third-party/headers/muparserx/mpIToken.cpp create mode 100644 src/third-party/headers/muparserx/mpIValReader.cpp create mode 100644 src/third-party/headers/muparserx/mpIValue.cpp create mode 100644 src/third-party/headers/muparserx/mpIfThenElse.cpp create mode 100644 src/third-party/headers/muparserx/mpOprtBinAssign.cpp create mode 100644 src/third-party/headers/muparserx/mpOprtBinCommon.cpp create mode 100644 src/third-party/headers/muparserx/mpOprtCmplx.cpp create mode 100644 src/third-party/headers/muparserx/mpOprtIndex.cpp create mode 100644 src/third-party/headers/muparserx/mpOprtMatrix.cpp create mode 100644 src/third-party/headers/muparserx/mpOprtNonCmplx.cpp create mode 100755 src/third-party/headers/muparserx/mpOprtPostfixCommon.cpp create mode 100644 src/third-party/headers/muparserx/mpPackageCmplx.cpp create mode 100644 src/third-party/headers/muparserx/mpPackageCommon.cpp create mode 100644 src/third-party/headers/muparserx/mpPackageMatrix.cpp create mode 100644 src/third-party/headers/muparserx/mpPackageNonCmplx.cpp create mode 100644 src/third-party/headers/muparserx/mpPackageStr.cpp create mode 100644 src/third-party/headers/muparserx/mpPackageUnit.cpp create mode 100644 src/third-party/headers/muparserx/mpParser.cpp create mode 100644 src/third-party/headers/muparserx/mpParserBase.cpp create mode 100644 src/third-party/headers/muparserx/mpParserMessageProvider.cpp create mode 100644 src/third-party/headers/muparserx/mpRPN.cpp create mode 100644 src/third-party/headers/muparserx/mpScriptTokens.cpp create mode 100644 src/third-party/headers/muparserx/mpTest.cpp create mode 100644 src/third-party/headers/muparserx/mpTokenReader.cpp create mode 100644 src/third-party/headers/muparserx/mpValReader.cpp create mode 100644 src/third-party/headers/muparserx/mpValue.cpp create mode 100644 src/third-party/headers/muparserx/mpValueCache.cpp create mode 100644 src/third-party/headers/muparserx/mpVariable.cpp create mode 100644 src/third-party/linux/lib/libmuparserx.a create mode 100644 src/third-party/win64/lib/muparserx.lib create mode 100644 test/terra/test_python_to_cpp.py diff --git a/CMakeLists.txt b/CMakeLists.txt index 2bd2bc8e57..53177bc138 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -39,6 +39,7 @@ set(AER_SIMULATOR_CPP_EXTERNAL_LIBS "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/headers" "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/macos/lib" "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/win64/lib" + "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/linux/lib" "${USER_LIB_PATH}") # TODO: We may want to change the prefix path for all the environments @@ -178,19 +179,51 @@ endif() message(STATUS "BLAS library found: ${BLAS_LIBRARIES}") +message(STATUS "Looking for spdlog library...") +find_package(spdlog) +if(spdlog_FOUND) + message(STATUS "spdlog found.") + set(SPDLOG_LIB spdlog::spdlog) +else() + message(STATUS "spdlog not found.") + set(SPDLOG_LIB "") +endif() + + +message(STATUS "Looking for muparserx library...") + +set(MUPARSERX_LIB_PATH "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/linux/lib") +if(APPLE) + set(MUPARSERX_LIB_PATH "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/macos/lib") +elseif(WIN32) + set(MUPARSERX_LIB_PATH "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/win32/lib") +endif() + +find_library(MUPARSERX_LIB NAMES libmuparserx.a muparserx HINTS ${MUPARSERX_LIB_PATH}) +if(${MUPARSERX_LIB} MATCHES "MUPARSERX-NOTFOUND") + message(FATAL_ERROR "No muparserx library found") +endif() +message(STATUS "Muparserx library found: ${MUPARSERX_LIB}") +# I keep this disabled on purpose, just in case I need to debug muparserx related problems +# file(GLOB MUPARSERX_SOURCES "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/headers/muparserx/*.cpp") + + # Set dependent libraries set(AER_LIBRARIES - ${OPENMP_EXTERNAL_LIB} - ${BLAS_LIBRARIES} - nlohmann_json - Threads::Threads - ${CMAKE_DL_LIBS}) + ${OPENMP_EXTERNAL_LIB} + ${BLAS_LIBRARIES} + nlohmann_json + Threads::Threads + ${SPDLOG_LIB} + ${CMAKE_DL_LIBS} + ${MUPARSERX_LIB}) # Cython build is only enabled if building through scikit-build. if(SKBUILD) # Terra Addon build add_subdirectory(qiskit/providers/aer/openpulse/cy) add_subdirectory(qiskit/providers/aer/openpulse/qutip_lite/cy) add_subdirectory(qiskit/providers/aer/backends/wrappers) + add_subdirectory(src/simulators/open_pulse) else() # Standalone build add_executable(qasm_simulator ${AER_SIMULATOR_CPP_MAIN}) set_target_properties(qasm_simulator PROPERTIES @@ -209,5 +242,8 @@ endif() # Tests if(BUILD_TESTS) - add_subdirectory(test) + # These tests were meant to be as an example, or template for C++ specific + # code, but they're not being maintained, so we are disabling them until we + # have real C++ tests in the codebase. + # add_subdirectory(test) endif() diff --git a/example/pulse_sim.py b/example/pulse_sim.py deleted file mode 100644 index 0a27b2b2f5..0000000000 --- a/example/pulse_sim.py +++ /dev/null @@ -1,526 +0,0 @@ -#!/usr/bin/env pythonw -# coding: utf-8 - -# ## Open Pulse Simulator - Rabi Example - -# If running the openpulse branch from source, may need to add a symbolic link in site-packages. Also run `python setup.py build_ext --inplace` in openpulse first. - -# In[1]: - - -#Import general libraries (needed for functions) -import numpy as np -import matplotlib.pyplot as plt -from scipy.optimize import curve_fit - -#Import Qiskit classes classes -import qiskit -#from qiskit.providers.aer.noise import NoiseModel -#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error - -import qiskit.pulse as pulse -import qiskit.pulse.pulse_lib as pulse_lib -from qiskit.compiler import assemble -import random -from qiskit.test.mock import FakeOpenPulse2Q - - -# In[2]: - - -qiskit.IBMQ.load_account() - - -# In[3]: - - -#Get a pulse configuration from the fake backend -backend_real = FakeOpenPulse2Q() -back_config = backend_real.configuration().to_dict() -system = pulse.PulseChannelSpec.from_backend(backend_real) - - -# In[4]: - - -#Get pulse simulator backend -backend_sim = qiskit.Aer.get_backend('pulse_simulator') - - -# ## Simulations -# -# ### These need to be run in sequential order -# -# [Rabi Oscillation](#rabi) -# Apply a pulse to Q0 and measure the population evoluation versus pulse amplitude -# -# [Measurement Level 1 for the Readout Test](#readout_test) -#
Prepare the |0> and |1> states and look at the measurement level 1 output -# -# [CR Oscillation](#cr) -#
Look at the Q1 State when we drive Q0 at the frequency of Q1 -# -# [T1](#t1) -#
Demonstrating noise with pulse - -# -# # Simulate a Rabi Oscillation - -# First, we are going to simulate a rabi oscillation, i.e., meausure the qubit state population versus the amplitude of a drive pulse. This is the same example that is in the tutorials. - -# ### Build Pulse Schedule - -# Build on qubit 0 - -# In[5]: - - -#qubit to use for exeperiment -qubit = 0 -# exp configuration -exps = 41 -shots = 512 - -# Rabi pulse -drive_amps = np.linspace(0, 0.9, exps) -drive_samples = 128 -drive_sigma = 16 - -# Measurement pulse -meas_amp = 0.025 -meas_samples = 1200 -meas_sigma = 4 -meas_risefall = 25 - -# Measurement pulse (common for all experiment) -meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp, - sigma=meas_sigma, risefall=meas_risefall, - name='meas_pulse') -acq_cmd=pulse.Acquire(duration=meas_samples) - -# create measurement schedule -measure_and_acquire = meas_pulse(system.qubits[qubit].measure) | acq_cmd(system.acquires, system.memoryslots) - -# Create schedule -schedules = [] -for ii, drive_amp in enumerate(drive_amps): - # drive pulse - rabi_pulse = pulse_lib.gaussian(duration=drive_samples, - amp=drive_amp, - sigma=drive_sigma, name='rabi_pulse_%d' % ii) - - # add commands to schedule - schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp) - - schedule += rabi_pulse(system.qubits[qubit].drive) - schedule += measure_and_acquire << schedule.duration - - schedules.append(schedule) - - -# ### Design the Hamiltonian - -# Let's build a transmon Hamiltonian with anharmonicity to test the Rabi oscillation and CR - -# In[6]: - - -hamiltonian = {} -hamiltonian['h_str'] = [] -#Q0 terms -hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0') -hamiltonian['h_str'].append('np.pi*alpha0*O0*O0') -hamiltonian['h_str'].append('2*np.pi*r*X0||D0') -hamiltonian['h_str'].append('2*np.pi*r*X0||U1') -hamiltonian['h_str'].append('2*np.pi*r*X1||U0') - -#Q1 terms -hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1') -hamiltonian['h_str'].append('np.pi*alpha1*O1*O1') -hamiltonian['h_str'].append('2*np.pi*r*X0||D1') - -#Exchange coupling betwene Q0 and Q1 -hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)') -hamiltonian['vars'] = {'v0': 5.00, 'v1': 5.1, 'j': 0.01, - 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33} - -#set the qubit dimensions to 3 -hamiltonian['qub'] = {'0': 3, '1': 3} - -#update the back_end -back_config['hamiltonian'] = hamiltonian -back_config['noise'] = {} -back_config['dt'] = 1.0 - - -# ### Add Solver Settings - -# Any solver settings also does into the back_config - -# In[7]: - - -back_config['ode_options'] = {} - - -# ### Restrict the Qubits Used in the Simulation - -# We can use a qubit whitelist (`qubit_list`) to restrict the set of qubits used in the solution. The pulse simulator will appropriately alter the Hamiltonian. To start let's assume the list contains the first 2 qubits. - -# In[8]: - - -back_config['qubit_list'] = [0,1] -#back_config['qubit_list'] = None - - -# ### Assemble the qobj with the backend config file and the qubit_list - -# We have to do this step twice to get the dressed frequencies for setting the LO's. Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state. - -# In[9]: - - -rabi_qobj = assemble(schedules, backend_real, - meas_level=1, meas_return='avg', - memory_slots=2, - shots=shots, sim_config = back_config) - - -# In[10]: - - -evals = backend_sim.get_dressed_energies(rabi_qobj) - - -# In[11]: - - -evals/2/np.pi - - -# In[12]: - - -rabi_qobj = assemble(schedules, backend_real, - meas_level=1, meas_return='avg', - memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi, - evals[3]/2/np.pi], - shots=shots, sim_config = back_config) - - -# ### Simulate - -# In[13]: - - -#Note: this is how to run bypassing the backend -#opsys = qiskit.providers.aer.openpulse.qobj.digest.digest_pulse_obj(rabi_qobj.to_dict()) -#simdata = qiskit.providers.aer.openpulse.solver.opsolve.opsolve(opsys) - - -# In[14]: - - -sim_result = backend_sim.run(rabi_qobj).result() - - -# Extract the qubit populations - -# In[15]: - - -amp_data_Q0 = [] -amp_data_Q1 = [] - -for exp_idx in range(len(drive_amps)): - exp_mem = sim_result.get_memory(exp_idx) - amp_data_Q0.append(np.abs(exp_mem[0])) - amp_data_Q1.append(np.abs(exp_mem[1])) - - -# In[16]: - - -#Fit the data -fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B) -fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5]) - -#get the pi amplitude -pi_amp = (fitparams[3])*fitparams[2]/2/np.pi - -plt.plot(drive_amps, amp_data_Q0, label='Q0') -plt.plot(drive_amps, amp_data_Q1, label='Q1') -plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit') -plt.axvline(pi_amp, color='black', linestyle='dashed') -plt.legend() -plt.xlabel('Pulse amplitude, a.u.', fontsize=20) -plt.ylabel('Signal, a.u.', fontsize=20) -plt.title('Rabi on Q0', fontsize=20) -plt.grid(True) - -print('Pi Amplitude %f'%(pi_amp)) - - -# -# # Look at the Shots Distribution - -# Using the pulse amplitude calibrated above, do an experiment with no pulse and an experiment with a pi pulse and look at the measurement outcomes. - -# In[17]: - - -# Create schedule -pi_pulse = pulse_lib.gaussian(duration=drive_samples, - amp=pi_amp, - sigma=drive_sigma, - name='pi_pulse') - -pi_2_pulse = pulse_lib.gaussian(duration=drive_samples, - amp=pi_amp/2, - sigma=drive_sigma, - name='pi_2_pulse') - -# excited -excited_exp = pulse.Schedule(name='pi_exp') -excited_exp += pi_pulse(system.qubits[qubit].drive) -measure_time = excited_exp.duration -excited_exp |= measure_and_acquire << measure_time - -# superposition -sup_exp = pulse.Schedule(name='pi_2_exp') -sup_exp += pi_2_pulse(system.qubits[qubit].drive) -measure_time = sup_exp.duration -sup_exp |= measure_and_acquire << measure_time - -# ground -ground_exp = pulse.Schedule(name='no_pi_exp') -ground_exp |= pulse.Schedule(name='ground_exp') -ground_exp |= measure_and_acquire << measure_time - -excited_exp_schedules = [ground_exp, sup_exp, excited_exp] - - -# Change the `meas_return=single` which will return each individual measurement - -# In[18]: - - -readout_qobj = assemble(excited_exp_schedules, backend_real, - meas_level=1, meas_return='single', - memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi, - evals[3]/2/np.pi], - shots=shots, sim_config = back_config) - - -# In[19]: - - -sim_result = backend_sim.run(readout_qobj).result() - - -# Plot the data, there is no measurement error in the simulator data so the histographs will be all centered at the average point. - -# In[20]: - - -ground_data = sim_result.get_memory(0)[:, qubit] -excited_data = sim_result.get_memory(2)[:, qubit] -sup_data = sim_result.get_memory(1)[:, qubit] - - -# Add some random noise to the data to better approximate the experiment - -# In[21]: - - -for idx in range(len(ground_data)): - ground_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1) - excited_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1) - sup_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1) - - -# In[22]: - - - -plt.scatter(np.real(ground_data), np.imag(ground_data), s=5, cmap='viridis',c='blue',alpha=0.5, label='|0>') -plt.scatter(np.real(excited_data), np.imag(excited_data), s=5, cmap='viridis',c='green',alpha=0.5, label='|1>') -plt.scatter(np.real(sup_data), np.imag(sup_data), s=5, cmap='viridis',c='red',alpha=0.5, label='|0>+|1>') -ground_center = np.mean(ground_data) -excited_center = np.mean(excited_data) -sup_center = np.mean(sup_data) - -plt.scatter(np.real(ground_center), np.imag(ground_center), c='blue', s=200, alpha=1.0) -plt.scatter(np.real(excited_center), np.imag(excited_center), c='green', s=200, alpha=1.0) -plt.scatter(np.real(sup_center), np.imag(sup_center), c='red', s=200, alpha=1.0) - -plt.title('Kernel integrated I-Q scatter plot', fontsize=20) -plt.legend(loc='upper right') -plt.xlabel('I (a.u.)', fontsize=16) -plt.ylabel('Q (a.u.)', fontsize=16) - - -# -# # Cross-Resonance - -# Simulate cross-resonance by driving on U0. Note you need to run Rabi first to setup the hamiltonian. - -# In[23]: - - -#qubit to use for exeperiment -qubit = 0 -# exp configuration -exps = 41 -shots = 512 - -# Rabi pulse -cr_drive_amps = np.linspace(0, 0.9, exps) -cr_drive_samples = 128*3 -cr_drive_sigma = 4 - - -# Create schedule -schedules = [] -for ii, cr_drive_amp in enumerate(cr_drive_amps): - # drive pulse - cr_rabi_pulse = pulse_lib.gaussian_square(duration=cr_drive_samples, - amp=cr_drive_amp, - risefall=cr_drive_sigma*4, - sigma=cr_drive_sigma, name='rabi_pulse_%d' % ii) - - # add commands to schedule - schedule = pulse.Schedule(name='cr_rabi_exp_amp_%s' % cr_drive_amp) - - schedule += cr_rabi_pulse(system.controls[0]) - schedule += measure_and_acquire << schedule.duration - - schedules.append(schedule) - - -# In[24]: - - -cr_rabi_qobj = assemble(schedules, backend_real, - meas_level=1, meas_return='avg', - memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi, - evals[3]/2/np.pi], - shots=shots, sim_config = back_config) - - -# In[25]: - - -sim_result = backend_sim.run(cr_rabi_qobj).result() - - -# In[26]: - - -amp_data_Q0 = [] -amp_data_Q1 = [] - -for exp_idx in range(len(cr_drive_amps)): - exp_mem = sim_result.get_memory(exp_idx) - amp_data_Q0.append(np.abs(exp_mem[0])) - amp_data_Q1.append(np.abs(exp_mem[1])) - - -# In[27]: - - -plt.plot(drive_amps, amp_data_Q0, label='Q0') -plt.plot(drive_amps, amp_data_Q1, label='Q1') -plt.legend() -plt.xlabel('Pulse amplitude, a.u.', fontsize=20) -plt.ylabel('Signal, a.u.', fontsize=20) -plt.title('CR (Target Q1, driving on Q0)', fontsize=20) -plt.grid(True) - - -# -# # T1 - -# Using the calibrated Pi pulse add a T1 decay channel and simulate a t1 experiment. This can take a while to run. The noise operators in pulse are still a work in progress. - -# In[28]: - - - -t1_times = np.linspace(0,500,10) -t1_times = np.array(t1_times, dtype=int) - -T1_exps = [] -for kk in range(len(t1_times)): - schedule = pulse.Schedule(name='T1_{}'.format(kk)) - schedule |= pi_pulse(system.qubits[qubit].drive) << schedule.duration - schedule |= measure_and_acquire << int(t1_times[kk]) + schedule.duration - T1_exps.append(schedule) - - -# In[29]: - - -# Add noise to the Hamiltonian on qubit '0' -back_config['noise'] = {"qubit": - {"0": - {"Sm": 0.006 - }}} -#back_config['noise'] = {} - - -# In[30]: - - -t1_qobj = assemble(T1_exps, backend_real, - meas_level=1, meas_return='avg', - memory_slots=2, qubit_lo_freq = [evals[1]/2/np.pi, - evals[3]/2/np.pi], - shots=100, sim_config = back_config) - - -# In[31]: - - -sim_result_t1 = backend_sim.run(t1_qobj).result() - - -# In[32]: - - -t1_data_Q0 = [] -t1_data_Q1 = [] - - -for exp_idx in range(len(t1_times)): - exp_mem = sim_result_t1.get_memory(exp_idx) - t1_data_Q0.append(np.abs(exp_mem[0])) - t1_data_Q1.append(np.abs(exp_mem[1])) - - -# In[33]: - - -#Fit the data -fit_func_t1 = lambda x,A,B,T: (A*np.exp(-x/T)+B) -fitparams, conv = curve_fit(fit_func_t1, t1_times, t1_data_Q0, [0.5,0.5,100]) - - -plt.plot(t1_times, t1_data_Q0, label='Q0') -plt.plot(t1_times, t1_data_Q1, label='Q1') -plt.plot(t1_times, fit_func_t1(t1_times, *fitparams), color='black', linestyle='dashed', label='Fit') - -plt.legend() -plt.xlabel('Wait Time (dt)', fontsize=20) -plt.ylabel('Signal, a.u.', fontsize=20) -plt.ylim([0,1.05]) -plt.title('T1 on Q0', fontsize=20) -plt.grid(True) - - -# In[ ]: - - - - diff --git a/example/pulse_sim_cy_fast.py b/example/pulse_sim_cy_fast.py new file mode 100644 index 0000000000..0b60aaffec --- /dev/null +++ b/example/pulse_sim_cy_fast.py @@ -0,0 +1,272 @@ +#!/usr/bin/env python +# coding: utf-8 + +# ## Open Pulse Simulator - Rabi Example + +# If running the openpulse branch from source, may need to add a symbolic link in site-packages. Also run `python setup.py build_ext --inplace` in openpulse first. + +# In[1]: + + +#Import general libraries (needed for functions) +import numpy as np +import matplotlib.pyplot as plt +from scipy.optimize import curve_fit + +#Import Qiskit classes classes +import qiskit +#from qiskit.providers.aer.noise import NoiseModel +#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error + +import qiskit.pulse as pulse +import qiskit.pulse.pulse_lib as pulse_lib +from qiskit.compiler import assemble +import random +from qiskit.test.mock import FakeOpenPulse2Q + + +# In[2]: + + +#Get a pulse configuration from the fake backend +backend_real = FakeOpenPulse2Q() +configuration = backend_real.configuration() +system = pulse.PulseChannelSpec.from_backend(backend_real) + + +# In[3]: + + +#Get pulse simulator backend +backend_sim = qiskit.Aer.get_backend('pulse_simulator') + + +# ## Simulations +# +# ### These need to be run in sequential order +# +# [Rabi Oscillation](#rabi) +# Apply a pulse to Q0 and measure the population evoluation versus pulse amplitude +# +# [Measurement Level 1 for the Readout Test](#readout_test) +#
Prepare the |0> and |1> states and look at the measurement level 1 output +# +# [CR Oscillation](#cr) +#
Look at the Q1 State when we drive Q0 at the frequency of Q1 +# +# [T1](#t1) +#
Demonstrating noise with pulse + +# +# # Simulate a Rabi Oscillation + +# First, we are going to simulate a rabi oscillation, i.e., meausure the qubit state population versus the amplitude of a drive pulse. This is the same example that is in the tutorials. + +# ### Build Pulse Schedule + +# Build on qubit 0 + +# In[4]: + + +#qubit to use for exeperiment +qubit = 0 +# exp configuration +exps = 41 +shots = 512 + +# Rabi pulse +drive_amps = np.linspace(0, 0.9, exps) +drive_samples = 128 +drive_sigma = 16 + +# Measurement pulse +meas_amp = 0.025 +meas_samples = 1200 +meas_sigma = 4 +meas_risefall = 25 + +# Measurement pulse (common for all experiment) +meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp, + sigma=meas_sigma, risefall=meas_risefall, + name='meas_pulse') +acq_cmd=pulse.Acquire(duration=meas_samples) + +# create measurement schedule +measure_and_acquire = meas_pulse(system.qubits[qubit].measure) | acq_cmd(system.acquires, system.memoryslots) + +# Create schedule +schedules = [] +for ii, drive_amp in enumerate(drive_amps): + # drive pulse + rabi_pulse = pulse_lib.gaussian(duration=drive_samples, + amp=drive_amp, + sigma=drive_sigma, name='rabi_pulse_%d' % ii) + + # add commands to schedule + schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp) + + schedule += rabi_pulse(system.qubits[qubit].drive) + schedule += measure_and_acquire << schedule.duration + + schedules.append(schedule) + + +# ### Design the Hamiltonian + +# Let's build a transmon Hamiltonian with anharmonicity to test the Rabi oscillation and CR + +# In[5]: + + +hamiltonian = {} +hamiltonian['h_str'] = [] +#Q0 terms +hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0') +hamiltonian['h_str'].append('np.pi*alpha0*O0*O0') +hamiltonian['h_str'].append('2*np.pi*r*X0||D0') +hamiltonian['h_str'].append('2*np.pi*r*X0||U1') +hamiltonian['h_str'].append('2*np.pi*r*X1||U0') + +#Q1 terms +hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1') +hamiltonian['h_str'].append('np.pi*alpha1*O1*O1') +hamiltonian['h_str'].append('2*np.pi*r*X1||D1') + +#Exchange coupling betwene Q0 and Q1 +hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)') +hamiltonian['vars'] = {'v0': 5.00, 'v1': 5.1, 'j': 0.01, + 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33} + +#set the qubit dimensions to 3 +hamiltonian['qub'] = {'0': 3, '1': 3} + + +# ### Setup backend_options for simulation + +# First copy the real-device configuration to our backend options, then override the Hamiltonian with our custom Hamiltonian, and add any additional solver options. + +# In[6]: + + +backend_options = configuration.to_dict() +backend_options['hamiltonian'] = hamiltonian +backend_options['dt'] = 1.0 +backend_options['ode_options'] = {} +backend_options['use_cpp_ode_func'] = False + + +# ### Restrict the Qubits Used in the Simulation + +# We can use a qubit whitelist (`qubit_list`) to restrict the set of qubits used in the solution. The pulse simulator will appropriately alter the Hamiltonian. To start let's assume the list contains the first 2 qubits. + +# In[7]: + + +backend_options['qubit_list'] = [0, 1] +#backend_options['qubit_list'] = None + + +# ### Assemble the qobj with the backend config file and the qubit_list + +# We have to do this step twice to get the dressed frequencies for setting the LO's. Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state. + +# In[8]: + + +rabi_qobj_no_lo = assemble(schedules, backend_real, + meas_level=1, meas_return='avg', + memory_slots=2, + shots=shots) + + +# In[9]: + + +evals, estates = backend_sim.get_dressed_energies(rabi_qobj_no_lo, + backend_options=backend_options) + + +# In[10]: + + +evals/2/np.pi + + +# In[11]: + + +qubit_lo_freq = [evals[1]/2/np.pi, evals[3]/2/np.pi] + +rabi_qobj = assemble(schedules, backend_real, + meas_level=1, meas_return='avg', + memory_slots=2, qubit_lo_freq=qubit_lo_freq, + shots=shots) + + +# ### Simulate + +# In[12]: + + +#Note: this is how to run bypassing the backend +#opsys = qiskit.providers.aer.openpulse.qobj.digest.digest_pulse_obj(rabi_qobj.to_dict()) +#simdata = qiskit.providers.aer.openpulse.solver.opsolve.opsolve(opsys) + + +# In[13]: + + +sim_result = backend_sim.run(rabi_qobj, backend_options=backend_options).result() + + +# In[14]: + + +#get the end time of the simulation in dt +sim_result.results[0].header.ode_t + + +# In[15]: + + +#get the statevector IN THE FRAME OF THE ORIGINAL HAMILTONIAN +sim_result.get_statevector(0) + + +# Extract the qubit populations + +# In[16]: + + +amp_data_Q0 = [] +amp_data_Q1 = [] + +for exp_idx in range(len(drive_amps)): + exp_mem = sim_result.get_memory(exp_idx) + amp_data_Q0.append(np.abs(exp_mem[0])) + amp_data_Q1.append(np.abs(exp_mem[1])) + + +# In[17]: + + +#Fit the data +fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B) +fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5]) + +#get the pi amplitude +pi_amp = (fitparams[3])*fitparams[2]/2/np.pi + +plt.plot(drive_amps, amp_data_Q0, label='Q0') +plt.plot(drive_amps, amp_data_Q1, label='Q1') +plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit') +plt.axvline(pi_amp, color='black', linestyle='dashed') +plt.legend() +plt.xlabel('Pulse amplitude, a.u.', fontsize=20) +plt.ylabel('Signal, a.u.', fontsize=20) +plt.title('Rabi on Q0', fontsize=20) +plt.grid(True) + +print('Pi Amplitude %f'%(pi_amp)) + diff --git a/example/pulse_sim_fast.py b/example/pulse_sim_fast.py new file mode 100644 index 0000000000..16ed207a79 --- /dev/null +++ b/example/pulse_sim_fast.py @@ -0,0 +1,271 @@ +#!/usr/bin/env python +# coding: utf-8 + +# ## Open Pulse Simulator - Rabi Example + +# If running the openpulse branch from source, may need to add a symbolic link in site-packages. Also run `python setup.py build_ext --inplace` in openpulse first. + +# In[1]: + + +#Import general libraries (needed for functions) +import numpy as np +import matplotlib.pyplot as plt +from scipy.optimize import curve_fit + +#Import Qiskit classes classes +import qiskit +#from qiskit.providers.aer.noise import NoiseModel +#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error + +import qiskit.pulse as pulse +import qiskit.pulse.pulse_lib as pulse_lib +from qiskit.compiler import assemble +import random +from qiskit.test.mock import FakeOpenPulse2Q + + +# In[2]: + + +#Get a pulse configuration from the fake backend +backend_real = FakeOpenPulse2Q() +configuration = backend_real.configuration() +system = pulse.PulseChannelSpec.from_backend(backend_real) + + +# In[3]: + + +#Get pulse simulator backend +backend_sim = qiskit.Aer.get_backend('pulse_simulator') + + +# ## Simulations +# +# ### These need to be run in sequential order +# +# [Rabi Oscillation](#rabi) +# Apply a pulse to Q0 and measure the population evoluation versus pulse amplitude +# +# [Measurement Level 1 for the Readout Test](#readout_test) +#
Prepare the |0> and |1> states and look at the measurement level 1 output +# +# [CR Oscillation](#cr) +#
Look at the Q1 State when we drive Q0 at the frequency of Q1 +# +# [T1](#t1) +#
Demonstrating noise with pulse + +# +# # Simulate a Rabi Oscillation + +# First, we are going to simulate a rabi oscillation, i.e., meausure the qubit state population versus the amplitude of a drive pulse. This is the same example that is in the tutorials. + +# ### Build Pulse Schedule + +# Build on qubit 0 + +# In[4]: + + +#qubit to use for exeperiment +qubit = 0 +# exp configuration +exps = 41 +shots = 512 + +# Rabi pulse +drive_amps = np.linspace(0, 0.9, exps) +drive_samples = 128 +drive_sigma = 16 + +# Measurement pulse +meas_amp = 0.025 +meas_samples = 1200 +meas_sigma = 4 +meas_risefall = 25 + +# Measurement pulse (common for all experiment) +meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp, + sigma=meas_sigma, risefall=meas_risefall, + name='meas_pulse') +acq_cmd=pulse.Acquire(duration=meas_samples) + +# create measurement schedule +measure_and_acquire = meas_pulse(system.qubits[qubit].measure) | acq_cmd(system.acquires, system.memoryslots) + +# Create schedule +schedules = [] +for ii, drive_amp in enumerate(drive_amps): + # drive pulse + rabi_pulse = pulse_lib.gaussian(duration=drive_samples, + amp=drive_amp, + sigma=drive_sigma, name='rabi_pulse_%d' % ii) + + # add commands to schedule + schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp) + + schedule += rabi_pulse(system.qubits[qubit].drive) + schedule += measure_and_acquire << schedule.duration + + schedules.append(schedule) + + +# ### Design the Hamiltonian + +# Let's build a transmon Hamiltonian with anharmonicity to test the Rabi oscillation and CR + +# In[5]: + + +hamiltonian = {} +hamiltonian['h_str'] = [] +#Q0 terms +hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0') +hamiltonian['h_str'].append('np.pi*alpha0*O0*O0') +hamiltonian['h_str'].append('2*np.pi*r*X0||D0') +hamiltonian['h_str'].append('2*np.pi*r*X0||U1') +hamiltonian['h_str'].append('2*np.pi*r*X1||U0') + +#Q1 terms +hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1') +hamiltonian['h_str'].append('np.pi*alpha1*O1*O1') +hamiltonian['h_str'].append('2*np.pi*r*X1||D1') + +#Exchange coupling betwene Q0 and Q1 +hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)') +hamiltonian['vars'] = {'v0': 5.00, 'v1': 5.1, 'j': 0.01, + 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33} + +#set the qubit dimensions to 3 +hamiltonian['qub'] = {'0': 3, '1': 3} + + +# ### Setup backend_options for simulation + +# First copy the real-device configuration to our backend options, then override the Hamiltonian with our custom Hamiltonian, and add any additional solver options. + +# In[6]: + + +backend_options = configuration.to_dict() +backend_options['hamiltonian'] = hamiltonian +backend_options['dt'] = 1.0 +backend_options['ode_options'] = {} + + +# ### Restrict the Qubits Used in the Simulation + +# We can use a qubit whitelist (`qubit_list`) to restrict the set of qubits used in the solution. The pulse simulator will appropriately alter the Hamiltonian. To start let's assume the list contains the first 2 qubits. + +# In[7]: + + +backend_options['qubit_list'] = [0, 1] +#backend_options['qubit_list'] = None + + +# ### Assemble the qobj with the backend config file and the qubit_list + +# We have to do this step twice to get the dressed frequencies for setting the LO's. Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state. + +# In[8]: + + +rabi_qobj_no_lo = assemble(schedules, backend_real, + meas_level=1, meas_return='avg', + memory_slots=2, + shots=shots) + + +# In[9]: + + +evals, estates = backend_sim.get_dressed_energies(rabi_qobj_no_lo, + backend_options=backend_options) + + +# In[10]: + + +evals/2/np.pi + + +# In[11]: + + +qubit_lo_freq = [evals[1]/2/np.pi, evals[3]/2/np.pi] + +rabi_qobj = assemble(schedules, backend_real, + meas_level=1, meas_return='avg', + memory_slots=2, qubit_lo_freq=qubit_lo_freq, + shots=shots) + + +# ### Simulate + +# In[12]: + + +#Note: this is how to run bypassing the backend +#opsys = qiskit.providers.aer.openpulse.qobj.digest.digest_pulse_obj(rabi_qobj.to_dict()) +#simdata = qiskit.providers.aer.openpulse.solver.opsolve.opsolve(opsys) + + +# In[13]: + + +sim_result = backend_sim.run(rabi_qobj, backend_options=backend_options).result() + + +# In[14]: + + +#get the end time of the simulation in dt +sim_result.results[0].header.ode_t + + +# In[15]: + + +#get the statevector IN THE FRAME OF THE ORIGINAL HAMILTONIAN +sim_result.get_statevector(0) + + +# Extract the qubit populations + +# In[16]: + + +amp_data_Q0 = [] +amp_data_Q1 = [] + +for exp_idx in range(len(drive_amps)): + exp_mem = sim_result.get_memory(exp_idx) + amp_data_Q0.append(np.abs(exp_mem[0])) + amp_data_Q1.append(np.abs(exp_mem[1])) + + +# In[17]: + + +#Fit the data +fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B) +fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5]) + +#get the pi amplitude +pi_amp = (fitparams[3])*fitparams[2]/2/np.pi + +plt.plot(drive_amps, amp_data_Q0, label='Q0') +plt.plot(drive_amps, amp_data_Q1, label='Q1') +plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit') +plt.axvline(pi_amp, color='black', linestyle='dashed') +plt.legend() +plt.xlabel('Pulse amplitude, a.u.', fontsize=20) +plt.ylabel('Signal, a.u.', fontsize=20) +plt.title('Rabi on Q0', fontsize=20) +plt.grid(True) + +print('Pi Amplitude %f'%(pi_amp)) + diff --git a/qiskit/providers/aer/noise/errors/errorutils.py b/qiskit/providers/aer/noise/errors/errorutils.py index 9be07b8f13..dcc5fa2aa9 100644 --- a/qiskit/providers/aer/noise/errors/errorutils.py +++ b/qiskit/providers/aer/noise/errors/errorutils.py @@ -557,6 +557,7 @@ def kraus2instructions(kraus_ops, standard_gates, atol=ATOL_DEFAULT): for mat in kraus_ops: # Get the value of the maximum diagonal element # of op.H * op for rescaling + # pylint: disable=no-member prob = abs(max(np.diag(np.conj(np.transpose(mat)).dot(mat)))) if prob > 0.0: if abs(prob - 1) > 0.0: diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 994e09025b..9bfdf16daa 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -115,6 +115,8 @@ def digest_pulse_obj(qobj, system_model, backend_options=None, noise_model=None) estates = [op.state(state) for state in ham_model._estates.T[:]] out.initial_state = estates[0] out.global_data['vars'] = list(out.vars.values()) + # Need this info for evaluating the hamiltonian vars in the c++ solver + out.global_data['vars_names'] = list(out.vars.keys()) out.global_data['freqs'] = list(out.freqs.values()) # Get dt @@ -196,6 +198,9 @@ def digest_pulse_obj(qobj, system_model, backend_options=None, noise_model=None) out.experiments.append(exp_struct) if not exp_struct['can_sample']: out.can_sample = False + + # This is a temporary flag while stabilizing cpp func ODE solver + out.use_cpp_ode_func = qobj_config.get('use_cpp_ode_func', True) return out diff --git a/qiskit/providers/aer/openpulse/qobj/op_system.py b/qiskit/providers/aer/openpulse/qobj/op_system.py index 6d49f82570..00b390d3aa 100644 --- a/qiskit/providers/aer/openpulse/qobj/op_system.py +++ b/qiskit/providers/aer/openpulse/qobj/op_system.py @@ -55,5 +55,7 @@ def __init__(self): self.h_diag = None # eigenvalues of the time-independent hamiltonian self.evals = None + # Use C++ version of the function to pass to the ODE solver or the Cython one + self.use_cpp_ode_func = False # eigenstates of the time-independent hamiltonian self.estates = None diff --git a/qiskit/providers/aer/openpulse/qobj/opparse.py b/qiskit/providers/aer/openpulse/qobj/opparse.py index c2b9419343..dfda280786 100644 --- a/qiskit/providers/aer/openpulse/qobj/opparse.py +++ b/qiskit/providers/aer/openpulse/qobj/opparse.py @@ -90,7 +90,7 @@ def parse(self, qubit_list=None): else: td = p_td.group('ch') token = self._shunting_yard(token) - _td = [self._token2qobj(token), td] + _td = self._token2qobj(token), td self.__td_hams.append(_td) else: diff --git a/qiskit/providers/aer/openpulse/qutip_lite/operators.py b/qiskit/providers/aer/openpulse/qutip_lite/operators.py index 3badefce16..dd3cc049cd 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/operators.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/operators.py @@ -53,7 +53,6 @@ """ import numpy as np -import scipy import scipy.sparse as sp from .fastsparse import fast_csr_matrix, fast_identity @@ -76,7 +75,7 @@ def jmat(j, *args): Raises: TypeError: Invalid input. """ - if (scipy.fix(2 * j) != 2 * j) or (j < 0): + if (np.fix(2 * j) != 2 * j) or (j < 0): raise TypeError('j must be a non-negative integer or half-integer') if not args: diff --git a/qiskit/providers/aer/openpulse/qutip_lite/states.py b/qiskit/providers/aer/openpulse/qutip_lite/states.py index 6bb9534273..a8ae4754e5 100755 --- a/qiskit/providers/aer/openpulse/qutip_lite/states.py +++ b/qiskit/providers/aer/openpulse/qutip_lite/states.py @@ -50,8 +50,6 @@ """ import numpy as np -# pylint: disable=no-name-in-module -from scipy import arange, conj import scipy.sparse as sp from .qobj import Qobj @@ -133,7 +131,7 @@ def coherent(N, alpha, offset=0, method='operator'): x = basis(N, 0) a = destroy(N) - D = (alpha * a.dag() - conj(alpha) * a).expm() + D = (alpha * a.dag() - np.conj(alpha) * a).expm() return D * x elif method == "analytic" or offset > 0: @@ -251,7 +249,7 @@ def thermal_dm(N, n, method='operator'): if n == 0: return fock_dm(N, 0) else: - i = arange(N) + i = np.arange(N) if method == 'operator': beta = np.log(1.0 / n + 1.0) diags = np.exp(-1 * beta * i) diff --git a/qiskit/providers/aer/openpulse/solver/monte_carlo.py b/qiskit/providers/aer/openpulse/solver/monte_carlo.py index fc6983922e..2e25c1ce36 100644 --- a/qiskit/providers/aer/openpulse/solver/monte_carlo.py +++ b/qiskit/providers/aer/openpulse/solver/monte_carlo.py @@ -21,6 +21,7 @@ """Monte carlo wave function solver.""" from math import log +import logging import numpy as np from scipy.integrate import ode from scipy.linalg.blas import get_blas_funcs @@ -33,12 +34,15 @@ dznrm2 = get_blas_funcs("znrm2", dtype=np.float64) -def monte_carlo(seed, exp, global_data, ode_options): +def monte_carlo(seed, exp, op_system): """ Monte Carlo algorithm returning state-vector or expectation values at times tlist for a single trajectory. """ + global_data = op_system.global_data + ode_options = op_system.ode_options + cy_rhs_func = global_data['rhs_func'] rng = np.random.RandomState(seed) tlist = exp['tlist'] @@ -64,10 +68,16 @@ def monte_carlo(seed, exp, global_data, ode_options): ODE = ode(cy_rhs_func) - _inst = 'ODE.set_f_params(%s)' % global_data['string'] - code = compile(_inst, '', 'exec') - # pylint: disable=exec-used - exec(code) + if op_system.use_cpp_ode_func: + # Don't know how to use OrderedDict type on Cython, so transforming it to dict + channels = dict(op_system.channels) + ODE.set_f_params(global_data, exp, op_system.system, channels, register) + else: + _inst = 'ODE.set_f_params(%s)' % global_data['string'] + logging.debug("Monte Carlo: %s\n\n", _inst) + code = compile(_inst, '', 'exec') + # pylint: disable=exec-used + exec(code) # initialize ODE solver for RHS ODE._integrator = qiskit_zvode(method=ode_options.method, diff --git a/qiskit/providers/aer/openpulse/solver/opsolve.py b/qiskit/providers/aer/openpulse/solver/opsolve.py index 82788ad83a..6842c08ded 100644 --- a/qiskit/providers/aer/openpulse/solver/opsolve.py +++ b/qiskit/providers/aer/openpulse/solver/opsolve.py @@ -51,8 +51,9 @@ def opsolve(op_system): # build Hamiltonian data structures op_data_config(op_system) - # compile Cython RHS - _op_generate_rhs(op_system) + if not op_system.use_cpp_ode_func: + # compile Cython RHS + _op_generate_rhs(op_system) # Load cython function _op_func_load(op_system) # load monte carlo class @@ -117,9 +118,7 @@ def run(self): start = time.time() exp_results = parallel_map(unitary_evolution, self.op_system.experiments, - task_args=(self.op_system.global_data, - self.op_system.ode_options - ), + task_args=(self.op_system,), **map_kwargs ) end = time.time() @@ -138,12 +137,8 @@ def run(self): size=self.op_system.global_data['shots']) exp_res = parallel_map(monte_carlo, seeds, - task_args=(exp, - self.op_system.global_data, - self.op_system.ode_options - ), - **map_kwargs - ) + task_args=(exp, self.op_system,), + **map_kwargs) # exp_results is a list for each shot # so transform back to an array of shots @@ -228,7 +223,9 @@ def run(self): all_results.append(results) - _cython_build_cleanup(self.op_system.global_data['rhs_file_name']) + if not self.op_system.use_cpp_ode_func: + _cython_build_cleanup(self.op_system.global_data['rhs_file_name']) + return all_results diff --git a/qiskit/providers/aer/openpulse/solver/rhs_utils.py b/qiskit/providers/aer/openpulse/solver/rhs_utils.py index 7071c914ea..a66240b56d 100644 --- a/qiskit/providers/aer/openpulse/solver/rhs_utils.py +++ b/qiskit/providers/aer/openpulse/solver/rhs_utils.py @@ -40,9 +40,15 @@ def _op_func_load(op_system): Args: op_system (OPSystem): An OpenPulse system object. """ - code = compile('from ' + op_system.global_data['rhs_file_name'] + - ' import cy_td_ode_rhs', '', 'exec') - # pylint: disable=exec-used - exec(code, globals()) - # pylint: disable=undefined-variable - op_system.global_data['rhs_func'] = cy_td_ode_rhs + + if op_system.use_cpp_ode_func: + # pylint: disable=no-name-in-module, import-error, import-outside-toplevel + from ..cy.numeric_integrator_wrapper import td_ode_rhs_static + op_system.global_data['rhs_func'] = td_ode_rhs_static + else: + code = compile('from ' + op_system.global_data['rhs_file_name'] + + ' import cy_td_ode_rhs', '', 'exec') + # pylint: disable=exec-used + exec(code, globals()) + # pylint: disable=undefined-variable + op_system.global_data['rhs_func'] = cy_td_ode_rhs diff --git a/qiskit/providers/aer/openpulse/solver/unitary.py b/qiskit/providers/aer/openpulse/solver/unitary.py index 9766559f58..2e488792c9 100644 --- a/qiskit/providers/aer/openpulse/solver/unitary.py +++ b/qiskit/providers/aer/openpulse/solver/unitary.py @@ -17,6 +17,7 @@ """Module for unitary pulse evolution. """ +import logging import numpy as np from scipy.integrate import ode from scipy.linalg.blas import get_blas_funcs @@ -25,7 +26,7 @@ dznrm2 = get_blas_funcs("znrm2", dtype=np.float64) -def unitary_evolution(exp, global_data, ode_options): +def unitary_evolution(exp, op_system): """ Calculates evolution when there is no noise, or any measurements that are not at the end @@ -33,9 +34,7 @@ def unitary_evolution(exp, global_data, ode_options): Args: exp (dict): Dictionary of experimental pulse and fc - data. - global_data (dict): Data that applies to all experiments. - ode_options (OPoptions): Options for the underlying ODE solver. + op_system (OPSystem): Global OpenPulse system settings Returns: array: Memory of shots. @@ -43,6 +42,10 @@ def unitary_evolution(exp, global_data, ode_options): Raises: Exception: Error in ODE solver. """ + + global_data = op_system.global_data + ode_options = op_system.ode_options + cy_rhs_func = global_data['rhs_func'] rng = np.random.RandomState(exp['seed']) tlist = exp['tlist'] @@ -57,6 +60,16 @@ def unitary_evolution(exp, global_data, ode_options): num_channels = len(exp['channels']) ODE = ode(cy_rhs_func) + if op_system.use_cpp_ode_func: + # Don't know how to use OrderedDict type on Cython, so transforming it to dict + channels = dict(op_system.channels) + ODE.set_f_params(global_data, exp, op_system.system, channels, register) + else: + _inst = 'ODE.set_f_params(%s)' % global_data['string'] + logging.debug("Unitary Evolution: %s\n\n", _inst) + code = compile(_inst, '', 'exec') + exec(code) # pylint disable=exec-used + ODE.set_integrator('zvode', method=ode_options.method, order=ode_options.order, @@ -67,10 +80,6 @@ def unitary_evolution(exp, global_data, ode_options): min_step=ode_options.min_step, max_step=ode_options.max_step) - _inst = 'ODE.set_f_params(%s)' % global_data['string'] - code = compile(_inst, '', 'exec') - exec(code) # pylint disable=exec-used - if not ODE._y: ODE.t = 0.0 ODE._y = np.array([0.0], complex) diff --git a/src/simulators/open_pulse/CMakeLists.txt b/src/simulators/open_pulse/CMakeLists.txt new file mode 100644 index 0000000000..b0399434f1 --- /dev/null +++ b/src/simulators/open_pulse/CMakeLists.txt @@ -0,0 +1,30 @@ +# Cython OP extensions + +include(Linter) +include(cython_utils) + +# We need to remove the -static flag, because Python Extension system only supports +# dynamic linked libraries, but we want to build a shared libraries with the least +# dependencies we can, so some of these dependencies are linked statically into our +# shared library. +string(REPLACE " -static " "" CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS}") + +# Set some general flags +if(APPLE) + message(STATUS "On Mac, we force linking with undefined symbols for Python library, they will be + solved at runtime by the loader") + if(CMAKE_CXX_COMPILER_ID MATCHES "Clang") + set(AER_LINKER_FLAGS "-undefined dynamic_lookup") + else() + # -flat_namespace linker flag is needed otherwise dynamic symbol resolution doesn't work as expected with GCC. + # Symbols with the same name exist in different .so, so the loader just takes the first one it finds, + # which is usually the one from the first .so loaded. + # See: Two-Leve namespace symbol resolution + set(AER_LINKER_FLAGS "-undefined dynamic_lookup -flat_namespace") + endif() + unset(PYTHON_LIBRARIES) +endif() + +set(CYTHON_INSTALL_DIR "qiskit/providers/aer/openpulse/cy/") +add_cython_module(numeric_integrator_wrapper numeric_integrator.cpp) +add_cython_module(test_python_to_cpp) diff --git a/src/simulators/open_pulse/eval_hamiltonian.hpp b/src/simulators/open_pulse/eval_hamiltonian.hpp new file mode 100644 index 0000000000..2753db7405 --- /dev/null +++ b/src/simulators/open_pulse/eval_hamiltonian.hpp @@ -0,0 +1,106 @@ +/** + * This code is part of Qiskit. + * + * (C) Copyright IBM 2018, 2019. + * + * This code is licensed under the Apache License, Version 2.0. You may + * obtain a copy of this license in the LICENSE.txt file in the root directory + * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. + * + * Any modifications or derivative works of this code must retain this + * copyright notice, and modified files need to carry a notice indicating + * that they have been altered from the originals. + */ + +#ifndef _EVAL_HAMILTONIAN_HPP +#define _EVAL_HAMILTONIAN_HPP + +#include +#include +#include +#include +#include +#include + +struct ParserValues { + ParserValues(std::unique_ptr parser, const std::string& expr): + parser(std::move(parser)), expr(expr) { + } + std::unique_ptr parser; + std::string expr; + std::unordered_map> var_values; +}; + +namespace std { + template <> + struct hash{ + std::size_t operator()(const ParserValues& p) const { + return std::hash()(p.expr); + } + }; +} + +// TODO: Document +complex_t evaluate_hamiltonian_expression(const std::string& expr_string, + const std::vector& vars, + const std::vector& vars_names, + const std::unordered_map& chan_values){ + + + static std::unordered_map> parser_expr; + auto parser_iter = parser_expr.find(expr_string); + if(parser_iter == parser_expr.end()){ + auto parserx = std::make_unique(); + //Value pi(M_PI); + //parser->DefineVar("npi", Variable(&pi)); + const auto replace = [](const std::string& from, const std::string& to, std::string where) -> std::string { + size_t start_pos = 0; + while((start_pos = where.find(from, start_pos)) != std::string::npos) { + where.replace(start_pos, from.length(), to); + start_pos += to.length(); + } + return where; + }; + parserx->SetExpr(replace("np.pi", "pi", expr_string)); + auto parser = std::make_unique(std::move(parserx), expr_string); + //std::cout << "Creating parser: " << std::hex << parser.get() << " for expr: " << expr_string << "\n"; + parser_expr.emplace(expr_string, std::move(parser)); + } + auto * parser = parser_expr[expr_string].get(); + + //std::cout << "Getting parser " << std::hex << parser << "\n"; + + auto maybe_update_value = [parser](const std::string& var_name, const complex_t& var_value){ + if(parser->var_values.find(var_name) == parser->var_values.end()){ + parser->var_values.emplace(var_name, std::make_unique(var_value)); + parser->parser->DefineVar(var_name, mup::Variable(parser->var_values[var_name].get())); + }else{ // There's already a variable defined for this expresion + //std::cout << var_name << " is now: " << std::to_string(var_value.real()) << "," << std::to_string(var_value.imag()) << "\n"; + auto * ref = parser->var_values[var_name].get(); + // Update the value from the container + *ref = var_value; + } + }; + + for(const auto& idx_var : enumerate(vars)){ + size_t index = idx_var.first; + auto var_value = static_cast(idx_var.second); + maybe_update_value(vars_names[index], var_value); + } + + for(const auto& idx_channel : chan_values){ + auto channel = idx_channel.first; // The string of the channel + auto var_value = idx_channel.second; // The complex_t of the map + maybe_update_value(channel, var_value); + } + + try{ + mup::Value result = parser->parser->Eval(); + return result.GetComplex(); + }catch(std::exception ex){ + std::cout << ex.what(); + } + return 0.; +} + +#endif //_EVAL_HAMILTONIAN_HPP diff --git a/src/simulators/open_pulse/iterators.hpp b/src/simulators/open_pulse/iterators.hpp new file mode 100644 index 0000000000..64e7919412 --- /dev/null +++ b/src/simulators/open_pulse/iterators.hpp @@ -0,0 +1,91 @@ +/** + * This code is part of Qiskit. + * + * (C) Copyright IBM 2018, 2019. + * + * This code is licensed under the Apache License, Version 2.0. You may + * obtain a copy of this license in the LICENSE.txt file in the root directory + * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. + * + * Any modifications or derivative works of this code must retain this + * copyright notice, and modified files need to carry a notice indicating + * that they have been altered from the originals. + */ + +#ifndef _ITERATORS_HPP +#define _ITERATORS_HPP + +template +struct iterator_extractor { using type = typename T::iterator; }; + +template +struct iterator_extractor { using type = typename T::const_iterator; }; + +/** + * Python-like `enumerate()` for C++14 ranged-for + * + * I wish I'd had this included in the STL :) + * + * Usage: + * ```c++ + * for(auto& elem: index(vec)){ + * std::cout << "Index: " << elem.first << " Element: " << elem.second; + * } + * ``` + **/ +template +class Indexer { +public: + class _Iterator { + using inner_iterator = typename iterator_extractor::type; + using inner_reference = typename std::iterator_traits::reference; + public: + using reference = std::pair; + + _Iterator(inner_iterator it): _pos(0), _it(it) {} + + reference operator*() const { + return reference(_pos, *_it); + } + + _Iterator& operator++() { + ++_pos; + ++_it; + return *this; + } + + _Iterator operator++(int) { + _Iterator tmp(*this); + ++*this; + return tmp; + } + + bool operator==(_Iterator const& it) const { + return _it == it._it; + } + bool operator!=(_Iterator const& it) const { + return !(*this == it); + } + + private: + size_t _pos; + inner_iterator _it; + }; + + Indexer(T& t): _container(t) {} + + _Iterator begin() const { + return _Iterator(_container.begin()); + } + _Iterator end() const { + return _Iterator(_container.end()); + } + +private: + T& _container; +}; // class Indexer + +template +Indexer enumerate(T& t) { return Indexer(t); } + +#endif \ No newline at end of file diff --git a/src/simulators/open_pulse/log.hpp b/src/simulators/open_pulse/log.hpp new file mode 100644 index 0000000000..fac05ea246 --- /dev/null +++ b/src/simulators/open_pulse/log.hpp @@ -0,0 +1,100 @@ +/** + * This code is part of Qiskit. + * + * (C) Copyright IBM 2018, 2019. + * + * This code is licensed under the Apache License, Version 2.0. You may + * obtain a copy of this license in the LICENSE.txt file in the root directory + * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. + * + * Any modifications or derivative works of this code must retain this + * copyright notice, and modified files need to carry a notice indicating + * that they have been altered from the originals. + */ + +#ifndef _LOG_HPP +#define _LOG_HPP + +#include +#include +#include +#include +#include +#include "types.hpp" +#include "python_to_cpp.hpp" +#include "nparray.hpp" + +template +void jlog(const std::string& msg, const T& value){ + spdlog::debug("{}: {}", msg, value); +} + +template<> +void jlog(const std::string& msg, const complex_t& values){ + spdlog::debug("{}: [{},{}i]", msg, values.real(), values.imag()); +} + +template +void jlog(const std::string& msg, const NpArray& values){ + spdlog::debug("{}", msg); + spdlog::debug(".shape: "); + for(const auto& shape : values.shape) + spdlog::debug("{} ", shape); + + spdlog::debug("\n.data: "); + for(const auto& val : values.data){ + jlog("", val); + } +} + +template +void jlog(const std::string& msg, const std::vector& values){ + spdlog::debug("{}", msg); + for(const auto& val : values){ + jlog("", val); + } +} + +template<> +void jlog(const std::string& msg, const std::unordered_map>>& values){ + spdlog::debug("{}", msg); + for(const auto& val : values){ + for(const auto& inner: val.second){ + for(const auto& inner2: inner){ + spdlog::debug("{}:{} ", val.first, inner2); + } + } + } +} + +template<> +void jlog(const std::string& msg, const std::unordered_map& values){ + spdlog::debug("{}", msg); + for(const auto& val : values){ + spdlog::debug("{}:{} ", val.first, val.second); + } +} + +template<> +void jlog(const std::string& msg, const std::unordered_map>>& values){ + spdlog::debug("{}", msg); + for(const auto& val : values){ + for(const auto& inner: val.second){ + jlog(val.first, inner); + } + } +} + +template<> +void jlog(const std::string& msg, const ordered_map>>& values){ + spdlog::debug("{}", msg); + using order_map_t = ordered_map>>; + for(const auto& val : const_cast(values)){ + for(const auto& inner: val.second){ + jlog(val.first, inner); + } + } +} + + +#endif //_LOG_HPP \ No newline at end of file diff --git a/src/simulators/open_pulse/numeric_integrator.cpp b/src/simulators/open_pulse/numeric_integrator.cpp new file mode 100644 index 0000000000..1cd8b0841a --- /dev/null +++ b/src/simulators/open_pulse/numeric_integrator.cpp @@ -0,0 +1,226 @@ +#include +#include +#include +#include +#include +#define _USE_MATH_DEFINES +#include +#include +#include +#ifdef DEBUG +#include +#include +#include +#endif +#include "numeric_integrator.hpp" +#include "python_to_cpp.hpp" + +#ifdef DEBUG +class Unregister { + public: + ~Unregister(){ + spdlog::drop_all(); + } +}; +#endif + +/** + * Python // operator-like division + */ +int32_t floor_div(int32_t a, int32_t b) { + int32_t q = a / b; + int32_t r = a - q*b; + q -= ((r != 0) & ((r ^ b) < 0)); + return q; +} + +complex_t chan_value( + double t, + unsigned int chan_num, + const double freq_ch, + const NpArray& chan_pulse_times, + const NpArray& pulse_array, + const NpArray& pulse_indexes, + const NpArray& fc_array, + const NpArray& reg){ + + static const auto get_arr_idx = [](double t, double start, double stop, size_t len_array) -> int { + return static_cast(std::floor((t - start) / (stop - start) * len_array)); + }; + + complex_t out = {0., 0.}; + auto num_times = floor_div(static_cast(chan_pulse_times.shape[0]), 4); + + for(auto i=0; i < num_times; ++i){ + auto start_time = chan_pulse_times[4 * i]; + auto stop_time = chan_pulse_times[4 * i + 1]; + if(start_time <= t && t < stop_time){ + auto cond = static_cast(chan_pulse_times[4 * i + 3]); + if(cond < 0 || reg[cond]) { + auto temp_idx = static_cast(chan_pulse_times[4 * i + 2]); + auto start_idx = pulse_indexes[temp_idx]; + auto stop_idx = pulse_indexes[temp_idx+1]; + auto offset_idx = get_arr_idx(t, start_time, stop_time, stop_idx - start_idx); + out = pulse_array[start_idx + offset_idx]; + } + } + } + + // TODO floating point comparsion with complex ?! + // Seems like this is equivalent to: out != complex_t(0., 0.) + if(out != 0.){ + double phase = 0.; + num_times = floor_div(fc_array.shape[0], 3); + for(auto i = 0; i < num_times; ++i){ + // TODO floating point comparison + if(t >= fc_array[3 * i]){ + bool do_fc = true; + if(fc_array[3 * i + 2] >= 0){ + if(!reg[static_cast(fc_array[3 * i + 2])]){ + do_fc = false; + } + } + if(do_fc){ + phase += fc_array[3 * i + 1]; + } + }else{ + break; + } + } + if(phase != 0.){ + out *= std::exp(complex_t(0.,1.) * phase); + } + out *= std::exp(complex_t(0., -1.) * 2. * M_PI * freq_ch * t); + } + return out; +} + + +PyArrayObject * create_py_array_from_vector( + complex_t * out, + int num_rows){ + + npy_intp dims = num_rows; + PyArrayObject * array = reinterpret_cast(PyArray_SimpleNewFromData(1, &dims, NPY_COMPLEX128, out)); + PyArray_ENABLEFLAGS(array, NPY_OWNDATA); + #ifdef DEBUG + CALLGRIND_STOP_INSTRUMENTATION; + CALLGRIND_DUMP_STATS; + #endif + return array; +} + +PyArrayObject * td_ode_rhs( + double t, + PyArrayObject * py_vec, + PyObject * py_global_data, + PyObject * py_exp, + PyObject * py_system, + PyObject * py_channels, + PyObject * py_register){ + + #ifdef DEBUG + CALLGRIND_START_INSTRUMENTATION; + #endif + + const static auto numpy_initialized = init_numpy(); + + // I left this commented on porpose so we can use logging eventually + // This is just a RAII for the logger + //const Unregister unregister; + //auto file_logger = spdlog::basic_logger_mt("basic_logger", "logs/td_ode_rhs.txt"); + //spdlog::set_default_logger(file_logger); + //spdlog::set_level(spdlog::level::debug); // Set global log level to debug + //spdlog::flush_on(spdlog::level::debug); + + if(py_vec == nullptr || + py_global_data == nullptr || + py_exp == nullptr || + py_system == nullptr || + py_register == nullptr){ + std::string msg = "These arguments cannot be null: "; + msg += (py_vec == nullptr ? "py_vec " : "" ); + msg += (py_global_data == nullptr ? "py_global_data " : "" ); + msg += (py_exp == nullptr ? "py_exp " : "" ); + msg += (py_system == nullptr ? "py_system " : "" ); + msg += (py_register == nullptr ? "py_register " : "" ); + throw std::invalid_argument(msg); + } + + auto vec = get_value>(py_vec); + auto num_rows = vec.shape[0]; + auto out = static_cast(PyDataMem_NEW_ZEROED(num_rows, sizeof(complex_t))); + + auto pulses = get_ordered_map_from_dict_item>>(py_exp, "channels"); + auto freqs = get_vec_from_dict_item(py_global_data, "freqs"); + auto pulse_array = get_value_from_dict_item>(py_global_data, "pulse_array"); + auto pulse_indices = get_value_from_dict_item>(py_global_data, "pulse_indices"); + auto reg = get_value>(py_register); + + std::unordered_map chan_values; + chan_values.reserve(pulses.size()); + for(const auto& elem : enumerate(pulses)){ + /** + * eleme is map of string as key type, and vector of vectors of doubles. + * elem["D0"] = [[0.,1.,2.][0.,1.,2.]] + **/ + auto i = elem.first; + auto channel = elem.second.first; + auto pulse = elem.second.second; + + auto val = chan_value(t, i, freqs[i], pulse[0], pulse_array, + pulse_indices, pulse[1], reg); + chan_values.emplace(channel, val); + } + + // 4. Eval the time-dependent terms and do SPMV. + auto systems = get_value>(py_system); + auto vars = get_vec_from_dict_item(py_global_data, "vars"); + auto vars_names = get_vec_from_dict_item(py_global_data, "vars_names"); + auto num_h_terms = get_value_from_dict_item(py_global_data, "num_h_terms"); + auto datas = get_vec_from_dict_item>(py_global_data, "h_ops_data"); + auto idxs = get_vec_from_dict_item>(py_global_data, "h_ops_ind"); + auto ptrs = get_vec_from_dict_item>(py_global_data, "h_ops_ptr"); + auto energy = get_value_from_dict_item>(py_global_data, "h_diag_elems"); + for(const auto& idx_sys : enumerate(systems)){ + auto sys_index = idx_sys.first; + auto sys = idx_sys.second; + + // TODO: Refactor + std::string term; + if(sys_index == systems.size() && num_h_terms > systems.size()){ + term = "1.0"; + }else if(sys_index < systems.size()){ + //term = sys.second; + term = sys.term; + }else{ + continue; + } + + auto td = evaluate_hamiltonian_expression(term, vars, vars_names, chan_values); + if(std::abs(td) > 1e-15){ + for(auto i=0; i +#include +#include +#include +#include + +PyArrayObject * td_ode_rhs( + double , + PyArrayObject * , + PyObject * , + PyObject * , + PyObject * , + PyObject * , + PyObject * +); + +#endif // _NUMERIC_INTEGRATOR_HPP \ No newline at end of file diff --git a/src/simulators/open_pulse/numeric_integrator_wrapper.pyx b/src/simulators/open_pulse/numeric_integrator_wrapper.pyx new file mode 100644 index 0000000000..4a031efdf2 --- /dev/null +++ b/src/simulators/open_pulse/numeric_integrator_wrapper.pyx @@ -0,0 +1,31 @@ +#!python +#cython: language_level=3 +# This code is part of Qiskit. +# +# (C) Copyright IBM 2017, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. + +cimport cython +cimport numpy as np + +cdef extern from "numeric_integrator.hpp": + cdef np.ndarray td_ode_rhs( + double t, + np.ndarray vec, + dict global_data, + dict exp, + list system, + dict channels, + register + ) except + + +def td_ode_rhs_static(t, vec, global_data, exp, system, channels, register): + return td_ode_rhs(t, vec, global_data, exp, system, channels, register) + diff --git a/src/simulators/open_pulse/ordered_map.hpp b/src/simulators/open_pulse/ordered_map.hpp new file mode 100644 index 0000000000..0cad0f76fb --- /dev/null +++ b/src/simulators/open_pulse/ordered_map.hpp @@ -0,0 +1,130 @@ +/** + * This code is part of Qiskit. + * + * (C) Copyright IBM 2018, 2019. + * + * This code is licensed under the Apache License, Version 2.0. You may + * obtain a copy of this license in the LICENSE.txt file in the root directory + * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. + * + * Any modifications or derivative works of this code must retain this + * copyright notice, and modified files need to carry a notice indicating + * that they have been altered from the originals. + */ + +#ifndef _ORDERED_MAP_HPP +#define _ORDERED_MAP_HPP + +#include +#include +#include +#include + +template< + class Key, + class T, + class Hash = std::hash, + class KeyEqual = std::equal_to, + class Allocator = std::allocator> +> class ordered_map { + public: + + using unordered_map_t = std::unordered_map; + using vector_t = std::vector; + + auto reserve(size_t size){ + order.reserve(size); + return internal_map.reserve(size); + } + + template + decltype(auto) emplace(Args&&... args) { + const auto first = std::get<0>(std::forward_as_tuple(args...)); + order.emplace_back(first); + return internal_map.emplace(std::forward(args)...); + } + + size_t size(){ + return internal_map.size(); + } + + const T& operator[](const std::string& index) const { + return internal_map[index]; + } + + // This is needed so we can use the container in an iterator context like ranged fors. + template + class ordered_map_iterator_t { + using unordered_map_iter_t = typename _map_t::iterator; + using vec_iter_t = typename _vec_t::iterator; + + _map_t& map; + _vec_t& vec; + + unordered_map_iter_t map_iter; + vec_iter_t vec_iter; + + public: + + using reference = typename unordered_map_iter_t::reference; + using difference_type = typename unordered_map_iter_t::difference_type; + using value_type = typename unordered_map_iter_t::value_type; + using pointer = typename unordered_map_iter_t::reference; + using iterator_category = typename unordered_map_iter_t::iterator_category; + + ordered_map_iterator_t(_map_t& map, + _vec_t& vec) : map(map), vec(vec){ + } + + ordered_map_iterator_t begin() { + vec_iter = vec.begin(); + map_iter = map.find(*vec_iter); + return *this; + } + + ordered_map_iterator_t end() { + vec_iter = vec.end(); + map_iter = map.find(*(vec_iter - 1)); + return *this; + } + + ordered_map_iterator_t operator ++(){ + auto tmp = ++vec_iter; + tmp = (tmp == vec.end()? --tmp: tmp); + map_iter = map.find(*tmp); + return *this; + } + + bool operator ==(const ordered_map_iterator_t& rhs) const { + return vec_iter == rhs.vec_iter; + } + + bool operator !=(const ordered_map_iterator_t& rhs) const { + return vec_iter != rhs.vec_iter; + } + + reference operator *() const { + return *map_iter; + } + }; + + using iterator = ordered_map_iterator_t; + using const_iterator = ordered_map_iterator_t; + + iterator it{internal_map, order}; + + const_iterator begin() { + return it.begin(); + } + + const_iterator end() { + return it.end(); + } + + private: + unordered_map_t internal_map; + vector_t order; + +}; + +#endif //_ORDERED_MAP_HPP \ No newline at end of file diff --git a/src/simulators/open_pulse/python_to_cpp.hpp b/src/simulators/open_pulse/python_to_cpp.hpp new file mode 100644 index 0000000000..cb3563271a --- /dev/null +++ b/src/simulators/open_pulse/python_to_cpp.hpp @@ -0,0 +1,509 @@ +/** + * This code is part of Qiskit. + * + * (C) Copyright IBM 2018, 2019. + * + * This code is licensed under the Apache License, Version 2.0. You may + * obtain a copy of this license in the LICENSE.txt file in the root directory + * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. + * + * Any modifications or derivative works of this code must retain this + * copyright notice, and modified files need to carry a notice indicating + * that they have been altered from the originals. + */ + +#ifndef _PYTHON_TO_CPP_HPP +#define _PYTHON_TO_CPP_HPP + +#include +#include +#include +#include +#include +#include +#include +#ifdef DEBUG +#include +#include +#endif +#include +#include +#include "ordered_map.hpp" +#include "types.hpp" +#include "iterators.hpp" +#include "eval_hamiltonian.hpp" + +static bool init_numpy(){ + static bool initialized = false; + if(!initialized){ + import_array(); + initialized = true; + } +}; + +bool check_is_integer(PyObject * value){ + if(value == nullptr) + throw std::invalid_argument("PyObject is null!"); + + // Seems like this function checks every integer type + if(!PyLong_Check(value)) + return false; + + return true; +} + +bool check_is_string(PyObject * value){ + if(value == nullptr) + throw std::invalid_argument("PyObject is null!"); + + if(!PyUnicode_Check(value)) + return false; + + return true; +} + +bool check_is_floating_point(PyObject * value){ + if(value == nullptr) + throw std::invalid_argument("PyObject is null!"); + + if(!PyFloat_Check(value)) + return false; + + return true; +} + +bool check_is_complex(PyObject * value){ + if(value == nullptr) + throw std::invalid_argument("PyObject is null!"); + + if(!PyComplex_Check(value)) + return false; + + return true; +} + +bool check_is_list(PyObject * value){ + if(value == nullptr) + throw std::invalid_argument("Pyhton list is null!"); + + // Check that it's a list + if(!PyList_Check(value)) + return false; + + return true; +} + +bool check_is_tuple(PyObject * value){ + if(value == nullptr) + throw std::invalid_argument("Pyhton tuple is null!"); + + // Check that it's a tuple + if(!PyTuple_Check(value)) + return false; + + return true; +} + +bool check_is_dict(PyObject * value){ + if(value == nullptr) + throw std::invalid_argument("Pyhton dict is null!"); + + // Check that it's a dict + if(!PyDict_Check(value)) + return false; + + return true; +} + +bool check_is_np_array(PyArrayObject * value){ + if(value == nullptr) + throw std::invalid_argument("Numpy ndarray is null!"); + init_numpy(); + // Check that it's a numpy ndarray + if(!PyArray_Check(value)) + return false; + + return true; +} + + +// Simon Brand technique to achive partial specialization on function templates +// https://www.fluentcpp.com/2017/08/15/function-templates-partial-specialization-cpp/ +// This "type" struct will carry T, but wil be ignored by the compiler later. +// It's like a help you give to the compiler so it can resolve the specialization +template +struct type{}; + +template +T get_value(type _, PyObject * value){ + throw std::invalid_argument("Cannot get value for this type!"); +} + +// TODO: We might want to expose only these two functions +template +T get_value(PyObject * value){ + return get_value(type{}, value); +} + +template +const T get_value(PyArrayObject * value){ + return get_value(type{}, value); +} +// + + +template<> +uint8_t get_value(type _, PyObject * value){ + return get_value(value); +} + +template<> +long get_value(type _, PyObject * value){ + if(!check_is_integer(value)) + throw std::invalid_argument("PyObject is not a long!"); + + long c_value = PyLong_AsLong(value); + auto ex = PyErr_Occurred(); + if(ex) + throw ex; + + return c_value; +} + +template<> +double get_value(type _, PyObject * value){ + if(!check_is_floating_point(value)){ + // it's not a floating point, but maybe an integer? + if(check_is_integer(value)) + return static_cast(get_value(value)); + + throw std::invalid_argument("PyObject is not a double!"); + } + + double c_value = PyFloat_AsDouble(value); + auto ex = PyErr_Occurred(); + if(ex) + throw ex; + + return c_value; +} + +template<> +std::complex get_value(type> _, PyObject * value){ + if(!check_is_complex(value)) + throw std::invalid_argument("PyObject is not a complex number!"); + + Py_complex c_value = PyComplex_AsCComplex(value); + auto ex = PyErr_Occurred(); + if(ex) + throw ex; + + return std::complex(c_value.real, c_value.imag); +} + +template<> +std::string get_value(type _, PyObject * value){ + if(!check_is_string(value)) + throw std::invalid_argument("PyObject is not a string!"); + + auto bytes_str = PyUnicode_AsUTF8String(value); + auto c_str = PyBytes_AsString(bytes_str); + + if(c_str == nullptr) + throw std::invalid_argument("Conversion to utf-8 has failed!"); + + return std::string(c_str); +} + +template +std::vector get_value(type> _, PyObject * value){ + if(!check_is_list(value)) + throw std::invalid_argument("PyObject is not a List!"); + + auto size = PyList_Size(value); + std::vector vector; + vector.reserve(size); + for(auto i=0; i(py_item); + vector.emplace_back(item); + } + return vector; +} + +/* WARNING: There's no support for variadic templates in Cython, so + we use a std::pair because there's no more than two types in the Python + tuples so far, so as we are fine for now... */ +template +std::pair get_value(type> _, PyObject * value){ + if(!check_is_tuple(value)) + throw std::invalid_argument("PyObject is not a Tuple!"); + + if(PyTuple_Size(value) > 2) + throw std::invalid_argument("Tuples with more than 2 elements are not supported yet!!"); + + auto first_py_item = PyTuple_GetItem(value, 0); + if(first_py_item == nullptr) + throw std::invalid_argument("The tuple must have a first element"); + + auto second_py_item = PyTuple_GetItem(value, 1); + if(second_py_item == nullptr) + throw std::invalid_argument("The tuple must have a second element"); + + auto first_item = get_value(first_py_item); + auto second_item = get_value(second_py_item); + + return std::make_pair(first_item, second_item); +} + +template +std::unordered_map get_value(type> _, PyObject * value){ + if(!check_is_dict(value)) + throw std::invalid_argument("PyObject is not a dictonary!!"); + + auto size = PyDict_Size(value); + std::unordered_map map; + map.reserve(size); + + PyObject *key, *val; + Py_ssize_t pos = 0; + while (PyDict_Next(value, &pos, &key, &val)) { + auto inner_key = get_value(key); + auto inner_value = get_value(val); + map.emplace(inner_key, inner_value); + } + return map; +} + +template +const ordered_map get_value(type> _, PyObject * value){ + if(!check_is_dict(value)) + throw std::invalid_argument("PyObject is not a dictonary!!"); + + auto size = PyDict_Size(value); + ordered_map map; + map.reserve(size); + + PyObject *key, *val; + Py_ssize_t pos = 0; + while (PyDict_Next(value, &pos, &key, &val)) { + auto inner_key = get_value(key); + auto inner_value = get_value(val); + map.emplace(inner_key, inner_value); + } + return map; +} + + +template<> +TermExpression get_value(type_, PyObject * value) { + if(!check_is_tuple(value)) + throw std::invalid_argument("PyObject is not a Tuple!"); + + if(PyTuple_Size(value) > 2) + throw std::invalid_argument("Tuples with more than 2 elements are not supported yet!!"); + + auto term = PyTuple_GetItem(value, 1); // 0 is first + if(term == nullptr) + throw std::invalid_argument("The tuple must have a second element"); + + auto term_expr = get_value(term); + return TermExpression(term_expr); +} + + +template +class NpArray { + public: + NpArray(){} + NpArray(PyArrayObject * array){ + _populate_data(array); + _populate_shape(array); + size = array->dimensions[0]; + } + + const VecType * data = nullptr; + size_t size = 0; + + /** + * The shape of the array: like + * ```pyhton + * arr = np.array([0,1,2],[3,4,5]) + * arr.shape + **/ + std::vector shape; + + const VecType& operator[](size_t index) const { + return data[index]; + } + + NpArray& operator=(const NpArray& other){ + data = reinterpret_cast(other.data); + size = other.size; + shape = other.shape; + return *this; + } + + bool operator==(const NpArray& other) const { + if(other.size != size || + other.shape.size() != shape.size()) + return false; + + for(auto i = 0; i < other.size; ++i){ + if(data[i] != other[i]) + return false; + } + + for(auto i = 0; i < other.shape.size(); ++i){ + if(shape[i] != other.shape[i]) + return false; + } + + return true; + } + private: + + void _populate_shape(PyArrayObject * array){ + if(!check_is_np_array(array)) + throw std::invalid_argument("PyArrayObject is not a numpy array!"); + + auto p_dims = PyArray_SHAPE(array); + if(p_dims == nullptr) + throw std::invalid_argument("Couldn't get the shape of the array!"); + + auto num_dims = PyArray_NDIM(array); + shape.reserve(num_dims); + for(auto i = 0; i < num_dims; ++i){ + shape.emplace_back(p_dims[i]); + } + } + + void _populate_data(PyArrayObject * array){ + data = reinterpret_cast(array->data); + } +}; + +template +const NpArray get_value(type> _, PyArrayObject * value){ + if(!check_is_np_array(value)) + throw std::invalid_argument("PyArrayObject is not a numpy array!"); + + return NpArray(value); +} + +template +const NpArray get_value(type> _, PyObject * value) { + PyArrayObject * array = reinterpret_cast(value); + return get_value>(array); +} + + +PyObject * _get_py_value_from_py_dict(PyObject * dict, const std::string& key){ + if(!check_is_dict(dict)) + throw std::invalid_argument("Python dictionary is null!"); + + // PyObject * tmp_key; + // PyObject * value; + // Py_ssize_t pos = 0; + // while (PyDict_Next(dict, &pos, &tmp_key, &value)) { + // auto key_str = get_value(tmp_key); + // if(key_str == key){ + // return value; + // } + // } + return PyDict_GetItemString(dict, key.c_str()); +} + + +/** + * Returns a C++ vector from a Python list that is inside a Pyhton dictionary under a key. + * + * We assume that the item indexed by the key, it's a list: + * ```python + * my_dict = { "key": [1,2,3,4] } + * ``` + * ```c++ + * auto v = get_vec_from_dict_item(pyobj_dict, "key") + * for(auto& elem: v) + * std::cout << elem; + * ``` + * Output: + * ``` + * 1234 + * ``` + * + * @param dict PyObject* A pointer to a PyObject type representing a dictionary + * @return A vector of type VecType from the Pyhton's dictionary key. + **/ +template +const std::vector get_vec_from_dict_item(PyObject * dict, const std::string& item_key){ + PyObject * py_value = _get_py_value_from_py_dict(dict, item_key); + return get_value>(py_value); +} + +/** + * Returns a C++ unordered_map from a Python dictionary that is inside another Pyhton + * dictionary under a key. + * + * We assume that the item indexed by the key, it's a dictionary: + * ```python + * my_dict = { "key": {"inner": 1, "renni": 255} } + * ``` + * ```c++ + * auto m = get_map_from_dict_item(pyobj_dict, "key"); + * for(auto& item: m) + * std::cout << " key:" << item.first << " val:" << item.second; + * ``` + * Output: + * ``` + * key:inner val:1 key:renni val:255 + * ``` + * + * @param dict PyObject* A pointer to a PyObject type representing a dictionary + * @return An unordered map of type from the Pyhton's dictionary key. + **/ +template +const std::unordered_map get_map_from_dict_item(PyObject * dict, const std::string& item_key){ + PyObject * py_value = _get_py_value_from_py_dict(dict, item_key); + return get_value>(py_value); +} + + +template +const ordered_map get_ordered_map_from_dict_item(PyObject * dict, const std::string& item_key){ + PyObject * py_value = _get_py_value_from_py_dict(dict, item_key); + return get_value>(py_value); +} + +/** + * Returns a C++ value of type ValueTyep from a Python numeric that is inside a Pyhton + * dictionary under a key. + * + * We assume that the item indexed by the key, it's a numeric: + * ```python + * my_dict = { "key": 255} } + * ``` + * ```c++ + * auto l = get_value_from_dict_item(pyobj_dict, "key"); + * std::cout << "val: " << l; + * ``` + * Output: + * ``` + * 255 + * ``` + * + * @param dict PyObject* A pointer to a PyObject type representing a dictionary + * @return A long from the Pyhton's dictionary key. + **/ +template +ValueType get_value_from_dict_item(PyObject * dict, const std::string& item_key){ + PyObject * py_value = _get_py_value_from_py_dict(dict, item_key); + if(py_value == Py_None) + return {}; + + return get_value(py_value); +} + +#endif //_PYTHON_TO_CPP_HPP diff --git a/src/simulators/open_pulse/test_python_to_cpp.hpp b/src/simulators/open_pulse/test_python_to_cpp.hpp new file mode 100644 index 0000000000..3db11dce88 --- /dev/null +++ b/src/simulators/open_pulse/test_python_to_cpp.hpp @@ -0,0 +1,87 @@ +/** + * This code is part of Qiskit. + * + * (C) Copyright IBM 2018, 2019. + * + * This code is licensed under the Apache License, Version 2.0. You may + * obtain a copy of this license in the LICENSE.txt file in the root directory + * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. + * + * Any modifications or derivative works of this code must retain this + * copyright notice, and modified files need to carry a notice indicating + * that they have been altered from the originals. + */ + +#ifndef _TEST_HELPERS_HPP +#define _TEST_HELPERS_HPP + +#include +#include +#include +#include +#include +#include +#include +#include "python_to_cpp.hpp" + +// TODO: Test QuantumObj +// TODO: Test Hamiltonian + +bool cpp_test_py_list_to_cpp_vec(PyObject * val){ + // val = [1., 2., 3.] + auto vec = get_value>(val); + auto expected = std::vector{1., 2., 3.}; + return vec == expected; +} + +bool cpp_test_py_list_of_lists_to_cpp_vector_of_vectors(PyObject * val){ + // val = [[1., 2., 3.]] + auto vec = get_value>>(val); + auto expected = std::vector>{{1., 2., 3.}}; + return vec == expected; +} + +bool cpp_test_py_dict_string_numeric_to_cpp_map_string_numeric(PyObject * val){ + // val = {"key": 1} + auto map = get_value>(val); + auto expected = std::unordered_map{{"key", 1}}; + return map == expected; + +} + +bool cpp_test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(PyObject * val){ + // val = {"key": [[1., 2., 3.]]} + auto map = get_value>>>(val); + auto expected = std::unordered_map>>{{"key", {{1., 2., 3.}}}}; + return map == expected; +} + +bool cpp_test_np_array_of_doubles(PyArrayObject * val){ + // val = np.array([0., 1., 2., 3.]) + auto vec = get_value>(val); + if(vec[0] != 0. || vec[1] != 1. || vec[2] != 2. || vec[3] != 3.) + return false; + + return true; +} + +bool cpp_test_evaluate_hamiltonians(PyObject * val){ + // TODO: Add tests! + return false; +} + +bool cpp_test_py_ordered_map(PyObject * val){ + // Ordered map should guarantee insertion order. + // val = {"D0": 1, "U0": 2, "D1": 3, "U1": 4} + std::vector order = {"D0", "U0", "D1", "U1"}; + auto ordered = get_value>(val); + size_t i = 0; + for(const auto& elem: ordered) { + auto key = elem.first; + if(key != order[i++]) + return false; + } + return true; +} + +#endif // _TEST_HELPERS_HPP \ No newline at end of file diff --git a/src/simulators/open_pulse/test_python_to_cpp.pyx b/src/simulators/open_pulse/test_python_to_cpp.pyx new file mode 100644 index 0000000000..c94aa3ea89 --- /dev/null +++ b/src/simulators/open_pulse/test_python_to_cpp.pyx @@ -0,0 +1,54 @@ +#!python +#cython: language_level=3 +# This code is part of Qiskit. +# +# (C) Copyright IBM 2017, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have be + +cimport cython +from cpython.ref cimport PyObject +from libcpp.vector cimport vector +from libcpp.unordered_map cimport unordered_map +from libcpp.string cimport string +from libcpp.complex cimport complex +from libcpp cimport bool +import numpy as np +cimport numpy as np + +# These definitions are only for testing the C++ wrappers over Python C API +cdef extern from "test_python_to_cpp.hpp": + cdef bool cpp_test_py_list_to_cpp_vec(list val) + cdef bool cpp_test_py_list_of_lists_to_cpp_vector_of_vectors(list val) + cdef bool cpp_test_py_dict_string_numeric_to_cpp_map_string_numeric(dict val) + cdef bool cpp_test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(dict val) + cdef bool cpp_test_np_array_of_doubles(np.ndarray val) + cdef bool cpp_test_evaluate_hamiltonians(list val) + cdef bool cpp_test_py_ordered_map(dict val) + +def test_py_list_to_cpp_vec(val): + return cpp_test_py_list_to_cpp_vec(val) + +def test_py_list_of_lists_to_cpp_vector_of_vectors(val): + return cpp_test_py_list_of_lists_to_cpp_vector_of_vectors(val) + +def test_py_dict_string_numeric_to_cpp_map_string_numeric(val): + return cpp_test_py_dict_string_numeric_to_cpp_map_string_numeric(val) + +def test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(val): + return cpp_test_py_dict_string_list_of_list_of_doubles_to_cpp_map_string_vec_of_vecs_of_doubles(val) + +def test_np_array_of_doubles(val): + return cpp_test_np_array_of_doubles(val) + +def test_evaluate_hamiltonians(val): + return cpp_test_evaluate_hamiltonians(val) + +def test_py_ordered_map(val): + return cpp_test_py_ordered_map(val) diff --git a/src/simulators/open_pulse/types.hpp b/src/simulators/open_pulse/types.hpp new file mode 100644 index 0000000000..f8dac3fd30 --- /dev/null +++ b/src/simulators/open_pulse/types.hpp @@ -0,0 +1,27 @@ +/** + * This code is part of Qiskit. + * + * (C) Copyright IBM 2018, 2019. + * + * This code is licensed under the Apache License, Version 2.0. You may + * obtain a copy of this license in the LICENSE.txt file in the root directory + * of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. + * + * Any modifications or derivative works of this code must retain this + * copyright notice, and modified files need to carry a notice indicating + * that they have been altered from the originals. + */ + +#ifndef _TEST_TYPES_HPP +#define _TEST_TYPES_HPP + +#include + +using complex_t = std::complex; + +struct TermExpression { + TermExpression(const std::string& term) : term(term) {} + std::string term; +}; + +#endif // _TEST_TYPES_HPP \ No newline at end of file diff --git a/src/third-party/headers/muparserx/mpError.cpp b/src/third-party/headers/muparserx/mpError.cpp new file mode 100644 index 0000000000..67f7d53fec --- /dev/null +++ b/src/third-party/headers/muparserx/mpError.cpp @@ -0,0 +1,266 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ +#include "mpError.h" +#include "mpIToken.h" +#include "mpParserMessageProvider.h" + + +MUP_NAMESPACE_START + +std::unique_ptr ParserErrorMsg::m_pInstance; + +//------------------------------------------------------------------------------ +const ParserMessageProviderBase& ParserErrorMsg::Instance() +{ + if (!m_pInstance.get()) + { + m_pInstance.reset(new ParserMessageProviderEnglish); + m_pInstance->Init(); + } + + return *m_pInstance; +} + +//------------------------------------------------------------------------------ +void ParserErrorMsg::Reset(ParserMessageProviderBase *pProvider) +{ + if (pProvider != nullptr) + { + m_pInstance.reset(pProvider); + m_pInstance->Init(); + } +} + +//------------------------------------------------------------------------------ +string_type ParserErrorMsg::GetErrorMsg(EErrorCodes eError) const +{ + if (!m_pInstance.get()) + return string_type(); + else + return m_pInstance->GetErrorMsg(eError); +} + + +//--------------------------------------------------------------------------- +ParserErrorMsg::~ParserErrorMsg() +{} + +//--------------------------------------------------------------------------- +ParserErrorMsg::ParserErrorMsg() +{} + +//--------------------------------------------------------------------------- +// +// Error context +// +//--------------------------------------------------------------------------- + +/** \brief Constructs an empty Error context structure. */ +ErrorContext::ErrorContext(EErrorCodes a_iErrc, + int a_iPos, + string_type a_sIdent) + :Expr() + , Ident(a_sIdent) + , Hint() + , Errc(a_iErrc) + , Type1(0) + , Type2(0) + , Arg(-1) + , Pos(a_iPos) +{} + +//--------------------------------------------------------------------------- +ErrorContext::ErrorContext(EErrorCodes iErrc, + int iPos, + string_type sIdent, + char_type cType1, + char_type cType2, + int nArg) + :Expr() + , Ident(sIdent) + , Hint() + , Errc(iErrc) + , Type1(cType1) + , Type2(cType2) + , Arg(nArg) + , Pos(iPos) +{} + +//--------------------------------------------------------------------------- +// +// ParserError class +// +//--------------------------------------------------------------------------- + +ParserError::ParserError() + :m_Err() + , m_sMsg() + , m_ErrMsg(ParserErrorMsg::Instance()) +{} + +//------------------------------------------------------------------------------ +ParserError::ParserError(const string_type &sMsg) + :m_Err() + , m_sMsg(sMsg) + , m_ErrMsg(ParserErrorMsg::Instance()) +{} + +//------------------------------------------------------------------------------ +ParserError::ParserError(const ErrorContext &a_Err) + :m_Err(a_Err) + , m_sMsg() + , m_ErrMsg(ParserErrorMsg::Instance()) +{ + m_sMsg = m_ErrMsg.GetErrorMsg(a_Err.Errc); +} + +//------------------------------------------------------------------------------ +ParserError::ParserError(const ParserError &a_Obj) + :m_Err(a_Obj.m_Err) + , m_sMsg(a_Obj.m_sMsg) + , m_ErrMsg(ParserErrorMsg::Instance()) +{} + +//------------------------------------------------------------------------------ +ParserError& ParserError::operator=(const ParserError &a_Obj) +{ + if (this == &a_Obj) + return *this; + + m_sMsg = a_Obj.m_sMsg; + m_Err = a_Obj.m_Err; + return *this; +} + +//------------------------------------------------------------------------------ +/** \brief Replace all occurences of a substring with another string. */ +void ParserError::ReplaceSubString(string_type &sSource, + const string_type &sFind, + const string_type &sReplaceWith) const +{ + string_type sResult; + string_type::size_type iPos(0), iNext(0); + + for (;;) + { + iNext = sSource.find(sFind, iPos); + sResult.append(sSource, iPos, iNext - iPos); + + if (iNext == string_type::npos) + break; + + sResult.append(sReplaceWith); + iPos = iNext + sFind.length(); + } + + sSource.swap(sResult); +} + + +//------------------------------------------------------------------------------ +/** \brief Replace all occurences of a substring with another string. */ +void ParserError::ReplaceSubString(string_type &sSource, + const string_type &sFind, + int iReplaceWith) const +{ + stringstream_type stream; + stream << iReplaceWith; + ReplaceSubString(sSource, sFind, stream.str()); +} + +//------------------------------------------------------------------------------ +/** \brief Replace all occurences of a substring with another string. */ +void ParserError::ReplaceSubString(string_type &sSource, + const string_type &sFind, + char_type cReplaceWith) const +{ + stringstream_type stream; + stream << cReplaceWith; + ReplaceSubString(sSource, sFind, stream.str()); +} + +//------------------------------------------------------------------------------ +void ParserError::Reset() +{ + m_sMsg = _T(""); + m_Err = ErrorContext(); +} + +//------------------------------------------------------------------------------ +const string_type& ParserError::GetExpr() const +{ + return m_Err.Expr; +} + +//------------------------------------------------------------------------------ +string_type ParserError::GetMsg() const +{ + string_type sMsg(m_sMsg); + ReplaceSubString(sMsg, _T("$EXPR$"), m_Err.Expr); + ReplaceSubString(sMsg, _T("$IDENT$"), m_Err.Ident); + ReplaceSubString(sMsg, _T("$POS$"), m_Err.Pos); + ReplaceSubString(sMsg, _T("$ARG$"), m_Err.Arg); + ReplaceSubString(sMsg, _T("$TYPE1$"), m_Err.Type1); + ReplaceSubString(sMsg, _T("$TYPE2$"), m_Err.Type2); + ReplaceSubString(sMsg, _T("$HINT$"), m_Err.Hint); + return sMsg; +} + +//------------------------------------------------------------------------------ +ErrorContext& ParserError::GetContext() +{ + return m_Err; +} + +//------------------------------------------------------------------------------ +/** \brief Return the expression position related to the error. + + If the error is not related to a distinct position this will return -1 + */ +int ParserError::GetPos() const +{ + return m_Err.Pos; +} + +//------------------------------------------------------------------------------ +/** \brief Return string related with this token (if available). */ +const string_type& ParserError::GetToken() const +{ + return m_Err.Ident; +} + +//------------------------------------------------------------------------------ +/** \brief Return the error code. */ +EErrorCodes ParserError::GetCode() const +{ + return m_Err.Errc; +} +} // namespace mu diff --git a/src/third-party/headers/muparserx/mpFuncCmplx.cpp b/src/third-party/headers/muparserx/mpFuncCmplx.cpp new file mode 100644 index 0000000000..9f97b23439 --- /dev/null +++ b/src/third-party/headers/muparserx/mpFuncCmplx.cpp @@ -0,0 +1,635 @@ +/** \file + \brief Definition of functions for complex valued operations. + +
+               __________                                 ____  ___
+    _____  __ _\______   \_____ _______  ______ __________\   \/  /
+   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
+  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
+  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+        \/                     \/           \/     \/           \_/
+                                       Copyright (C) 2016 Ingo Berg
+                                       All rights reserved.
+
+  muParserX - A C++ math parser library with array and string support
+  Copyright (c) 2016, Ingo Berg
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright notice, 
+     this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright notice, 
+     this list of conditions and the following disclaimer in the documentation 
+     and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+  POSSIBILITY OF SUCH DAMAGE.
+
+*/ +#include "mpFuncCmplx.h" + +//--- Standard includes ---------------------------------------------------- +#include +#include +#include +#include + +//--- Parser framework ----------------------------------------------------- +#include "mpValue.h" +#include "mpError.h" + + +MUP_NAMESPACE_START + + //----------------------------------------------------------------------- + // + // class FunCmplxReal + // + //----------------------------------------------------------------------- + + FunCmplxReal::FunCmplxReal() + :ICallback(cmFUNC, _T("real"), 1) + {} + + //----------------------------------------------------------------------- + FunCmplxReal::~FunCmplxReal() + {} + + //----------------------------------------------------------------------- + void FunCmplxReal::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + float_type v = a_pArg[0]->GetFloat(); + *ret = v; + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxReal::GetDesc() const + { + return _T("real(x) - Returns the real part of the complex number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxReal::Clone() const + { + return new FunCmplxReal(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxImag + // + //----------------------------------------------------------------------- + + FunCmplxImag::FunCmplxImag() + :ICallback(cmFUNC, _T("imag"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxImag::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + float_type v = a_pArg[0]->GetImag(); + *ret = v; + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxImag::GetDesc() const + { + return _T("imag(x) - Returns the imaginary part of the complex number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxImag::Clone() const + { + return new FunCmplxImag(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxConj + // + //----------------------------------------------------------------------- + + FunCmplxConj::FunCmplxConj() + :ICallback(cmFUNC, _T("conj"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxConj::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + *ret = cmplx_type(a_pArg[0]->GetFloat(), -a_pArg[0]->GetImag()); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxConj::GetDesc() const + { + return _T("conj(x) - Returns the complex conjugate of the complex number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxConj::Clone() const + { + return new FunCmplxConj(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxArg + // + //----------------------------------------------------------------------- + + FunCmplxArg::FunCmplxArg() + :ICallback(cmFUNC, _T("arg"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxArg::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = std::arg(v); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxArg::GetDesc() const + { + return _T("arg(x) - Returns the phase angle (or angular component) of the complex number x, expressed in radians."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxArg::Clone() const + { + return new FunCmplxArg(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxNorm + // + //----------------------------------------------------------------------- + + FunCmplxNorm::FunCmplxNorm() + :ICallback(cmFUNC, _T("norm"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxNorm::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = std::norm(v); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxNorm::GetDesc() const + { + return _T("norm(x) - Returns the norm value of the complex number x.") + _T(" The norm value of a complex number is the squared magnitude,") + _T(" defined as the addition of the square of both the real part") + _T(" and the imaginary part (without the imaginary unit). This is") + _T(" the square of abs (x)."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxNorm::Clone() const + { + return new FunCmplxNorm(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxCos + // + //----------------------------------------------------------------------- + + FunCmplxCos::FunCmplxCos() + :ICallback(cmFUNC, _T("cos"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxCos::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + if (a_pArg[0]->IsNonComplexScalar()) + { + *ret = std::cos(a_pArg[0]->GetFloat()); + } + else + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = std::cos(v); + } + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxCos::GetDesc() const + { + return _T("cos(x) - Returns the cosine of the number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxCos::Clone() const + { + return new FunCmplxCos(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxSin + // + //----------------------------------------------------------------------- + + FunCmplxSin::FunCmplxSin() + :ICallback(cmFUNC, _T("sin"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxSin::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + if (a_pArg[0]->IsNonComplexScalar()) + { + *ret = std::sin(a_pArg[0]->GetFloat()); + } + else + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = std::sin(v); + } + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxSin::GetDesc() const + { + return _T("sin(x) - Returns the sine of the number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxSin::Clone() const + { + return new FunCmplxSin(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxCosH + // + //----------------------------------------------------------------------- + + FunCmplxCosH::FunCmplxCosH() + :ICallback(cmFUNC, _T("cosh"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxCosH::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = cosh(v); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxCosH::GetDesc() const + { + return _T("cosh(x) - Returns the hyperbolic cosine of the number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxCosH::Clone() const + { + return new FunCmplxCosH(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxSinH + // + //----------------------------------------------------------------------- + + FunCmplxSinH::FunCmplxSinH() + :ICallback(cmFUNC, _T("sinh"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxSinH::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = sinh(v); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxSinH::GetDesc() const + { + return _T("sinh(x) - Returns the hyperbolic sine of the complex number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxSinH::Clone() const + { + return new FunCmplxSinH(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxTan + // + //----------------------------------------------------------------------- + + FunCmplxTan::FunCmplxTan() + :ICallback(cmFUNC, _T("tan"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxTan::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + if (a_pArg[0]->IsNonComplexScalar()) + { + *ret = std::tan(a_pArg[0]->GetFloat()); + } + else + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = std::tan(v); + } + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxTan::GetDesc() const + { + return _T("tan(x) - Returns the tangens of the number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxTan::Clone() const + { + return new FunCmplxTan(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxTanH + // + //----------------------------------------------------------------------- + + FunCmplxTanH::FunCmplxTanH() + :ICallback(cmFUNC, _T("tanh"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxTanH::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = tanh(v); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxTanH::GetDesc() const + { + return _T("tanh(x) - Returns the hyperbolic tangent of the complex number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxTanH::Clone() const + { + return new FunCmplxTanH(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxSqrt + // + //----------------------------------------------------------------------- + + FunCmplxSqrt::FunCmplxSqrt() + :ICallback(cmFUNC, _T("sqrt"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxSqrt::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + *ret = sqrt((*a_pArg[0]).GetComplex()); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxSqrt::GetDesc() const + { + return _T("sqrt(x) - Returns the square root of x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxSqrt::Clone() const + { + return new FunCmplxSqrt(*this); + } + + + //----------------------------------------------------------------------- + // + // class FunCmplxExp + // + //----------------------------------------------------------------------- + + FunCmplxExp::FunCmplxExp() + :ICallback(cmFUNC, _T("exp"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxExp::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = exp(v); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxExp::GetDesc() const + { + return _T("exp(x) - Returns the base-e exponential of the complex number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxExp::Clone() const + { + return new FunCmplxExp(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxLn + // + //----------------------------------------------------------------------- + + FunCmplxLn::FunCmplxLn() + :ICallback(cmFUNC, _T("ln"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxLn::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = log(v); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxLn::GetDesc() const + { + return _T("ln(x) - Returns the natural (base-e) logarithm of the complex number x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxLn::Clone() const + { + return new FunCmplxLn(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxLog + // + //----------------------------------------------------------------------- + + FunCmplxLog::FunCmplxLog() + :ICallback(cmFUNC, _T("log"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxLog::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = log(v); + } + + + //----------------------------------------------------------------------- + const char_type* FunCmplxLog::GetDesc() const + { + return _T("log(x) - Common logarithm of x, for values of x greater than zero."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxLog::Clone() const + { + return new FunCmplxLog(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxLog10 + // + //----------------------------------------------------------------------- + + FunCmplxLog10::FunCmplxLog10() + :ICallback(cmFUNC, _T("log10"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxLog10::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = log10(v); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxLog10::GetDesc() const + { + return _T("log10(x) - Common logarithm of x, for values of x greater than zero."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxLog10::Clone() const + { + return new FunCmplxLog10(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxLog2 + // + //----------------------------------------------------------------------- + + FunCmplxLog2::FunCmplxLog2() + :ICallback(cmFUNC, _T("log2"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxLog2::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + std::complex v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); + *ret = std::log(v) * (float_type)1.0/std::log((float_type)2.0); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxLog2::GetDesc() const + { + return _T("log2(x) - Logarithm to base 2 of x, for values of x greater than zero."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxLog2::Clone() const + { + return new FunCmplxLog2(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxAbs + // + //----------------------------------------------------------------------- + + FunCmplxAbs::FunCmplxAbs() + :ICallback(cmFUNC, _T("abs"), 1) + {} + + //----------------------------------------------------------------------- + void FunCmplxAbs::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + float_type v = sqrt(a_pArg[0]->GetFloat()*a_pArg[0]->GetFloat() + + a_pArg[0]->GetImag()*a_pArg[0]->GetImag()); + *ret = v; + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxAbs::GetDesc() const + { + return _T("abs(x) - Returns the absolute value of x."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxAbs::Clone() const + { + return new FunCmplxAbs(*this); + } + + //----------------------------------------------------------------------- + // + // class FunCmplxPow + // + //----------------------------------------------------------------------- + + FunCmplxPow::FunCmplxPow() + :ICallback(cmFUNC, _T("pow"), 2) + {} + + //----------------------------------------------------------------------- + void FunCmplxPow::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + *ret = std::pow(a_pArg[0]->GetComplex(), a_pArg[1]->GetComplex()); + } + + //----------------------------------------------------------------------- + const char_type* FunCmplxPow::GetDesc() const + { + return _T("pox(x, y) - Raise x to the power of y."); + } + + //----------------------------------------------------------------------- + IToken* FunCmplxPow::Clone() const + { + return new FunCmplxPow(*this); + } + + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpFuncCommon.cpp b/src/third-party/headers/muparserx/mpFuncCommon.cpp new file mode 100644 index 0000000000..71797ad8a5 --- /dev/null +++ b/src/third-party/headers/muparserx/mpFuncCommon.cpp @@ -0,0 +1,272 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + muParserX - A C++ math parser library with array and string support + Copyright (c) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpFuncCommon.h" + +#include +#include +#include + +#include "mpValue.h" +#include "mpParserBase.h" + + +MUP_NAMESPACE_START + + //------------------------------------------------------------------------------ + // + // FunParserID + // + //------------------------------------------------------------------------------ + + FunParserID::FunParserID() + :ICallback(cmFUNC, _T("parserid"), 0) + {} + + //------------------------------------------------------------------------------ + void FunParserID::Eval(ptr_val_type &ret, const ptr_val_type * /*a_pArg*/, int /*a_iArgc*/) + { + string_type sVer = _T("muParserX V") + GetParent()->GetVersion(); + *ret = sVer; + } + + //------------------------------------------------------------------------------ + const char_type* FunParserID::GetDesc() const + { + return _T("parserid() - muParserX version information"); + } + + //------------------------------------------------------------------------------ + IToken* FunParserID::Clone() const + { + return new FunParserID(*this); + } + + //------------------------------------------------------------------------------ + // + // Max Function + // + //------------------------------------------------------------------------------ + + FunMax::FunMax() : ICallback(cmFUNC, _T("max"), -1) + {} + + //------------------------------------------------------------------------------ + void FunMax::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) + { + if (a_iArgc < 1) + throw ParserError(ErrorContext(ecTOO_FEW_PARAMS, GetExprPos(), GetIdent())); + + float_type max(-1e30), val(0); + for (int i=0; iGetType()) + { + case 'f': + case 'i': val = a_pArg[i]->GetFloat(); break; + case 'n': break; // ignore not in list entries (missing parameter) + case 'c': + default: + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT_FUN; + err.Arg = i+1; + err.Type1 = a_pArg[i]->GetType(); + err.Type2 = 'f'; + throw ParserError(err); + } + } + max = std::max(max, val); + } + + *ret = max; + } + + //------------------------------------------------------------------------------ + const char_type* FunMax::GetDesc() const + { + return _T("max(x,y,...,z) - Returns the maximum value from all of its function arguments."); + } + + //------------------------------------------------------------------------------ + IToken* FunMax::Clone() const + { + return new FunMax(*this); + } + + //------------------------------------------------------------------------------ + // + // Min Function + // + //------------------------------------------------------------------------------ + + FunMin::FunMin() : ICallback(cmFUNC, _T("min"), -1) + {} + + //------------------------------------------------------------------------------ + /** \brief Returns the minimum value of all values. + \param a_pArg Pointer to an array of Values + \param a_iArgc Number of values stored in a_pArg + */ + void FunMin::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) + { + if (a_iArgc < 1) + throw ParserError(ErrorContext(ecTOO_FEW_PARAMS, GetExprPos(), GetIdent())); + + float_type min(1e30), val(min); + + for (int i=0; iGetType()) + { + case 'f': + case 'i': val = a_pArg[i]->GetFloat(); break; + default: + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT_FUN; + err.Arg = i+1; + err.Type1 = a_pArg[i]->GetType(); + err.Type2 = 'f'; + throw ParserError(err); + } + } + min = std::min(min, val); + } + + *ret = min; + } + + //------------------------------------------------------------------------------ + const char_type* FunMin::GetDesc() const + { + return _T("min(x,y,...,z) - Returns the minimum value from all of its function arguments."); + } + + //------------------------------------------------------------------------------ + IToken* FunMin::Clone() const + { + return new FunMin(*this); + } + + //------------------------------------------------------------------------------ + // + // class FunSum + // + //------------------------------------------------------------------------------ + + FunSum::FunSum() + :ICallback(cmFUNC, _T("sum"), -1) + {} + + //------------------------------------------------------------------------------ + /** \brief Returns the minimum value of all values. + \param a_pArg Pointer to an array of Values + \param a_iArgc Number of values stored in a_pArg + */ + void FunSum::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) + { + if (a_iArgc < 1) + throw ParserError(ErrorContext(ecTOO_FEW_PARAMS, GetExprPos(), GetIdent())); + + float_type sum(0); + + for (int i=0; iGetType()) + { + case 'f': + case 'i': sum += a_pArg[i]->GetFloat(); break; + default: + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT_FUN; + err.Arg = i+1; + err.Type1 = a_pArg[i]->GetType(); + err.Type2 = 'f'; + throw ParserError(err); + } + } + } + + *ret = sum; + } + + //------------------------------------------------------------------------------ + const char_type* FunSum::GetDesc() const + { + return _T("sum(x,y,...,z) - Returns the sum of all arguments."); + } + + //------------------------------------------------------------------------------ + IToken* FunSum::Clone() const + { + return new FunSum(*this); + } + + //------------------------------------------------------------------------------ + // + // SizeOf + // + //------------------------------------------------------------------------------ + + FunSizeOf::FunSizeOf() + :ICallback(cmFUNC, _T("sizeof"), 1) + {} + + //------------------------------------------------------------------------------ + FunSizeOf::~FunSizeOf() + {} + + //------------------------------------------------------------------------------ + /** \brief Returns the number of elements stored in the first parameter. */ + void FunSizeOf::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) + { + assert(a_iArgc==1); + *ret = (float_type)a_pArg[0]->GetArray().GetRows(); + } + + //------------------------------------------------------------------------------ + const char_type* FunSizeOf::GetDesc() const + { + return _T("sizeof(a) - Returns the number of elements in a."); + } + + //------------------------------------------------------------------------------ + IToken* FunSizeOf::Clone() const + { + return new FunSizeOf(*this); + } + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpFuncMatrix.cpp b/src/third-party/headers/muparserx/mpFuncMatrix.cpp new file mode 100644 index 0000000000..995e680e7b --- /dev/null +++ b/src/third-party/headers/muparserx/mpFuncMatrix.cpp @@ -0,0 +1,249 @@ +/** \file + \brief Definition of functions for complex valued operations. + +
+               __________                                 ____  ___
+    _____  __ _\______   \_____ _______  ______ __________\   \/  /
+    /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
+    |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
+    |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+          \/                     \/           \/     \/           \_/
+
+    muParserX - A C++ math parser library with array and string support
+    Copyright (c) 2016, Ingo Berg
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+    IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+    
+ */ +#include "mpFuncMatrix.h" + +//--- Standard includes ---------------------------------------------------- +#include +#include +#include +#include + +//--- Parser framework ----------------------------------------------------- +#include "mpValue.h" +#include "mpError.h" + + +MUP_NAMESPACE_START + +//----------------------------------------------------------------------- +// +// class FunMatrixOnes +// +//----------------------------------------------------------------------- + +FunMatrixOnes::FunMatrixOnes() +:ICallback(cmFUNC, _T("ones"), -1) +{} + +//----------------------------------------------------------------------- +FunMatrixOnes::~FunMatrixOnes() +{} + +//----------------------------------------------------------------------- +void FunMatrixOnes::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int argc) +{ + if (argc < 1 || argc>2) + { + ErrorContext err; + err.Errc = ecINVALID_NUMBER_OF_PARAMETERS; + err.Arg = argc; + err.Ident = GetIdent(); + throw ParserError(err); + } + + int_type m = a_pArg[0]->GetInteger(), + n = (argc == 1) ? m : a_pArg[1]->GetInteger(); + + if (m == n && n == 1) + { + *ret = 1.0; // unboxing of 1x1 matrices + } + else + { + *ret = matrix_type(m, n, 1.0); + } +} + +//----------------------------------------------------------------------- +const char_type* FunMatrixOnes::GetDesc() const +{ + return _T("ones(x [, y]) - Returns a matrix whose elements are all 1."); +} + +//----------------------------------------------------------------------- +IToken* FunMatrixOnes::Clone() const +{ + return new FunMatrixOnes(*this); +} + +//----------------------------------------------------------------------- +// +// class FunMatrixZeros +// +//----------------------------------------------------------------------- + +FunMatrixZeros::FunMatrixZeros() + :ICallback(cmFUNC, _T("zeros"), -1) +{} + +//----------------------------------------------------------------------- +FunMatrixZeros::~FunMatrixZeros() +{} + +//----------------------------------------------------------------------- +void FunMatrixZeros::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int argc) +{ + if (argc < 1 || argc>2) + { + ErrorContext err; + err.Errc = ecINVALID_NUMBER_OF_PARAMETERS; + err.Arg = argc; + err.Ident = GetIdent(); + throw ParserError(err); + } + + int_type m = a_pArg[0]->GetInteger(), + n = (argc == 1) ? m : a_pArg[1]->GetInteger(); + + if (m == n && n == 1) + { + *ret = 0.0; // unboxing of 1x1 matrices + } + else + { + *ret = matrix_type(m, n, 0.0); + } +} + +//----------------------------------------------------------------------- +const char_type* FunMatrixZeros::GetDesc() const +{ + return _T("zeros(x [, y]) - Returns a matrix whose elements are all 0."); +} + +//----------------------------------------------------------------------- +IToken* FunMatrixZeros::Clone() const +{ + return new FunMatrixZeros(*this); +} + +//----------------------------------------------------------------------- +// +// class FunMatrixEye +// +//----------------------------------------------------------------------- + +FunMatrixEye::FunMatrixEye() + :ICallback(cmFUNC, _T("eye"), -1) +{} + +//----------------------------------------------------------------------- +FunMatrixEye::~FunMatrixEye() +{} + +//----------------------------------------------------------------------- +void FunMatrixEye::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int argc) +{ + if (argc < 1 || argc>2) + { + ErrorContext err; + err.Errc = ecINVALID_NUMBER_OF_PARAMETERS; + err.Arg = argc; + err.Ident = GetIdent(); + throw ParserError(err); + } + + int_type m = a_pArg[0]->GetInteger(), + n = (argc == 1) ? m : a_pArg[1]->GetInteger(); + + matrix_type eye(m, n, 0.0); + + for (int i = 0; i < std::min(m, n); ++i) + { + eye.At(i, i) = 1.0; + } + + *ret = eye; +} + +//----------------------------------------------------------------------- +const char_type* FunMatrixEye::GetDesc() const +{ + return _T("eye(x, y) - returns a matrix with ones on its diagonal and zeros elsewhere."); +} + +//----------------------------------------------------------------------- +IToken* FunMatrixEye::Clone() const +{ + return new FunMatrixEye(*this); +} + +//----------------------------------------------------------------------- +// +// class FunMatrixSize +// +//----------------------------------------------------------------------- + +FunMatrixSize::FunMatrixSize() + :ICallback(cmFUNC, _T("size"), -1) +{} + +//----------------------------------------------------------------------- +FunMatrixSize::~FunMatrixSize() +{} + +//----------------------------------------------------------------------- +void FunMatrixSize::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int argc) +{ + if (argc != 1) + { + ErrorContext err; + err.Errc = ecINVALID_NUMBER_OF_PARAMETERS; + err.Arg = argc; + err.Ident = GetIdent(); + throw ParserError(err); + } + + matrix_type sz(1, 2, 0.0); + sz.At(0, 0) = (float_type)a_pArg[0]->GetRows(); + sz.At(0, 1) = (float_type)a_pArg[0]->GetCols(); + *ret = sz; +} + +//----------------------------------------------------------------------- +const char_type* FunMatrixSize::GetDesc() const +{ + return _T("size(x) - returns the matrix dimensions."); +} + +//----------------------------------------------------------------------- +IToken* FunMatrixSize::Clone() const +{ + return new FunMatrixSize(*this); +} + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpFuncNonCmplx.cpp b/src/third-party/headers/muparserx/mpFuncNonCmplx.cpp new file mode 100644 index 0000000000..4ea6b7db68 --- /dev/null +++ b/src/third-party/headers/muparserx/mpFuncNonCmplx.cpp @@ -0,0 +1,126 @@ +/** \file + \brief Implementation of basic functions used by muParserX. + +
+               __________                                 ____  ___
+    _____  __ _\______   \_____ _______  ______ __________\   \/  /
+   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
+  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
+  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+        \/                     \/           \/     \/           \_/
+                                       Copyright (C) 2016, Ingo Berg
+                                       All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright notice, 
+     this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright notice, 
+     this list of conditions and the following disclaimer in the documentation 
+     and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+  POSSIBILITY OF SUCH DAMAGE.
+  
+*/ +#include "mpFuncNonCmplx.h" + +//--- Standard includes ---------------------------------------------------- +#include +#include +#include + +//--- muParserX framework -------------------------------------------------- +#include "mpValue.h" +#include "mpError.h" + +#undef log +#undef log2 + +MUP_NAMESPACE_START + +#define MUP_UNARY_FUNC(CLASS, IDENT, FUNC, DESC) \ + CLASS::CLASS() \ + :ICallback(cmFUNC, _T(IDENT), 1) \ + {} \ + \ + void CLASS::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) \ + { \ + *ret = FUNC(a_pArg[0]->GetFloat()); \ + } \ + \ + const char_type* CLASS::GetDesc() const \ + { \ + return _T(DESC); \ + } \ + \ + IToken* CLASS::Clone() const \ + { \ + return new CLASS(*this); \ + } + + // trigonometric functions + MUP_UNARY_FUNC(FunTan, "sin", std::sin, "sine function") + MUP_UNARY_FUNC(FunCos, "cos", std::cos, "cosine function") + MUP_UNARY_FUNC(FunSin, "tan", std::tan, "tangens function") + // arcus functions + MUP_UNARY_FUNC(FunASin, "asin", std::asin, "arcus sine") + MUP_UNARY_FUNC(FunACos, "acos", std::acos, "arcus cosine") + MUP_UNARY_FUNC(FunATan, "atan", std::atan, "arcus tangens") + // hyperbolic functions + MUP_UNARY_FUNC(FunSinH, "sinh", std::sinh, "hyperbolic sine") + MUP_UNARY_FUNC(FunCosH, "cosh", std::cosh, "hyperbolic cosine") + MUP_UNARY_FUNC(FunTanH, "tanh", std::tanh, "hyperbolic tangens") + // hyperbolic arcus functions + MUP_UNARY_FUNC(FunASinH, "asinh", std::asinh, "hyperbolic arcus sine") + MUP_UNARY_FUNC(FunACosH, "acosh", std::acosh, "hyperbolic arcus cosine") + MUP_UNARY_FUNC(FunATanH, "atanh", std::atanh, "hyperbolic arcus tangens") + // logarithm functions + MUP_UNARY_FUNC(FunLog, "log", std::log, "Natural logarithm") + MUP_UNARY_FUNC(FunLog10, "log10", std::log10, "Logarithm base 10") + MUP_UNARY_FUNC(FunLog2, "log2", std::log2, "Logarithm base 2") + MUP_UNARY_FUNC(FunLn, "ln", std::log, "Natural logarithm") + // square root + MUP_UNARY_FUNC(FunSqrt, "sqrt", std::sqrt, "sqrt(x) - square root of x") + MUP_UNARY_FUNC(FunCbrt, "cbrt", std::cbrt, "cbrt(x) - cubic root of x") + MUP_UNARY_FUNC(FunExp, "exp", std::exp, "exp(x) - e to the power of x") + MUP_UNARY_FUNC(FunAbs, "abs", std::fabs, "abs(x) - absolute value of x") +#undef MUP_UNARY_FUNC + +#define MUP_BINARY_FUNC(CLASS, IDENT, FUNC, DESC) \ + CLASS::CLASS() \ + :ICallback(cmFUNC, _T(IDENT), 2) \ + {} \ + \ + void CLASS::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) \ + { \ + *ret = FUNC(a_pArg[0]->GetFloat(), a_pArg[1]->GetFloat()); \ + } \ + \ + const char_type* CLASS::GetDesc() const \ + { \ + return _T(DESC); \ + } \ + \ + IToken* CLASS::Clone() const \ + { \ + return new CLASS(*this); \ + } + + MUP_BINARY_FUNC(FunPow, "pow", std::pow, "pow(x, y) - raise x to the power of y") + MUP_BINARY_FUNC(FunHypot, "hypot", std::hypot, "hypot(x, y) - compute the length of the vector x,y") + MUP_BINARY_FUNC(FunAtan2, "atan2", std::atan2, "arcus tangens with quadrant fix") + MUP_BINARY_FUNC(FunFmod, "fmod", std::fmod, "fmod(x, y) - floating point remainder of x / y") + MUP_BINARY_FUNC(FunRemainder, "remainder", std::remainder, "remainder(x, y) - IEEE remainder of x / y") +#undef MUP_BINARY_FUNC + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpFuncStr.cpp b/src/third-party/headers/muparserx/mpFuncStr.cpp new file mode 100644 index 0000000000..093d016a01 --- /dev/null +++ b/src/third-party/headers/muparserx/mpFuncStr.cpp @@ -0,0 +1,180 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpFuncStr.h" + +#include +#include +#include +#include +#include + +#include "mpValue.h" +#include "mpError.h" + + +MUP_NAMESPACE_START + + //------------------------------------------------------------------------------ + // + // Strlen function + // + //------------------------------------------------------------------------------ + + FunStrLen::FunStrLen() + :ICallback(cmFUNC, _T("strlen"), 1) + {} + + //------------------------------------------------------------------------------ + void FunStrLen::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + string_type str = a_pArg[0]->GetString(); + *ret = (float_type)str.length(); + } + + //------------------------------------------------------------------------------ + const char_type* FunStrLen::GetDesc() const + { + return _T("strlen(s) - Returns the length of the string s."); + } + + //------------------------------------------------------------------------------ + IToken* FunStrLen::Clone() const + { + return new FunStrLen(*this); + } + + //------------------------------------------------------------------------------ + // + // ToUpper function + // + //------------------------------------------------------------------------------ + + FunStrToUpper::FunStrToUpper() + :ICallback(cmFUNC, _T("toupper"), 1) + {} + + //------------------------------------------------------------------------------ + void FunStrToUpper::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + using namespace std; + + string_type str = a_pArg[0]->GetString(); + std::transform(str.begin(), str.end(), str.begin(), ::toupper); + + *ret = str; + } + + //------------------------------------------------------------------------------ + const char_type* FunStrToUpper::GetDesc() const + { + return _T("toupper(s) - Converts the string s to uppercase characters."); + } + + //------------------------------------------------------------------------------ + IToken* FunStrToUpper::Clone() const + { + return new FunStrToUpper(*this); + } + + //------------------------------------------------------------------------------ + // + // ToLower function + // + //------------------------------------------------------------------------------ + + FunStrToLower::FunStrToLower() + :ICallback(cmFUNC, _T("tolower"), 1) + {} + + //------------------------------------------------------------------------------ + void FunStrToLower::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + using namespace std; + + string_type str = a_pArg[0]->GetString(); + std::transform(str.begin(), str.end(), str.begin(), ::tolower); + + *ret = str; + } + + //------------------------------------------------------------------------------ + const char_type* FunStrToLower::GetDesc() const + { + return _T("tolower(s) - Converts the string s to lowercase characters."); + } + + //------------------------------------------------------------------------------ + IToken* FunStrToLower::Clone() const + { + return new FunStrToLower(*this); + } + + //------------------------------------------------------------------------------ + // + // String to double conversion + // + //------------------------------------------------------------------------------ + + FunStrToDbl::FunStrToDbl() + :ICallback(cmFUNC, _T("str2dbl"), 1) + {} + + //------------------------------------------------------------------------------ + void FunStrToDbl::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) + { + assert(a_iArgc==1); + string_type in; + double out; // <- Ich will hier wirklich double, auch wenn der Type long double + // ist. sscanf und long double geht nicht mit GCC! + + in = a_pArg[0]->GetString(); + +#ifndef _UNICODE + sscanf(in.c_str(), "%lf", &out); +#else + swscanf(in.c_str(), _T("%lf"), &out); +#endif + + *ret = (float_type)out; + } + + //------------------------------------------------------------------------------ + const char_type* FunStrToDbl::GetDesc() const + { + return _T("str2dbl(s) - Converts the string stored in s into a floating foint value."); + } + + //------------------------------------------------------------------------------ + IToken* FunStrToDbl::Clone() const + { + return new FunStrToDbl(*this); + } +} // namespace mu diff --git a/src/third-party/headers/muparserx/mpICallback.cpp b/src/third-party/headers/muparserx/mpICallback.cpp new file mode 100644 index 0000000000..1523f75468 --- /dev/null +++ b/src/third-party/headers/muparserx/mpICallback.cpp @@ -0,0 +1,141 @@ +/** \file + \brief Implementation of the interface for parser callback objects. + +
+               __________                                 ____  ___
+    _____  __ _\______   \_____ _______  ______ __________\   \/  /
+   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
+  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
+  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+        \/                     \/           \/     \/           \_/
+                                       Copyright (C) 2016 Ingo Berg
+                                       All rights reserved.
+
+  muParserX - A C++ math parser library with array and string support
+  Copyright (c) 2016, Ingo Berg
+  All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright notice, 
+     this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright notice, 
+     this list of conditions and the following disclaimer in the documentation 
+     and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+  POSSIBILITY OF SUCH DAMAGE.
+
+*/ +#include "mpICallback.h" +#include + +#include "mpParserBase.h" + + +MUP_NAMESPACE_START + + //------------------------------------------------------------------------------ + ICallback::ICallback(ECmdCode a_iCode, + const char_type *a_szName, + int a_nArgc) + :IToken(a_iCode, a_szName) + ,m_pParent(nullptr) + ,m_nArgc(a_nArgc) + ,m_nArgsPresent(-1) + {} + + //------------------------------------------------------------------------------ + ICallback::~ICallback() + {} + + //--------------------------------------------------------------------------- + ICallback* ICallback::AsICallback() + { + return this; + } + + //--------------------------------------------------------------------------- + IValue* ICallback::AsIValue() + { + return nullptr; + } + + //------------------------------------------------------------------------------ + /** \brief Returns a pointer to the parser object owning this callback. + \pre [assert] m_pParent must be defined + */ + ParserXBase* ICallback::GetParent() + { + assert(m_pParent); + return m_pParent; + } + + //------------------------------------------------------------------------------ + void ICallback::SetArgc(int argc) + { + m_nArgc = argc; + } + + //------------------------------------------------------------------------------ + /** \brief Returns the m´number of arguments required by this callback. + \return Number of arguments or -1 if the number of arguments is variable. + */ + int ICallback::GetArgc() const + { + return m_nArgc; + } + + //------------------------------------------------------------------------------ + /** \brief Assign a parser object to the callback. + \param a_pParent The parser that belongs to this callback object. + + The parent object can be used in order to access internals of the parser + from within a callback object. Thus enabling callbacks to delete + variables or functions if this is desired. + */ + void ICallback::SetParent(parent_type *a_pParent) + { + assert(a_pParent); + m_pParent = a_pParent; + } + + //------------------------------------------------------------------------------ + string_type ICallback::AsciiDump() const + { + stringstream_type ss; + + ss << g_sCmdCode[ GetCode() ]; + ss << _T(" [addr=0x") << std::hex << this << std::dec; + ss << _T("; pos=") << GetExprPos(); + ss << _T("; id=\"") << GetIdent() << "\""; + ss << _T("; argc=") << GetArgc() << " (found: " << m_nArgsPresent << ")"; + ss << _T("]"); + + return ss.str(); + } + + //------------------------------------------------------------------------------ + void ICallback::SetNumArgsPresent(int argc) + { + m_nArgsPresent = argc; + } + + //------------------------------------------------------------------------------ + int ICallback::GetArgsPresent() const + { + if (m_nArgc!=-1) + return m_nArgc; + else + return m_nArgsPresent; + } +} // namespace mu diff --git a/src/third-party/headers/muparserx/mpIOprt.cpp b/src/third-party/headers/muparserx/mpIOprt.cpp new file mode 100644 index 0000000000..5ccf807e0c --- /dev/null +++ b/src/third-party/headers/muparserx/mpIOprt.cpp @@ -0,0 +1,170 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + muParserX - A C++ math parser library with array and string support + Copyright (c) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpIOprt.h" + +#include "mpError.h" + + +MUP_NAMESPACE_START + + //------------------------------------------------------------------------------ + // + // Binary Operators + // + //------------------------------------------------------------------------------ + + IOprtBin::IOprtBin(const char_type *a_szIdent, int nPrec, EOprtAsct eAsc) + :ICallback(cmOPRT_BIN, a_szIdent, 2) + ,IPrecedence() + ,m_nPrec(nPrec) + ,m_eAsc(eAsc) + {} + + //------------------------------------------------------------------------------ + IOprtBin::~IOprtBin() + {} + + //------------------------------------------------------------------------------ + string_type IOprtBin::AsciiDump() const + { + stringstream_type ss; + + ss << g_sCmdCode[ GetCode() ]; + ss << _T(" [addr=0x") << std::hex << this << std::dec; + ss << _T("; pos=") << GetExprPos(); + ss << _T("; id=\"") << GetIdent() << _T("\""); + ss << _T("; prec=") << GetPri(); + ss << _T("; argc=") << GetArgc(); + ss << _T("]"); + + return ss.str(); + } + + //------------------------------------------------------------------------------ + int IOprtBin::GetPri() const + { + return m_nPrec; + } + + //------------------------------------------------------------------------------ + EOprtAsct IOprtBin::GetAssociativity() const + { + return m_eAsc; + } + + //--------------------------------------------------------------------------- + IPrecedence* IOprtBin::AsIPrecedence() + { + return this; + } + + //------------------------------------------------------------------------------ + // + // Unary Postfix Operators + // + //------------------------------------------------------------------------------ + + IOprtPostfix::IOprtPostfix(const char_type *a_szIdent) + :ICallback(cmOPRT_POSTFIX, a_szIdent, 1) + {} + + //------------------------------------------------------------------------------ + IOprtPostfix::~IOprtPostfix() + {} + + //------------------------------------------------------------------------------ + string_type IOprtPostfix::AsciiDump() const + { + stringstream_type ss; + + ss << g_sCmdCode[ GetCode() ]; + ss << _T(" [addr=0x") << std::hex << this << std::dec; + ss << _T("; pos=") << GetExprPos(); + ss << _T("; id=\"") << GetIdent() << _T("\""); + ss << _T("; argc=") << GetArgc(); + ss << _T("]"); + + return ss.str(); + } + + //------------------------------------------------------------------------------ + // + // Unary Infix Operators + // + //------------------------------------------------------------------------------ + + IOprtInfix::IOprtInfix(const char_type *a_szIdent, int nPrec) + :ICallback(cmOPRT_INFIX, a_szIdent, 1) + ,IPrecedence() + ,m_nPrec(nPrec) + {} + + //------------------------------------------------------------------------------ + IOprtInfix::~IOprtInfix() + {} + + //------------------------------------------------------------------------------ + string_type IOprtInfix::AsciiDump() const + { + stringstream_type ss; + + ss << g_sCmdCode[ GetCode() ]; + ss << _T(" [addr=0x") << std::hex << this << std::dec; + ss << _T("; pos=") << GetExprPos(); + ss << _T("; id=\"") << GetIdent() << _T("\""); + ss << _T("; argc=") << GetArgc(); + ss << _T("]"); + + return ss.str(); + } + + //--------------------------------------------------------------------------- + IPrecedence* IOprtInfix::AsIPrecedence() + { + return this; + } + + //------------------------------------------------------------------------------ + int IOprtInfix::GetPri() const + { + return m_nPrec; + } + + //------------------------------------------------------------------------------ + EOprtAsct IOprtInfix::GetAssociativity() const + { + return oaNONE; + } +} // namespace mu diff --git a/src/third-party/headers/muparserx/mpIPackage.cpp b/src/third-party/headers/muparserx/mpIPackage.cpp new file mode 100644 index 0000000000..f534584cc5 --- /dev/null +++ b/src/third-party/headers/muparserx/mpIPackage.cpp @@ -0,0 +1,51 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + muParserX - A C++ math parser library with array and string support + Copyright (c) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpIPackage.h" + +#include "mpDefines.h" +#include "mpParserBase.h" + + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------ +IPackage::IPackage() +{} + +//------------------------------------------------------------------------------ +IPackage::~IPackage() +{} + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpIToken.cpp b/src/third-party/headers/muparserx/mpIToken.cpp new file mode 100644 index 0000000000..4f261815ca --- /dev/null +++ b/src/third-party/headers/muparserx/mpIToken.cpp @@ -0,0 +1,325 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + muParserX - A C++ math parser library with array and string support + Copyright (c) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpIToken.h" +#include +#include +#include +#include +#include + +#include "mpIPrecedence.h" + +MUP_NAMESPACE_START + +#ifdef MUP_LEAKAGE_REPORT + std::list IToken::s_Tokens; +#endif + +#ifndef _UNICODE + + //--------------------------------------------------------------------------- + /** \brief Overloaded streaming operator for outputting the value type + into an std::ostream. + \param a_Stream The stream object + \param a_Val The value object to be streamed + + This function is only present if _UNICODE is not defined. + */ + std::ostream& operator<<(std::ostream &a_Stream, const IToken &tok) + { + return a_Stream << tok.ToString(); + } + +#else + + //--------------------------------------------------------------------------- + /** \brief Overloaded streaming operator for outputting the value type + into an std::ostream. + \param a_Stream The stream object + \param a_Val The value object to be streamed + + This function is only present if _UNICODE is defined. + */ + std::wostream& operator<<(std::wostream &a_Stream, const IToken &tok) + { + return a_Stream << tok.ToString(); + } +#endif + +#ifdef MUP_LEAKAGE_REPORT + + void IToken::LeakageReport() + { + using namespace std; + + console() << "\n"; + console() << "Memory leakage report:\n\n"; + if (IToken::s_Tokens.size()) + { + list::const_iterator item = IToken::s_Tokens.begin(); + std::vector stat(cmCOUNT, 0); + for (; item!=IToken::s_Tokens.end(); ++item) + { + console() << "Addr: 0x" << hex << *item << " Ident: \"" << (*item)->GetIdent() << "\""; + console() << "\tCode: " << g_sCmdCode[(*item)->GetCode()] << "\n"; + stat[(*item)->GetCode()]++; + } + console() << "Leaked tokens: " << dec << (int)IToken::s_Tokens.size() << std::endl; + + for (int i=0; i::iterator it = std::find(IToken::s_Tokens.begin(), IToken::s_Tokens.end(), this); + IToken::s_Tokens.remove(this); +#endif + } + + //------------------------------------------------------------------------------ + /** \brief Copy constructor. + \param ref The token to copy basic state information from. + + The copy constructor must be implemented in order not to screw up + the reference count of the created object. CC's are used in the + Clone function and they would start with a reference count != 0 + introducing memory leaks if the default CC where used. + */ + IToken::IToken(const IToken &ref) + { + m_eCode = ref.m_eCode; + m_sIdent = ref.m_sIdent; + m_flags = ref.m_flags; + m_nPosExpr = ref.m_nPosExpr; + + // The following items must be initialised + // (rather than just beeing copied) + m_nRefCount = 0; + } + + //------------------------------------------------------------------------------ + void IToken::ResetRef() + { + m_nRefCount = 0; + } + + //------------------------------------------------------------------------------ + void IToken::Release() + { + delete this; + } + + //------------------------------------------------------------------------------ + string_type IToken::ToString() const + { + return AsciiDump(); + } + + //------------------------------------------------------------------------------ + int IToken::GetExprPos() const + { + return m_nPosExpr; + } + + //------------------------------------------------------------------------------ + void IToken::SetExprPos(int nPos) + { + m_nPosExpr = nPos; + } + + //------------------------------------------------------------------------------ + /** \brief return the token code. + + \sa ECmdCode + */ + ECmdCode IToken::GetCode() const + { + return m_eCode; + } + + //------------------------------------------------------------------------------ + /** \brief Return the token identifier string. */ + const string_type& IToken::GetIdent() const + { + return m_sIdent; + } + + //------------------------------------------------------------------------------ + void IToken::SetIdent(const string_type &a_sIdent) + { + m_sIdent = a_sIdent; + } + + //------------------------------------------------------------------------------ + string_type IToken::AsciiDump() const + { + stringstream_type ss; + ss << g_sCmdCode[m_eCode]; + return ss.str().c_str(); + } + + //------------------------------------------------------------------------------ + void IToken::IncRef() const + { + ++m_nRefCount; + } + + //------------------------------------------------------------------------------ + long IToken::DecRef() const + { + return --m_nRefCount; + } + + //------------------------------------------------------------------------------ + long IToken::GetRef() const + { + return m_nRefCount; + } + + //--------------------------------------------------------------------------- + void IToken::AddFlags(int flags) + { + m_flags |= flags; + } + + //--------------------------------------------------------------------------- + bool IToken::IsFlagSet(int flags) const + { + return (m_flags & flags)==flags; + } + + //--------------------------------------------------------------------------- + ICallback* IToken::AsICallback() + { + return nullptr; + } + + //--------------------------------------------------------------------------- + IValue* IToken::AsIValue() + { + return nullptr; + } + + //--------------------------------------------------------------------------- + IPrecedence* IToken::AsIPrecedence() + { + return nullptr; + } + + //------------------------------------------------------------------------------ + void IToken::Compile(const string_type & /*sArg*/) + { + } + + //--------------------------------------------------------------------------- + // + // Generic token implementation + // + //--------------------------------------------------------------------------- + + GenericToken::GenericToken(ECmdCode a_iCode, string_type a_sIdent) + :IToken(a_iCode, a_sIdent) + {} + + //--------------------------------------------------------------------------- + GenericToken::GenericToken(ECmdCode a_iCode) + :IToken(a_iCode, _T("")) + {} + + //--------------------------------------------------------------------------- + GenericToken::~GenericToken() + {} + + //--------------------------------------------------------------------------- + GenericToken::GenericToken(const GenericToken &a_Tok) + :IToken(a_Tok) + {} + + //--------------------------------------------------------------------------- + IToken* GenericToken::Clone() const + { + return new GenericToken(*this); + } + + //------------------------------------------------------------------------------ + string_type GenericToken::AsciiDump() const + { + stringstream_type ss; + + ss << g_sCmdCode[ GetCode() ]; + ss << _T(" [addr=0x") << std::hex << this << _T("]"); + + return ss.str(); + } + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpIValReader.cpp b/src/third-party/headers/muparserx/mpIValReader.cpp new file mode 100644 index 0000000000..ab6c629e96 --- /dev/null +++ b/src/third-party/headers/muparserx/mpIValReader.cpp @@ -0,0 +1,72 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + muParserX - A C++ math parser library with array and string support + Copyright (c) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpIValReader.h" +#include "mpTokenReader.h" + +#include + + +MUP_NAMESPACE_START + +//-------------------------------------------------------------------------------------------- + IValueReader::IValueReader() + :m_pTokenReader(nullptr) + {} + + //-------------------------------------------------------------------------------------------- + IValueReader::~IValueReader() + {} + + //-------------------------------------------------------------------------------------------- + IValueReader::IValueReader(const IValueReader &ref) + { + m_pTokenReader = ref.m_pTokenReader; + } + + //-------------------------------------------------------------------------------------------- + void IValueReader::SetParent(TokenReader *pTokenReader) + { + assert(pTokenReader); + m_pTokenReader = pTokenReader; + } + + //-------------------------------------------------------------------------------------------- + const IToken* IValueReader::TokenHistory(std::size_t pos) const + { + const TokenReader::token_buf_type &buf = m_pTokenReader->GetTokens(); + std::size_t size = buf.size(); + return (pos>=size) ? nullptr : buf[size-1-pos].Get(); + } +} diff --git a/src/third-party/headers/muparserx/mpIValue.cpp b/src/third-party/headers/muparserx/mpIValue.cpp new file mode 100644 index 0000000000..878b3d0889 --- /dev/null +++ b/src/third-party/headers/muparserx/mpIValue.cpp @@ -0,0 +1,449 @@ +/** \file + \brief Implementation of the virtual base class used for all parser values. + +
+                __________                                 ____  ___
+     _____  __ _\______   \_____ _______  ______ __________\   \/  /
+    /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
+    |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
+    |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+          \/                     \/           \/     \/           \_/
+    Copyright (C) 2016 Ingo Berg
+    All rights reserved.
+
+    muParserX - A C++ math parser library with array and string support
+    Copyright (c) 2016, Ingo Berg
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+    IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+    
+ */ +#include "mpIValue.h" + +//--- Standard includes ------------------------------------------------------ +#include +#include +#include +#include + +//--- muParserX framework ----------------------------------------------------- +#include "mpValue.h" +#include "mpError.h" +#include "mpValue.h" + + +MUP_NAMESPACE_START + +#ifndef _UNICODE + +//--------------------------------------------------------------------------- +/** \brief Overloaded streaming operator for outputting the value type + into an std::ostream. + \param a_Stream The stream object + \param a_Val The value object to be streamed + + This function is only present if _UNICODE is not defined. + */ + std::ostream& operator<<(std::ostream &a_Stream, const IValue &a_Val) +{ + return a_Stream << a_Val.ToString(); +} + +#else + +//--------------------------------------------------------------------------- +/** \brief Overloaded streaming operator for outputting the value type + into an std::ostream. + \param a_Stream The stream object + \param a_Val The value object to be streamed + + This function is only present if _UNICODE is defined. + */ + std::wostream& operator<<(std::wostream &a_Stream, const IValue &a_Val) +{ + return a_Stream << a_Val.ToString(); +} +#endif + +//--------------------------------------------------------------------------------------------- +Value operator*(const IValue& lhs, const IValue& rhs) +{ + return Value(lhs) *= rhs; +} + +//--------------------------------------------------------------------------- +IValue::IValue(ECmdCode a_iCode) + :IToken(a_iCode) +{ + assert(a_iCode == cmVAL); +} + +//--------------------------------------------------------------------------- +IValue::IValue(ECmdCode a_iCode, const string_type &a_sIdent) + :IToken(a_iCode, a_sIdent) +{ + assert(a_iCode == cmVAL); +} + +//--------------------------------------------------------------------------- +IValue::~IValue() +{} + +//--------------------------------------------------------------------------- +ICallback* IValue::AsICallback() +{ + return nullptr; +} + +//--------------------------------------------------------------------------- +IValue* IValue::AsIValue() +{ + return this; +} + +//--------------------------------------------------------------------------- +string_type IValue::ToString() const +{ + stringstream_type ss; + switch (GetType()) + { + case 'm': + { + const matrix_type &arr(GetArray()); + + if (arr.GetRows() > 1) + ss << _T("{"); + + for (int i = 0; i < arr.GetRows(); ++i) + { + if (arr.GetCols()>1) + ss << _T("{"); + + for (int j = 0; j < arr.GetCols(); ++j) + { + ss << arr.At(i, j).ToString(); + if (j != arr.GetCols() - 1) + ss << _T(", "); + } + + if (arr.GetCols()>1) + ss << _T("}"); + + if (i != arr.GetRows() - 1) + ss << _T("; "); + } + + if (arr.GetRows() > 1) + ss << _T("} "); + } + break; + + case 'c': + { + float_type re = GetFloat(), + im = GetImag(); + + // realteil nicht ausgeben, wenn es eine rein imaginäre Zahl ist + if (im == 0 || re != 0 || (im == 0 && re == 0)) + ss << re; + + if (im != 0) + { + if (im > 0 && re != 0) + ss << _T("+"); + + if (im != 1) + ss << im; + + ss << _T("i"); + } + } + break; + + case 'i': + case 'f': ss << std::setprecision(std::numeric_limits::digits10) << GetFloat(); break; + case 's': ss << _T("\"") << GetString() << _T("\""); break; + case 'b': ss << ((GetBool() == true) ? _T("true") : _T("false")); break; + case 'v': ss << _T("void"); break; + default: ss << _T("internal error: unknown value type."); break; + } + + return ss.str(); +} + +//--------------------------------------------------------------------------- +bool IValue::operator==(const IValue &a_Val) const +{ + char_type type1 = GetType(), + type2 = a_Val.GetType(); + + if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) + { + switch (GetType()) + { + case 'i': + case 'f': return GetFloat() == a_Val.GetFloat(); + case 'c': return GetComplex() == a_Val.GetComplex(); + case 's': return GetString() == a_Val.GetString(); + case 'b': return GetBool() == a_Val.GetBool(); + case 'v': return false; + case 'm': if (GetRows() != a_Val.GetRows() || GetCols() != a_Val.GetCols()) + { + return false; + } + else + { + for (int i = 0; i < GetRows(); ++i) + { + if (const_cast(this)->At(i) != const_cast(a_Val).At(i)) + return false; + } + + return true; + } + default: + ErrorContext err; + err.Errc = ecINTERNAL_ERROR; + err.Pos = -1; + err.Type1 = GetType(); + err.Type2 = a_Val.GetType(); + throw ParserError(err); + } // switch this type + } + else + { + return false; + } +} + +//--------------------------------------------------------------------------- +bool IValue::operator!=(const IValue &a_Val) const +{ + char_type type1 = GetType(), + type2 = a_Val.GetType(); + + if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) + { + switch (GetType()) + { + case 's': return GetString() != a_Val.GetString(); + case 'i': + case 'f': return GetFloat() != a_Val.GetFloat(); + case 'c': return (GetFloat() != a_Val.GetFloat()) || (GetImag() != a_Val.GetImag()); + case 'b': return GetBool() != a_Val.GetBool(); + case 'v': return true; + case 'm': if (GetRows() != a_Val.GetRows() || GetCols() != a_Val.GetCols()) + { + return true; + } + else + { + for (int i = 0; i < GetRows(); ++i) + { + if (const_cast(this)->At(i) != const_cast(a_Val).At(i)) + return true; + } + + return false; + } + default: + ErrorContext err; + err.Errc = ecINTERNAL_ERROR; + err.Pos = -1; + err.Type2 = GetType(); + err.Type1 = a_Val.GetType(); + throw ParserError(err); + } // switch this type + } + else + { + return true; + } +} + +//--------------------------------------------------------------------------- +bool IValue::operator<(const IValue &a_Val) const +{ + char_type type1 = GetType(); + char_type type2 = a_Val.GetType(); + + if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) + { + switch (GetType()) + { + case 's': return GetString() < a_Val.GetString(); + case 'i': + case 'f': + case 'c': return GetFloat() < a_Val.GetFloat(); + case 'b': return GetBool() < a_Val.GetBool(); + + default: + ErrorContext err; + err.Errc = ecINTERNAL_ERROR; + err.Pos = -1; + err.Type1 = GetType(); + err.Type2 = a_Val.GetType(); + throw ParserError(err); + } // switch this type + } + else + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT_FUN; + err.Arg = (type1 != 'f' && type1 != 'i') ? 1 : 2; + err.Type1 = type2; + err.Type2 = type1; + throw ParserError(err); + } +} + +//--------------------------------------------------------------------------- +bool IValue::operator> (const IValue &a_Val) const +{ + char_type type1 = GetType(), + type2 = a_Val.GetType(); + + if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) + { + switch (GetType()) + { + case 's': return GetString() > a_Val.GetString(); + case 'i': + case 'f': + case 'c': return GetFloat() > a_Val.GetFloat(); + case 'b': return GetBool() > a_Val.GetBool(); + default: + ErrorContext err; + err.Errc = ecINTERNAL_ERROR; + err.Pos = -1; + err.Type1 = GetType(); + err.Type2 = a_Val.GetType(); + throw ParserError(err); + + } // switch this type + } + else + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT_FUN; + err.Arg = (type1 != 'f' && type1 != 'i') ? 1 : 2; + err.Type1 = type2; + err.Type2 = type1; + throw ParserError(err); + } +} + +//--------------------------------------------------------------------------- +bool IValue::operator>=(const IValue &a_Val) const +{ + char_type type1 = GetType(), + type2 = a_Val.GetType(); + + if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) + { + switch (GetType()) + { + case 's': return GetString() >= a_Val.GetString(); + case 'i': + case 'f': + case 'c': return GetFloat() >= a_Val.GetFloat(); + case 'b': return GetBool() >= a_Val.GetBool(); + default: + ErrorContext err; + err.Errc = ecINTERNAL_ERROR; + err.Pos = -1; + err.Type1 = GetType(); + err.Type2 = a_Val.GetType(); + throw ParserError(err); + + } // switch this type + } + else + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT_FUN; + err.Arg = (type1 != 'f' && type1 != 'i') ? 1 : 2; + err.Type1 = type2; + err.Type2 = type1; + throw ParserError(err); + } +} + +//--------------------------------------------------------------------------- +bool IValue::operator<=(const IValue &a_Val) const +{ + char_type type1 = GetType(), + type2 = a_Val.GetType(); + + if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) + { + switch (GetType()) + { + case 's': return GetString() <= a_Val.GetString(); + case 'i': + case 'f': + case 'c': return GetFloat() <= a_Val.GetFloat(); + case 'b': return GetBool() <= a_Val.GetBool(); + default: + ErrorContext err; + err.Errc = ecINTERNAL_ERROR; + err.Pos = -1; + err.Type1 = GetType(); + err.Type2 = a_Val.GetType(); + throw ParserError(err); + + } // switch this type + } + else + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT_FUN; + err.Arg = (type1 != 'f' && type1 != 'i') ? 1 : 2; + err.Type1 = type2; + err.Type2 = type1; + throw ParserError(err); + } +} + +//--------------------------------------------------------------------------- +IValue& IValue::operator=(const IValue &ref) +{ + if (this == &ref) + return *this; + + switch (ref.GetType()) + { + case 'i': + case 'f': + case 'c': return *this = cmplx_type(ref.GetFloat(), ref.GetImag()); + case 's': return *this = ref.GetString(); + case 'm': return *this = ref.GetArray(); + case 'b': return *this = ref.GetBool(); + case 'v': + throw ParserError(_T("Assignment from void type is not possible")); + + default: + throw ParserError(_T("Internal error: unexpected data type identifier in IValue& operator=(const IValue &ref)")); + } +} + + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpIfThenElse.cpp b/src/third-party/headers/muparserx/mpIfThenElse.cpp new file mode 100644 index 0000000000..3d5a76fc09 --- /dev/null +++ b/src/third-party/headers/muparserx/mpIfThenElse.cpp @@ -0,0 +1,100 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + muParserX - A C++ math parser library with array and string support + Copyright (c) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpIfThenElse.h" + +MUP_NAMESPACE_START + + //--------------------------------------------------------------------------- + // + // If part of if-then-else clauses + // + //--------------------------------------------------------------------------- + + TokenIfThenElse::TokenIfThenElse(ECmdCode eCode) + :IToken(eCode, g_sCmdCode[ eCode ]) + ,IPrecedence() + ,m_nOffset() + {} + + //--------------------------------------------------------------------------- + IToken* TokenIfThenElse::Clone() const + { + return new TokenIfThenElse(*this); + } + + //--------------------------------------------------------------------------- + void TokenIfThenElse::SetOffset(int nOffset) + { + m_nOffset = nOffset; + } + + //--------------------------------------------------------------------------- + int TokenIfThenElse::GetOffset() const + { + return m_nOffset; + } + + //--------------------------------------------------------------------------- + string_type TokenIfThenElse::AsciiDump() const + { + stringstream_type ss; + + ss << GetIdent(); + ss << _T(" [addr=0x") << std::hex << this << std::dec; + ss << _T("; pos=") << GetExprPos(); + ss << _T("; offset=") << m_nOffset; + ss << _T("]"); + return ss.str(); + } + + //--------------------------------------------------------------------------- + int TokenIfThenElse::GetPri() const + { + return (int)prIF_THEN_ELSE; + } + + //--------------------------------------------------------------------------- + EOprtAsct TokenIfThenElse::GetAssociativity() const + { + return oaNONE; + } + + //--------------------------------------------------------------------------- + IPrecedence* TokenIfThenElse::AsIPrecedence() + { + return this; + } + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpOprtBinAssign.cpp b/src/third-party/headers/muparserx/mpOprtBinAssign.cpp new file mode 100644 index 0000000000..18fed101c9 --- /dev/null +++ b/src/third-party/headers/muparserx/mpOprtBinAssign.cpp @@ -0,0 +1,249 @@ +/** \file + \brief This file contains the implementation of binary assignment + operators used in muParser. + +
+               __________                                 ____  ___
+    _____  __ _\______   \_____ _______  ______ __________\   \/  /
+   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
+  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
+  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+        \/                     \/           \/     \/           \_/
+                                       Copyright (C) 2016, Ingo Berg
+                                       All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright notice, 
+     this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright notice, 
+     this list of conditions and the following disclaimer in the documentation 
+     and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+  POSSIBILITY OF SUCH DAMAGE.
+
+*/ +#include "mpOprtBinAssign.h" + + +MUP_NAMESPACE_START + + //--------------------------------------------------------------------- + // + // class OprtAssign + // + //--------------------------------------------------------------------- + + OprtAssign::OprtAssign() + :IOprtBin(_T("="), (int)prASSIGN, oaLEFT) + {} + + //--------------------------------------------------------------------- + const char_type* OprtAssign::GetDesc() const + { + return _T("'=' assignement operator"); + } + + //--------------------------------------------------------------------- + IToken* OprtAssign::Clone() const + { + return new OprtAssign(*this); + } + + //--------------------------------------------------------------------- + void OprtAssign::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + Variable *pVar = dynamic_cast(a_pArg[0].Get()); + + // assigment to non variable type + if (!pVar) + { + ErrorContext err; + err.Arg = 1; + err.Ident = _T("="); + err.Errc = ecASSIGNEMENT_TO_VALUE; + throw ParserError(err); + } + + *pVar = *a_pArg[1]; //pVar->SetFloat(a_pArg[1]->GetFloat()); + *ret = *pVar; + } + + //--------------------------------------------------------------------- + // + // class OprtAssignAdd + // + //--------------------------------------------------------------------- + + OprtAssignAdd::OprtAssignAdd() + :IOprtBin(_T("+="), (int)prASSIGN, oaLEFT) + {} + + //--------------------------------------------------------------------- + void OprtAssignAdd::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) + { + Variable *pVar = dynamic_cast(a_pArg[0].Get()); + + // assigment to non variable type + if (!pVar) + { + ErrorContext err; + err.Arg = 1; + err.Ident = _T("+="); + err.Errc = ecASSIGNEMENT_TO_VALUE; + throw ParserError(err); + } + + *pVar = cmplx_type(a_pArg[0]->GetFloat() + a_pArg[1]->GetFloat(), + a_pArg[0]->GetImag() + a_pArg[1]->GetImag()); + *ret = *pVar; + } + + //--------------------------------------------------------------------- + const char_type* OprtAssignAdd::GetDesc() const + { + return _T("assignement operator"); + } + + //--------------------------------------------------------------------- + IToken* OprtAssignAdd::Clone() const + { + return new OprtAssignAdd(*this); + } + + //--------------------------------------------------------------------- + // + // class OprtAssignAdd + // + //--------------------------------------------------------------------- + + OprtAssignSub::OprtAssignSub() + :IOprtBin(_T("-="), (int)prASSIGN, oaLEFT) + {} + + //--------------------------------------------------------------------- + void OprtAssignSub::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) + { + Variable *pVar = dynamic_cast(a_pArg[0].Get()); + if (!pVar) + { + ErrorContext err; + err.Arg = 1; + err.Ident = _T("-="); + err.Errc = ecASSIGNEMENT_TO_VALUE; + throw ParserError(err); + } + + *pVar = cmplx_type(a_pArg[0]->GetFloat() - a_pArg[1]->GetFloat(), + a_pArg[0]->GetImag() - a_pArg[1]->GetImag()); + *ret = *pVar; + } + + //--------------------------------------------------------------------- + const char_type* OprtAssignSub::GetDesc() const + { + return _T("assignement operator"); + } + + //--------------------------------------------------------------------- + IToken* OprtAssignSub::Clone() const + { + return new OprtAssignSub(*this); + } + + //--------------------------------------------------------------------- + // + // class OprtAssignAdd + // + //--------------------------------------------------------------------- + + OprtAssignMul::OprtAssignMul() + :IOprtBin(_T("*="), (int)prASSIGN, oaLEFT) + {} + + //--------------------------------------------------------------------- + void OprtAssignMul::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) + { + Variable *pVar = dynamic_cast(a_pArg[0].Get()); + if (!pVar) + { + ErrorContext err; + err.Arg = 1; + err.Ident = _T("*="); + err.Errc = ecASSIGNEMENT_TO_VALUE; + throw ParserError(err); + } + + float_type a = a_pArg[0]->GetFloat(), + b = a_pArg[0]->GetImag(), + c = a_pArg[1]->GetFloat(), + d = a_pArg[1]->GetImag(); + *pVar = cmplx_type(a*c-b*d, a*d-b*c); + *ret = *pVar; + } + + //--------------------------------------------------------------------- + const char_type* OprtAssignMul::GetDesc() const + { + return _T("multiply and assign operator"); + } + + //--------------------------------------------------------------------- + IToken* OprtAssignMul::Clone() const + { + return new OprtAssignMul(*this); + } + + //--------------------------------------------------------------------- + // + // class OprtAssignDiv + // + //--------------------------------------------------------------------- + + OprtAssignDiv::OprtAssignDiv() : IOprtBin(_T("/="), (int)prASSIGN, oaLEFT) + {} + + //------------------------------------------------------------------------------ + void OprtAssignDiv::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) + { + Variable *pVar = dynamic_cast(a_pArg[0].Get()); + if (!pVar) + { + ErrorContext err; + err.Arg = 1; + err.Ident = _T("/="); + err.Errc = ecASSIGNEMENT_TO_VALUE; + throw ParserError(err); + } + + float_type a = a_pArg[0]->GetFloat(), + b = a_pArg[0]->GetImag(), + c = a_pArg[1]->GetFloat(), + d = a_pArg[1]->GetImag(), + n = c*c + d*d; + *pVar = cmplx_type((a*c+b*d)/n, (b*c-a*d)/n); + *ret = *pVar; + } + + //------------------------------------------------------------------------------ + const char_type* OprtAssignDiv::GetDesc() const + { + return _T("multiply and divide operator"); + } + + //------------------------------------------------------------------------------ + IToken* OprtAssignDiv::Clone() const + { + return new OprtAssignDiv(*this); + } +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpOprtBinCommon.cpp b/src/third-party/headers/muparserx/mpOprtBinCommon.cpp new file mode 100644 index 0000000000..c1d6e225a2 --- /dev/null +++ b/src/third-party/headers/muparserx/mpOprtBinCommon.cpp @@ -0,0 +1,589 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + muParserX - A C++ math parser library with array and string support + Copyright (c) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ +#include "mpOprtBinCommon.h" +#include +#include + + +MUP_NAMESPACE_START + +//----------------------------------------------------------------------------------------------- +// +// class OprtStrAdd +// +//----------------------------------------------------------------------------------------------- + +OprtStrAdd::OprtStrAdd() +:IOprtBin(_T("//"), (int)prADD_SUB, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtStrAdd::Eval(ptr_val_type& ret, const ptr_val_type *arg, int argc) +{ + MUP_VERIFY(argc == 2); + string_type a = arg[0]->GetString(); + string_type b = arg[1]->GetString(); + *ret = a + b; +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtStrAdd::GetDesc() const +{ + return _T("string concatenation"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtStrAdd::Clone() const +{ + return new OprtStrAdd(*this); +} + + +//----------------------------------------------------------------------------------------------- +// +// class OprtEQ +// +//----------------------------------------------------------------------------------------------- + +OprtEQ::OprtEQ() + :IOprtBin(_T("=="), (int)prRELATIONAL1, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtEQ::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) +{ + *ret = *a_pArg[0] == *a_pArg[1]; +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtEQ::GetDesc() const +{ + return _T("equals operator"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtEQ::Clone() const +{ + return new OprtEQ(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtNEQ +// +//----------------------------------------------------------------------------------------------- + +OprtNEQ::OprtNEQ() + :IOprtBin(_T("!="), (int)prRELATIONAL1, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtNEQ::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) +{ + *ret = *a_pArg[0] != *a_pArg[1]; +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtNEQ::GetDesc() const +{ + return _T("not equal operator"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtNEQ::Clone() const +{ + return new OprtNEQ(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtLT +// +//----------------------------------------------------------------------------------------------- + +OprtLT::OprtLT() + :IOprtBin(_T("<"), (int)prRELATIONAL2, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtLT::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) +{ + *ret = *a_pArg[0] < *a_pArg[1]; +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtLT::GetDesc() const +{ + return _T("less than operator"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtLT::Clone() const +{ + return new OprtLT(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtGT +// +//----------------------------------------------------------------------------------------------- + +OprtGT::OprtGT() + :IOprtBin(_T(">"), (int)prRELATIONAL2, oaLEFT) {} + +//----------------------------------------------------------------------------------------------- +void OprtGT::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) +{ + *ret = *a_pArg[0] > *a_pArg[1]; +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtGT::GetDesc() const +{ + return _T("greater than operator"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtGT::Clone() const +{ + return new OprtGT(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtLE +// +//----------------------------------------------------------------------------------------------- + +OprtLE::OprtLE() + :IOprtBin(_T("<="), (int)prRELATIONAL2, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtLE::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) +{ + *ret = *a_pArg[0] <= *a_pArg[1]; +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtLE::GetDesc() const +{ + return _T("less or equal operator"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtLE::Clone() const +{ + return new OprtLE(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtGE +// +//----------------------------------------------------------------------------------------------- + +OprtGE::OprtGE() + :IOprtBin(_T(">="), (int)prRELATIONAL2, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtGE::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) +{ + *ret = *a_pArg[0] >= *a_pArg[1]; +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtGE::GetDesc() const +{ + return _T("greater or equal operator"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtGE::Clone() const +{ + return new OprtGE(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtAnd +// +//----------------------------------------------------------------------------------------------- + +OprtAnd::OprtAnd() + :IOprtBin(_T("&"), (int)prBIT_AND, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtAnd::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) +{ + MUP_VERIFY(num == 2); + + if (!a_pArg[0]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[0]->GetType(), 'i', 1)); + + if (!a_pArg[1]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[1]->GetType(), 'i', 2)); + + float_type a = a_pArg[0]->GetFloat(), + b = a_pArg[1]->GetFloat(); + + if (a != (int_type)a) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, a_pArg[0]->GetIdent(), a_pArg[0]->GetType(), 'i', 1)); + + if (b != (int_type)b) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, a_pArg[1]->GetIdent(), a_pArg[1]->GetType(), 'i', 2)); + + *ret = (float_type)((int_type)a & (int_type)(b)); +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtAnd::GetDesc() const +{ + return _T("bitwise and"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtAnd::Clone() const +{ + return new OprtAnd(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtOr +// +//----------------------------------------------------------------------------------------------- + +OprtOr::OprtOr() + :IOprtBin(_T("|"), (int)prBIT_OR, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtOr::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) +{ + MUP_VERIFY(num == 2); + + if (!a_pArg[0]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[0]->GetType(), 'i', 1)); + + if (!a_pArg[1]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[1]->GetType(), 'i', 2)); + + float_type a = a_pArg[0]->GetFloat(), + b = a_pArg[1]->GetFloat(); + + if (a != (int_type)a) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, a_pArg[0]->GetIdent(), a_pArg[0]->GetType(), 'i', 1)); + + if (b != (int_type)b) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, a_pArg[1]->GetIdent(), a_pArg[1]->GetType(), 'i', 2)); + + *ret = (float_type)((int_type)a | (int_type)(b)); +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtOr::GetDesc() const +{ + return _T("bitwise or"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtOr::Clone() const +{ + return new OprtOr(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtLOr +// +//----------------------------------------------------------------------------------------------- + +OprtLOr::OprtLOr(const char_type *szIdent) + :IOprtBin(szIdent, (int)prLOGIC_OR, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtLOr::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) +{ + MUP_VERIFY(num == 2); + *ret = a_pArg[0]->GetBool() || a_pArg[1]->GetBool(); +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtLOr::GetDesc() const +{ + return _T("logical or"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtLOr::Clone() const +{ + return new OprtLOr(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtLAnd +// +//----------------------------------------------------------------------------------------------- + +OprtLAnd::OprtLAnd(const char_type *szIdent) + :IOprtBin(szIdent, (int)prLOGIC_AND, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtLAnd::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) +{ + MUP_VERIFY(num == 2); + *ret = a_pArg[0]->GetBool() && a_pArg[1]->GetBool(); +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtLAnd::GetDesc() const +{ + return _T("logical and"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtLAnd::Clone() const +{ + return new OprtLAnd(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtShl +// +//----------------------------------------------------------------------------------------------- + +OprtShl::OprtShl() + :IOprtBin(_T("<<"), (int)prSHIFT, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtShl::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) +{ + MUP_VERIFY(num == 2); + + if (!a_pArg[0]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[0]->GetType(), 'i', 1)); + + if (!a_pArg[1]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[1]->GetType(), 'i', 2)); + + float_type a = a_pArg[0]->GetFloat(), + b = a_pArg[1]->GetFloat(); + + if (a != (int_type)a) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), a_pArg[0]->GetIdent(), a_pArg[0]->GetType(), 'i', 1)); + + if (b != (int_type)b) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), a_pArg[1]->GetIdent(), a_pArg[1]->GetType(), 'i', 2)); + + float_type result = a*std::pow(2, b); + int numDigits = std::numeric_limits::digits10; + + if (std::fabs(result) >= std::fabs(std::pow(10.0, numDigits))) + throw ParserError(ErrorContext(ecOVERFLOW, GetExprPos(), GetIdent())); + + if (result > 0) + { + *ret = std::floor(result); + } + else + { + *ret = std::ceil(result); + } +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtShl::GetDesc() const +{ + return _T("shift left"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtShl::Clone() const +{ + return new OprtShl(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// class OprtShr +// +//----------------------------------------------------------------------------------------------- + +OprtShr::OprtShr() + :IOprtBin(_T(">>"), (int)prSHIFT, oaLEFT) +{} + +//----------------------------------------------------------- +void OprtShr::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) +{ + MUP_VERIFY(num == 2); + + if (!a_pArg[0]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[0]->GetType(), 'i', 1)); + + if (!a_pArg[1]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[1]->GetType(), 'i', 2)); + + float_type a = a_pArg[0]->GetFloat(), + b = a_pArg[1]->GetFloat(); + + if (a != (int_type)a) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), a_pArg[0]->GetIdent(), a_pArg[0]->GetType(), 'i', 1)); + + if (b != (int_type)b) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), a_pArg[1]->GetIdent(), a_pArg[1]->GetType(), 'i', 2)); + + float_type result = a*std::pow(2, -b); + int numDigits = std::numeric_limits::digits10; + + if (std::fabs(result) >= std::fabs(std::pow(10.0, numDigits))) + throw ParserError(ErrorContext(ecOVERFLOW, GetExprPos(), GetIdent())); + + if (result > 0) + *ret = std::floor(result); + else + *ret = std::ceil(result); +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtShr::GetDesc() const +{ + return _T("shift right"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtShr::Clone() const +{ + return new OprtShr(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// Cast To Float +// +//----------------------------------------------------------------------------------------------- + +OprtCastToFloat::OprtCastToFloat() + :IOprtInfix(_T("(float)"), prINFIX) +{} + +//----------------------------------------------------------------------------------------------- +void OprtCastToFloat::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int /*a_iArgc*/) +{ + switch (a_pArg[0]->GetType()) + { + case 'i': + case 'f': + case 'b': + *ret = a_pArg[0]->GetFloat(); + break; + + default: + { + ErrorContext err; + err.Errc = ecINVALID_TYPECAST; + err.Type1 = a_pArg[0]->GetType(); + err.Type2 = 'f'; + throw ParserError(err); + } + } // switch value type +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtCastToFloat::GetDesc() const +{ + return _T("cast a value into a floating point number"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtCastToFloat::Clone() const +{ + return new OprtCastToFloat(*this); +} + +//----------------------------------------------------------------------------------------------- +// +// Cast To Int +// +//----------------------------------------------------------------------------------------------- + +OprtCastToInt::OprtCastToInt() + :IOprtInfix(_T("(int)"), prINFIX) +{} + +//----------------------------------------------------------------------------------------------- +void OprtCastToInt::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int /*a_iArgc*/) +{ + switch (a_pArg[0]->GetType()) + { + case 'f': + case 'i': + case 'b': + *ret = (float_type)((int_type)a_pArg[0]->GetFloat()); + break; + + default: + { + ErrorContext err; + err.Errc = ecINVALID_TYPECAST; + err.Type1 = a_pArg[0]->GetType(); + err.Type2 = 'i'; + throw ParserError(err); + } + } // switch value type +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtCastToInt::GetDesc() const +{ + return _T("cast a value into a floating point number"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtCastToInt::Clone() const +{ + return new OprtCastToInt(*this); +} + +} diff --git a/src/third-party/headers/muparserx/mpOprtCmplx.cpp b/src/third-party/headers/muparserx/mpOprtCmplx.cpp new file mode 100644 index 0000000000..dfc6da5a44 --- /dev/null +++ b/src/third-party/headers/muparserx/mpOprtCmplx.cpp @@ -0,0 +1,321 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + muParserX - A C++ math parser library with array and string support + Copyright (c) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. + */ +#include "mpOprtCmplx.h" +#include +#include + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------------------------- +// +// class OprtSignCmplx +// +//------------------------------------------------------------------------------------------------- + +OprtSignCmplx::OprtSignCmplx() +:IOprtInfix(_T("-"), prINFIX) +{} + +//----------------------------------------------------------------------------------------------- +void OprtSignCmplx::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) +{ + MUP_VERIFY(a_iArgc == 1); + + if (a_pArg[0]->IsScalar()) + { + float_type re = a_pArg[0]->GetFloat(); + float_type im = a_pArg[0]->GetImag(); + + // Do not omit the test for zero! Multiplying 0 with -1 + // will yield -0 on IEEE754 compliant implementations! + // This would change the result of complex calculations: + // + // i.e. sqrt(-1 + (-0)i) != sqrt(-1 + 0i) + // -i != i + cmplx_type v((re == 0) ? 0 : -re, (im == 0) ? 0 : -im); + *ret = v; + } + else if (a_pArg[0]->GetType() == 'm') + { + Value v(a_pArg[0]->GetRows(), 0); + for (int i = 0; i < a_pArg[0]->GetRows(); ++i) + { + v.At(i) = a_pArg[0]->At(i).GetComplex() * (float_type)-1.0; + } + *ret = v; + } + else + { + ErrorContext err; + err.Errc = ecINVALID_TYPE; + err.Type1 = a_pArg[0]->GetType(); + err.Type2 = 's'; + throw ParserError(err); + } +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtSignCmplx::GetDesc() const +{ + return _T("negative sign operator"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtSignCmplx::Clone() const +{ + return new OprtSignCmplx(*this); +} + +//------------------------------------------------------------------------------------------------- +// +// class OprtAddCmplx +// +//------------------------------------------------------------------------------------------------- + +OprtAddCmplx::OprtAddCmplx() +:IOprtBin(_T("+"), (int)prADD_SUB, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtAddCmplx::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int num) +{ + assert(num == 2); + + const IValue *arg1 = a_pArg[0].Get(); + const IValue *arg2 = a_pArg[1].Get(); + + if (arg1->IsNonComplexScalar() && arg2->IsNonComplexScalar()) + { + *ret = arg1->GetFloat() + arg2->GetFloat(); + } + else if (arg1->GetType() == 'm' && arg2->GetType() == 'm') + { + // Matrix + Matrix + *ret = arg1->GetArray() + arg2->GetArray(); + } + else + { + if (!arg1->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), arg1->GetType(), 'c', 1)); + + if (!arg2->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), arg2->GetType(), 'c', 2)); + + *ret = cmplx_type(arg1->GetFloat() + arg2->GetFloat(), + arg1->GetImag() + arg2->GetImag()); + } +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtAddCmplx::GetDesc() const +{ + return _T("addition"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtAddCmplx::Clone() const +{ + return new OprtAddCmplx(*this); +} + +//------------------------------------------------------------------------------------------------- +// +// class OprtSubCmplx +// +//------------------------------------------------------------------------------------------------- + +OprtSubCmplx::OprtSubCmplx() +:IOprtBin(_T("-"), (int)prADD_SUB, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtSubCmplx::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) +{ + assert(num == 2); + + const IValue *arg1 = a_pArg[0].Get(); + const IValue *arg2 = a_pArg[1].Get(); + if (a_pArg[0]->IsNonComplexScalar() && a_pArg[1]->IsNonComplexScalar()) + { + *ret = arg1->GetFloat() - arg2->GetFloat(); + } + else if (a_pArg[0]->GetType() == 'm' && a_pArg[1]->GetType() == 'm') + { + // Matrix + Matrix + *ret = arg1->GetArray() - arg2->GetArray(); + } + else + { + if (!a_pArg[0]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[0]->GetType(), 'c', 1)); + + if (!a_pArg[1]->IsScalar()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[1]->GetType(), 'c', 2)); + + *ret = cmplx_type(a_pArg[0]->GetFloat() - a_pArg[1]->GetFloat(), + a_pArg[0]->GetImag() - a_pArg[1]->GetImag()); + } +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtSubCmplx::GetDesc() const +{ + return _T("subtraction"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtSubCmplx::Clone() const +{ + return new OprtSubCmplx(*this); +} + +//------------------------------------------------------------------------------------------------- +// +// class OprtMulCmplx +// +//------------------------------------------------------------------------------------------------- + +OprtMulCmplx::OprtMulCmplx() +:IOprtBin(_T("*"), (int)prMUL_DIV, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtMulCmplx::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) +{ + assert(num == 2); + IValue *arg1 = a_pArg[0].Get(); + IValue *arg2 = a_pArg[1].Get(); + *ret = (*arg1) * (*arg2); +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtMulCmplx::GetDesc() const +{ + return _T("foo*bar - multiplication"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtMulCmplx::Clone() const +{ + return new OprtMulCmplx(*this); +} + +//------------------------------------------------------------------------------------------------- +// +// class OprtDivCmplx +// +//------------------------------------------------------------------------------------------------- + + +OprtDivCmplx::OprtDivCmplx() +:IOprtBin(_T("/"), (int)prMUL_DIV, oaLEFT) +{} + +//----------------------------------------------------------------------------------------------- +/** \brief Implements the Division operator. + \throw ParserError in case one of the arguments if + nonnumeric or an array. + + */ +void OprtDivCmplx::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) +{ + assert(num == 2); + + if (a_pArg[0]->IsNonComplexScalar() && a_pArg[1]->IsNonComplexScalar()) + { + *ret = a_pArg[0]->GetFloat() / a_pArg[1]->GetFloat(); + } + else + { + // multiplication of two imaginary numbers + float_type a = a_pArg[0]->GetFloat(), + b = a_pArg[0]->GetImag(), + c = a_pArg[1]->GetFloat(), + d = a_pArg[1]->GetImag(), + n = c*c + d*d; + *ret = cmplx_type((a*c + b*d) / n, (b*c - a*d) / n); + } +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtDivCmplx::GetDesc() const +{ + return _T("division"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtDivCmplx::Clone() const +{ + return new OprtDivCmplx(*this); +} + +//------------------------------------------------------------------------------------------------- +// +// class OprtPowCmplx +// +//------------------------------------------------------------------------------------------------- + +OprtPowCmplx::OprtPowCmplx() +:IOprtBin(_T("^"), (int)prPOW, oaRIGHT) +{} + +//----------------------------------------------------------------------------------------------- +void OprtPowCmplx::Eval(ptr_val_type& ret, const ptr_val_type *arg, int argc) +{ + assert(argc == 2); + + if (arg[0]->IsComplex() || arg[1]->IsComplex() || (arg[0]->GetFloat() < 0 && !arg[1]->IsInteger())) + { + *ret = std::pow(arg[0]->GetComplex(), arg[1]->GetComplex());; + } + else + { + *ret = std::pow(arg[0]->GetFloat(), arg[1]->GetFloat()); + } +} + +//----------------------------------------------------------------------------------------------- +const char_type* OprtPowCmplx::GetDesc() const +{ + return _T("raise x to the power of y"); +} + +//----------------------------------------------------------------------------------------------- +IToken* OprtPowCmplx::Clone() const +{ + return new OprtPowCmplx(*this); +} + +} // namespace diff --git a/src/third-party/headers/muparserx/mpOprtIndex.cpp b/src/third-party/headers/muparserx/mpOprtIndex.cpp new file mode 100644 index 0000000000..56700636af --- /dev/null +++ b/src/third-party/headers/muparserx/mpOprtIndex.cpp @@ -0,0 +1,117 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpOprtIndex.h" +#include "mpVariable.h" + +MUP_NAMESPACE_START + + //----------------------------------------------------------------------------------------------- + // + // class OprtIndex + // + //----------------------------------------------------------------------------------------------- + + OprtIndex::OprtIndex() + :ICallback(cmIC, _T("Index operator"), -1) + {} + + //----------------------------------------------------------------------------------------------- + /** \brief Index operator implementation + \param ret A reference to the return value + \param a_pArg Pointer to an array with the indices as ptr_val_type + \param a_iArgc Number of indices (=dimension) actully used in the expression found. This must + be 1 or 2 since three dimensional data structures are not supported by muParserX. + */ + void OprtIndex::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) + { + try + { + int rows = a_pArg[-1]->GetRows(); + int cols = a_pArg[-1]->GetCols(); + bool bArgIsVariable = a_pArg[-1]->IsVariable(); + + // If the index operator is applied to a variable the return value is also a variable + // pointing to a specific cell in the matrix. If the operator is applied to a value + // the return value is also a value. + switch (a_iArgc) + { + case 1: + if (cols == 1) + { + if (bArgIsVariable) + ret.Reset(new Variable(&(ret->At(*a_pArg[0], Value(0.0))))); + else + *ret = ret->At(*a_pArg[0], Value(0.0)); + } + else if (rows == 1) + { + if (bArgIsVariable) + ret.Reset(new Variable(&(ret->At(Value(0.0), *a_pArg[0])))); + else + *ret = ret->At(Value(0.0), *a_pArg[0]); + } + else + { + throw ParserError(ErrorContext(ecINDEX_DIMENSION, -1, GetIdent())); + } + break; + + case 2: + if (bArgIsVariable) + ret.Reset(new Variable(&(ret->At(*a_pArg[0], *a_pArg[1])))); + else + *ret = ret->At(*a_pArg[0], *a_pArg[1]); + break; + + default: + throw ParserError(ErrorContext(ecINDEX_DIMENSION, -1, GetIdent())); + } + } + catch(ParserError &exc) + { + exc.GetContext().Pos = GetExprPos(); + throw exc; + } + } + + //----------------------------------------------------------------------------------------------- + const char_type* OprtIndex::GetDesc() const + { + return _T("[,] - The index operator."); + } + + //----------------------------------------------------------------------------------------------- + IToken* OprtIndex::Clone() const + { + return new OprtIndex(*this); + } + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpOprtMatrix.cpp b/src/third-party/headers/muparserx/mpOprtMatrix.cpp new file mode 100644 index 0000000000..b06ed6f06c --- /dev/null +++ b/src/third-party/headers/muparserx/mpOprtMatrix.cpp @@ -0,0 +1,182 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpOprtMatrix.h" + + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------------------------- +// +// class OprtTranspose +// +//------------------------------------------------------------------------------------------------- + + OprtTranspose::OprtTranspose() + :IOprtPostfix(_T("'")) + {} + + //------------------------------------------------------------------------------------------------- + void OprtTranspose::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int /*a_iArgc*/) + { + if (a_pArg[0]->IsMatrix()) + { + matrix_type matrix = a_pArg[0]->GetArray(); + matrix.Transpose(); + *ret = matrix; + } + else + *ret = *a_pArg[0]; + } + + //------------------------------------------------------------------------------------------------- + const char_type* OprtTranspose::GetDesc() const + { + return _T("foo' - An operator for transposing a matrix."); + } + + //------------------------------------------------------------------------------------------------- + IToken* OprtTranspose::Clone() const + { + return new OprtTranspose(*this); + } + + //----------------------------------------------------------------------------------------------- + // + // class OprtCreateArray + // + //----------------------------------------------------------------------------------------------- + + OprtCreateArray::OprtCreateArray() + :ICallback(cmCBC, _T("Array constructor"), -1) + {} + + //----------------------------------------------------------------------------------------------- + /** \brief Index operator implementation + \param ret A reference to the return value + \param a_pArg Pointer to an array with the indices as ptr_val_type + \param a_iArgc Number of indices (=dimension) actully used in the expression found. This must + be 1 or 2 since three dimensional data structures are not supported by muParserX. + */ + void OprtCreateArray::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) + { + try + { + // The index is -1. + if (a_iArgc <= 0) + { + throw ParserError(ErrorContext(ecINVALID_PARAMETER, -1, GetIdent())); + } + + matrix_type m(a_iArgc, 1, 0.0); + for (int i = 0; i < a_iArgc; ++i) + { + if (a_pArg[i]->GetDim() != 0) + { + // Prevent people from using this constructor for matrix creation. + // This would not work as expected and i dont't want them + // to get used to awkward workarounds. It's just not working right now ok? + ErrorContext errc(ecINVALID_PARAMETER, -1, GetIdent()); + errc.Arg = i+1; + throw ParserError(errc); + } + + m.At(i) = *a_pArg[i]; + } + m.Transpose(); + + *ret = m; + } + catch (ParserError &exc) + { + exc.GetContext().Pos = GetExprPos(); + throw exc; + } + } + + //----------------------------------------------------------------------------------------------- + const char_type* OprtCreateArray::GetDesc() const + { + return _T("{,} - Array construction operator."); + } + + //----------------------------------------------------------------------------------------------- + IToken* OprtCreateArray::Clone() const + { + return new OprtCreateArray(*this); + } + +//----------------------------------------------------------- +// +// class OprtColon +// +//----------------------------------------------------------- + + OprtColon::OprtColon() + :IOprtBin(_T("~"), (int)prCOLON, oaLEFT) + {} + + //----------------------------------------------------------- + void OprtColon::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int num) + { + assert(num==2); + + const IValue *argMin = a_pArg[0].Get(); + const IValue *argMax = a_pArg[1].Get(); + + if (!argMin->IsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), argMin->GetType(), 'i', 1)); + + if (!argMax->IsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), argMax->GetType(), 'i', 1)); + + if (*argMax < *argMin) + throw ParserError(_T("Colon operator: Maximum value smaller than Minimum!")); + + int n = (int)(argMax->GetFloat() - argMin->GetFloat()) + 1; + matrix_type arr(n); + for (int i=0; iGetFloat() + i; + + *ret = arr; + } + + //----------------------------------------------------------- + const char_type* OprtColon::GetDesc() const + { + return _T(": - Colon operator"); + } + + //----------------------------------------------------------- + IToken* OprtColon::Clone() const + { + return new OprtColon(*this); + } +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpOprtNonCmplx.cpp b/src/third-party/headers/muparserx/mpOprtNonCmplx.cpp new file mode 100644 index 0000000000..d58ef632c3 --- /dev/null +++ b/src/third-party/headers/muparserx/mpOprtNonCmplx.cpp @@ -0,0 +1,423 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016 Ingo Berg + All rights reserved. + + muParserX - A C++ math parser library with array and string support + Copyright (c) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpOprtNonCmplx.h" + +MUP_NAMESPACE_START + + //------------------------------------------------------------------------------ + // + // Sign operator + // + //------------------------------------------------------------------------------ + + OprtSign::OprtSign() + :IOprtInfix( _T("-"), prINFIX) + {} + + //------------------------------------------------------------------------------ + void OprtSign::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) + { + MUP_VERIFY(a_iArgc == 1); + + if (a_pArg[0]->IsScalar()) + { + *ret = -a_pArg[0]->GetFloat(); + } + else if (a_pArg[0]->GetType()=='m') + { + Value v(a_pArg[0]->GetRows(), 0); + for (int i=0; iGetRows(); ++i) + { + v.At(i) = -a_pArg[0]->At(i).GetFloat(); + } + *ret = v; + } + else + { + ErrorContext err; + err.Errc = ecINVALID_TYPE; + err.Type1 = a_pArg[0]->GetType(); + err.Type2 = 's'; + throw ParserError(err); + } + } + + //------------------------------------------------------------------------------ + const char_type* OprtSign::GetDesc() const + { + return _T("-x - negative sign operator"); + } + + //------------------------------------------------------------------------------ + IToken* OprtSign::Clone() const + { + return new OprtSign(*this); + } + + //------------------------------------------------------------------------------ + // + // Sign operator + // + //------------------------------------------------------------------------------ + + OprtSignPos::OprtSignPos() + :IOprtInfix( _T("+"), prINFIX) + {} + + //------------------------------------------------------------------------------ + void OprtSignPos::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) + { + MUP_VERIFY(a_iArgc == 1); + + if (a_pArg[0]->IsScalar()) + { + *ret = a_pArg[0]->GetFloat(); + } + else if (a_pArg[0]->GetType()=='m') + { + Value v(a_pArg[0]->GetRows(), 0); + for (int i=0; iGetRows(); ++i) + { + v.At(i) = a_pArg[0]->At(i).GetFloat(); + } + *ret = v; + } + else + { + ErrorContext err; + err.Errc = ecINVALID_TYPE; + err.Type1 = a_pArg[0]->GetType(); + err.Type2 = 's'; + throw ParserError(err); + } + } + + //------------------------------------------------------------------------------ + const char_type* OprtSignPos::GetDesc() const + { + return _T("+x - positive sign operator"); + } + + //------------------------------------------------------------------------------ + IToken* OprtSignPos::Clone() const + { + return new OprtSignPos(*this); + } + +//----------------------------------------------------------- +// +// class OprtAdd +// +//----------------------------------------------------------- + + OprtAdd::OprtAdd() + :IOprtBin(_T("+"), (int)prADD_SUB, oaLEFT) + {} + + //----------------------------------------------------------- + void OprtAdd::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int num) + { + assert(num==2); + + const IValue *arg1 = a_pArg[0].Get(); + const IValue *arg2 = a_pArg[1].Get(); + if (arg1->GetType()=='m' && arg2->GetType()=='m') + { + // Vector + Vector + const matrix_type &a1 = arg1->GetArray(), + &a2 = arg2->GetArray(); + if (a1.GetRows()!=a2.GetRows()) + throw ParserError(ErrorContext(ecARRAY_SIZE_MISMATCH, -1, GetIdent(), 'm', 'm', 2)); + + matrix_type rv(a1.GetRows()); + for (int i=0; iIsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg1->GetType(), 'f', 1)); + + if (!arg2->IsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg2->GetType(), 'f', 2)); + + *ret = arg1->GetFloat() + arg2->GetFloat(); + } + } + + //----------------------------------------------------------- + const char_type* OprtAdd::GetDesc() const + { + return _T("x+y - Addition for noncomplex values"); + } + + //----------------------------------------------------------- + IToken* OprtAdd::Clone() const + { + return new OprtAdd(*this); + } + +//----------------------------------------------------------- +// +// class OprtSub +// +//----------------------------------------------------------- + + OprtSub::OprtSub() + :IOprtBin(_T("-"), (int)prADD_SUB, oaLEFT) + {} + + //----------------------------------------------------------- + void OprtSub::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) + { + assert(num==2); + + if (a_pArg[0]->GetType()=='m' && a_pArg[1]->GetType()=='m') + { + const matrix_type &a1 = a_pArg[0]->GetArray(), + &a2 = a_pArg[1]->GetArray(); + if (a1.GetRows()!=a2.GetRows()) + throw ParserError(ErrorContext(ecARRAY_SIZE_MISMATCH, -1, GetIdent(), 'm', 'm', 2)); + + matrix_type rv(a1.GetRows()); + for (int i=0; iIsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[0]->GetType(), 'f', 1)); + + if (!a_pArg[1]->IsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[1]->GetType(), 'f', 2)); + + *ret = a_pArg[0]->GetFloat() - a_pArg[1]->GetFloat(); + } + } + + //----------------------------------------------------------- + const char_type* OprtSub::GetDesc() const + { + return _T("subtraction"); + } + + //----------------------------------------------------------- + IToken* OprtSub::Clone() const + { + return new OprtSub(*this); + } + +//----------------------------------------------------------- +// +// class OprtMul +// +//----------------------------------------------------------- + + OprtMul::OprtMul() + :IOprtBin(_T("*"), (int)prMUL_DIV, oaLEFT) + {} + + //----------------------------------------------------------- + void OprtMul::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) + { + assert(num==2); + IValue *arg1 = a_pArg[0].Get(); + IValue *arg2 = a_pArg[1].Get(); + if (arg1->GetType()=='m' && arg2->GetType()=='m') + { + // Scalar multiplication + matrix_type a1 = arg1->GetArray(); + matrix_type a2 = arg2->GetArray(); + + if (a1.GetRows()!=a2.GetRows()) + throw ParserError(ErrorContext(ecARRAY_SIZE_MISMATCH, -1, GetIdent(), 'm', 'm', 2)); + + float_type val(0); + for (int i=0; iGetType()=='m' && arg2->IsNonComplexScalar()) + { + // Skalar * Vector + matrix_type out(a_pArg[0]->GetArray()); + for (int i=0; iGetFloat(); + + *ret = out; + } + else if (arg2->GetType()=='m' && arg1->IsNonComplexScalar()) + { + // Vector * Skalar + matrix_type out(arg2->GetArray()); + for (int i=0; iGetFloat(); + + *ret = out; + } + else + { + if (!arg1->IsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg1->GetType(), 'f', 1)); + + if (!arg2->IsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg2->GetType(), 'f', 2)); + + *ret = arg1->GetFloat() * arg2->GetFloat(); + } + } + + //----------------------------------------------------------- + const char_type* OprtMul::GetDesc() const + { + return _T("multiplication"); + } + + //----------------------------------------------------------- + IToken* OprtMul::Clone() const + { + return new OprtMul(*this); + } + +//----------------------------------------------------------- +// +// class OprtDiv +// +//----------------------------------------------------------- + + + OprtDiv::OprtDiv() + :IOprtBin(_T("/"), (int)prMUL_DIV, oaLEFT) + {} + + //----------------------------------------------------------- + /** \brief Implements the Division operator. + \throw ParserError in case one of the arguments if + nonnumeric or an array. + + */ + void OprtDiv::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) + { + assert(num==2); + + if (!a_pArg[0]->IsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[0]->GetType(), 'f', 1)); + + if (!a_pArg[1]->IsNonComplexScalar()) + throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[1]->GetType(), 'f', 2)); + + *ret = a_pArg[0]->GetFloat() / a_pArg[1]->GetFloat(); + } + + //----------------------------------------------------------- + const char_type* OprtDiv::GetDesc() const + { + return _T("division"); + } + + //----------------------------------------------------------- + IToken* OprtDiv::Clone() const + { + return new OprtDiv(*this); + } + +//----------------------------------------------------------- +// +// class OprtPow +// +//----------------------------------------------------------- + + OprtPow::OprtPow() + :IOprtBin(_T("^"), (int)prPOW, oaRIGHT) + {} + + //----------------------------------------------------------- + void OprtPow::Eval(ptr_val_type& ret, const ptr_val_type *arg, int argc) + { + assert(argc==2); + float_type a = arg[0]->GetFloat(); + float_type b = arg[1]->GetFloat(); + + int ib = (int)b; + if (b-ib==0) + { + switch (ib) + { + case 1: *ret = a; return; + case 2: *ret = a*a; return; + case 3: *ret = a*a*a; return; + case 4: *ret = a*a*a*a; return; + case 5: *ret = a*a*a*a*a; return; + default: *ret = std::pow(a, ib); return; + } + } + else + *ret = std::pow(a, b); + } + + //----------------------------------------------------------- + const char_type* OprtPow::GetDesc() const + { + return _T("x^y - Raises x to the power of y."); + } + + //----------------------------------------------------------- + IToken* OprtPow::Clone() const + { + return new OprtPow(*this); + } +} diff --git a/src/third-party/headers/muparserx/mpOprtPostfixCommon.cpp b/src/third-party/headers/muparserx/mpOprtPostfixCommon.cpp new file mode 100755 index 0000000000..f8ba01e895 --- /dev/null +++ b/src/third-party/headers/muparserx/mpOprtPostfixCommon.cpp @@ -0,0 +1,112 @@ +#include +#include "mpOprtPostfixCommon.h" + +MUP_NAMESPACE_START + +//----------------------------------------------------------- +// +// class OprtFact +// +//----------------------------------------------------------- + + OprtFact::OprtFact() + :IOprtPostfix(_T("!")) + {} + + //----------------------------------------------------------- + void OprtFact::Eval(ptr_val_type& ret, const ptr_val_type *arg, int) + { + if (!arg[0]->IsInteger()) + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), arg[0]->GetType(), 'i', 1)); + + int_type input = arg[0]->GetInteger(); + float_type input_long = float_type(input); + + if (input < 0) { + throw ParserError(ErrorContext(ecDOMAIN_ERROR, GetExprPos(), + GetIdent())); + } + + float_type result = 1; + for (float_type i = 1.0; i <= input_long; i += 1.0) + { + result *= i; + + // Only throw exceptions if IEEE 754 is not supported. The + // Prefered way of dealing with overflows is relying on: + // + // http://en.wikipedia.org/wiki/IEEE_754-1985 + // + // If the compiler does not support IEEE 754, chances are + // you are running on a pretty fucked up system. + // + #ifdef _MSC_VER + #pragma warning(push) + #pragma warning(disable:4127) + #endif /* _MSC_VER */ + if ( !std::numeric_limits::is_iec559 && + (result>std::numeric_limits::max() || result < 1.0) ) + #ifdef _MSC_VER + #pragma warning(pop) + #endif /* _MSC_VER */ + { + throw ParserError(ErrorContext(ecOVERFLOW, GetExprPos(), GetIdent())); + } + // + } + + *ret = result; + } + + //----------------------------------------------------------- + const char_type* OprtFact::GetDesc() const + { + return _T("x! - Returns factorial of a non-negative integer."); + } + + //----------------------------------------------------------- + IToken* OprtFact::Clone() const + { + return new OprtFact(*this); + } + + //----------------------------------------------------------- + // + // class OprtPercentage + // + //----------------------------------------------------------- + + OprtPercentage::OprtPercentage() + :IOprtPostfix(_T("%")) + {} + + //----------------------------------------------------------- + void OprtPercentage::Eval(ptr_val_type& ret, const ptr_val_type *arg, int) + { + + switch (arg[0]->GetType()) { + case 'i': + case 'f': { + float_type input = arg[0]->GetFloat(); + *ret = input / 100.0; + break; + } + default: + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), arg[0]->GetType(), 'f', 1)); + break; + } + } + + //----------------------------------------------------------- + const char_type* OprtPercentage::GetDesc() const + { + return _T("x% - Returns percentage of integer/float."); + } + + //----------------------------------------------------------- + IToken* OprtPercentage::Clone() const + { + return new OprtPercentage(*this); + } + +} diff --git a/src/third-party/headers/muparserx/mpPackageCmplx.cpp b/src/third-party/headers/muparserx/mpPackageCmplx.cpp new file mode 100644 index 0000000000..29435c48f1 --- /dev/null +++ b/src/third-party/headers/muparserx/mpPackageCmplx.cpp @@ -0,0 +1,102 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpPackageCmplx.h" + +#include "mpParserBase.h" +#include "mpFuncCmplx.h" +#include "mpOprtCmplx.h" +#include "mpOprtBinCommon.h" + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------ +std::unique_ptr PackageCmplx::s_pInstance; + +//------------------------------------------------------------------------------ +IPackage* PackageCmplx::Instance() +{ + if (s_pInstance.get()==nullptr) + { + s_pInstance.reset(new PackageCmplx); + } + + return s_pInstance.get(); +} + +//------------------------------------------------------------------------------ +void PackageCmplx::AddToParser(ParserXBase *pParser) +{ + // Constants + pParser->DefineConst( _T("i"), cmplx_type(0.0, 1.0) ); + + // Complex valued functions + pParser->DefineFun(new FunCmplxReal()); + pParser->DefineFun(new FunCmplxImag()); + pParser->DefineFun(new FunCmplxConj()); + pParser->DefineFun(new FunCmplxArg()); + pParser->DefineFun(new FunCmplxNorm()); + pParser->DefineFun(new FunCmplxSin()); + pParser->DefineFun(new FunCmplxCos()); + pParser->DefineFun(new FunCmplxTan()); + pParser->DefineFun(new FunCmplxSinH()); + pParser->DefineFun(new FunCmplxCosH()); + pParser->DefineFun(new FunCmplxTanH()); + pParser->DefineFun(new FunCmplxSqrt()); + pParser->DefineFun(new FunCmplxExp()); + pParser->DefineFun(new FunCmplxLn()); + pParser->DefineFun(new FunCmplxLog()); + pParser->DefineFun(new FunCmplxLog2()); + pParser->DefineFun(new FunCmplxLog10()); + pParser->DefineFun(new FunCmplxAbs()); + pParser->DefineFun(new FunCmplxPow()); + + // Complex valued operators + pParser->DefineOprt(new OprtAddCmplx()); + pParser->DefineOprt(new OprtSubCmplx()); + pParser->DefineOprt(new OprtMulCmplx()); + pParser->DefineOprt(new OprtDivCmplx()); + pParser->DefineOprt(new OprtPowCmplx()); + pParser->DefineInfixOprt(new OprtSignCmplx()); +} + +//------------------------------------------------------------------------------ +string_type PackageCmplx::GetDesc() const +{ + return _T(""); +} + +//------------------------------------------------------------------------------ +string_type PackageCmplx::GetPrefix() const +{ + return _T(""); +} + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageCommon.cpp b/src/third-party/headers/muparserx/mpPackageCommon.cpp new file mode 100644 index 0000000000..30fec3c1c0 --- /dev/null +++ b/src/third-party/headers/muparserx/mpPackageCommon.cpp @@ -0,0 +1,141 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpPackageCommon.h" + +#include "mpParserBase.h" +#include "mpFuncNonCmplx.h" +#include "mpFuncCommon.h" +#include "mpOprtBinCommon.h" +#include "mpOprtBinAssign.h" +#include "mpOprtPostfixCommon.h" +#include "mpValReader.h" + +/** \brief Pi (what else?). */ +#define MUP_CONST_PI 3.141592653589793238462643 +//#define MUP_CONST_PI 3.14159265358979323846264338327950288419716939937510L + +/** \brief The eulerian number. */ +#define MUP_CONST_E 2.718281828459045235360287 + + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------ +std::unique_ptr PackageCommon::s_pInstance; + +//------------------------------------------------------------------------------ +IPackage* PackageCommon::Instance() +{ + if (s_pInstance.get()==nullptr) + { + s_pInstance.reset(new PackageCommon); + } + + return s_pInstance.get(); +} + +//------------------------------------------------------------------------------ +void PackageCommon::AddToParser(ParserXBase *pParser) +{ + // Readers that need fancy decorations on their values must + // be added first (i.e. hex -> "0x...") Otherwise the + // zero in 0x will be read as a value of zero! + pParser->AddValueReader(new HexValReader); + pParser->AddValueReader(new BinValReader); + pParser->AddValueReader(new DblValReader); + pParser->AddValueReader(new BoolValReader); + + // Constants + pParser->DefineConst( _T("pi"), (float_type)MUP_CONST_PI ); + pParser->DefineConst( _T("e"), (float_type)MUP_CONST_E ); + + // Vector + pParser->DefineFun(new FunSizeOf()); + + // Generic functions + pParser->DefineFun(new FunMax()); + pParser->DefineFun(new FunMin()); + pParser->DefineFun(new FunSum()); + + // misc + pParser->DefineFun(new FunParserID); + + // integer package + pParser->DefineOprt(new OprtLAnd); + pParser->DefineOprt(new OprtLOr); + pParser->DefineOprt(new OprtAnd); + pParser->DefineOprt(new OprtOr); + pParser->DefineOprt(new OprtShr); + pParser->DefineOprt(new OprtShl); + + // booloean package + pParser->DefineOprt(new OprtLE); + pParser->DefineOprt(new OprtGE); + pParser->DefineOprt(new OprtLT); + pParser->DefineOprt(new OprtGT); + pParser->DefineOprt(new OprtEQ); + pParser->DefineOprt(new OprtNEQ); + pParser->DefineOprt(new OprtLAnd(_T("and"))); // add logic and with a different identifier + pParser->DefineOprt(new OprtLOr(_T("or"))); // add logic and with a different identifier +// pParser->DefineOprt(new OprtBXor); + + // assignement operators + pParser->DefineOprt(new OprtAssign); + pParser->DefineOprt(new OprtAssignAdd); + pParser->DefineOprt(new OprtAssignSub); + pParser->DefineOprt(new OprtAssignMul); + pParser->DefineOprt(new OprtAssignDiv); + + // infix operators + pParser->DefineInfixOprt(new OprtCastToFloat); + pParser->DefineInfixOprt(new OprtCastToInt); + + // postfix operators + pParser->DefinePostfixOprt(new OprtFact); +// commented: "%" is a reserved sign for either the +// modulo operator or comment lines. +// pParser->DefinePostfixOprt(new OprtPercentage); +// +} + +//------------------------------------------------------------------------------ +string_type PackageCommon::GetDesc() const +{ + return _T(""); +} + +//------------------------------------------------------------------------------ +string_type PackageCommon::GetPrefix() const +{ + return _T(""); +} + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageMatrix.cpp b/src/third-party/headers/muparserx/mpPackageMatrix.cpp new file mode 100644 index 0000000000..26dc20b949 --- /dev/null +++ b/src/third-party/headers/muparserx/mpPackageMatrix.cpp @@ -0,0 +1,82 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpPackageMatrix.h" + +#include "mpParserBase.h" +#include "mpFuncMatrix.h" +#include "mpOprtMatrix.h" + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------ +std::unique_ptr PackageMatrix::s_pInstance; + +//------------------------------------------------------------------------------ +IPackage* PackageMatrix::Instance() +{ + if (s_pInstance.get()==nullptr) + { + s_pInstance.reset(new PackageMatrix); + } + + return s_pInstance.get(); +} + +//------------------------------------------------------------------------------ +void PackageMatrix::AddToParser(ParserXBase *pParser) +{ + // Matrix functions + pParser->DefineFun(new FunMatrixOnes()); + pParser->DefineFun(new FunMatrixZeros()); + pParser->DefineFun(new FunMatrixEye()); + pParser->DefineFun(new FunMatrixSize()); + + // Matrix Operators + pParser->DefinePostfixOprt(new OprtTranspose()); + + // Colon operator +//pParser->DefineOprt(new OprtColon()); +//pParser->DefineAggregator(new AggColon()); +} + +//------------------------------------------------------------------------------ +string_type PackageMatrix::GetDesc() const +{ + return _T("Operators and functions for matrix operations"); +} + +//------------------------------------------------------------------------------ +string_type PackageMatrix::GetPrefix() const +{ + return _T(""); +} + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageNonCmplx.cpp b/src/third-party/headers/muparserx/mpPackageNonCmplx.cpp new file mode 100644 index 0000000000..fca5624429 --- /dev/null +++ b/src/third-party/headers/muparserx/mpPackageNonCmplx.cpp @@ -0,0 +1,108 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpPackageNonCmplx.h" + +#include "mpParserBase.h" +#include "mpFuncNonCmplx.h" +#include "mpOprtNonCmplx.h" +#include "mpOprtBinCommon.h" + + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------ +std::unique_ptr PackageNonCmplx::s_pInstance; + +//------------------------------------------------------------------------------ +IPackage* PackageNonCmplx::Instance() +{ + if (s_pInstance.get()==nullptr) + { + s_pInstance.reset(new PackageNonCmplx); + } + + return s_pInstance.get(); +} + +//------------------------------------------------------------------------------ +void PackageNonCmplx::AddToParser(ParserXBase *pParser) +{ + pParser->DefineFun(new FunSin()); + pParser->DefineFun(new FunCos()); + pParser->DefineFun(new FunTan()); + pParser->DefineFun(new FunSinH()); + pParser->DefineFun(new FunCosH()); + pParser->DefineFun(new FunTanH()); + pParser->DefineFun(new FunASin()); + pParser->DefineFun(new FunACos()); + pParser->DefineFun(new FunATan()); + pParser->DefineFun(new FunASinH()); + pParser->DefineFun(new FunACosH()); + pParser->DefineFun(new FunATanH()); + pParser->DefineFun(new FunLog()); + pParser->DefineFun(new FunLog10()); + pParser->DefineFun(new FunLog2()); + pParser->DefineFun(new FunLn()); + pParser->DefineFun(new FunExp()); + pParser->DefineFun(new FunSqrt()); + pParser->DefineFun(new FunCbrt()); + pParser->DefineFun(new FunAbs()); + + // binary functions + pParser->DefineFun(new FunPow()); + pParser->DefineFun(new FunHypot()); + pParser->DefineFun(new FunAtan2()); + pParser->DefineFun(new FunFmod()); + pParser->DefineFun(new FunRemainder()); + + // Operator callbacks + pParser->DefineInfixOprt(new OprtSign()); + pParser->DefineInfixOprt(new OprtSignPos()); + pParser->DefineOprt(new OprtAdd()); + pParser->DefineOprt(new OprtSub()); + pParser->DefineOprt(new OprtMul()); + pParser->DefineOprt(new OprtDiv()); + pParser->DefineOprt(new OprtPow); +} + +//------------------------------------------------------------------------------ +string_type PackageNonCmplx::GetDesc() const +{ + return _T(""); +} + +//------------------------------------------------------------------------------ +string_type PackageNonCmplx::GetPrefix() const +{ + return _T(""); +} + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageStr.cpp b/src/third-party/headers/muparserx/mpPackageStr.cpp new file mode 100644 index 0000000000..2fc00a0ec7 --- /dev/null +++ b/src/third-party/headers/muparserx/mpPackageStr.cpp @@ -0,0 +1,81 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpPackageStr.h" + +#include "mpParserBase.h" +#include "mpFuncStr.h" +#include "mpOprtBinCommon.h" +#include "mpValReader.h" + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------ +std::unique_ptr PackageStr::s_pInstance; + +//------------------------------------------------------------------------------ +IPackage* PackageStr::Instance() +{ + if (s_pInstance.get()==nullptr) + { + s_pInstance.reset(new PackageStr); + } + + return s_pInstance.get(); +} + +//------------------------------------------------------------------------------ +void PackageStr::AddToParser(ParserXBase *pParser) +{ + pParser->AddValueReader(new StrValReader()); + + // Functions + pParser->DefineFun(new FunStrLen()); + pParser->DefineFun(new FunStrToDbl()); + pParser->DefineFun(new FunStrToUpper()); + pParser->DefineFun(new FunStrToLower()); + + // Operators + pParser->DefineOprt(new OprtStrAdd); +} + +//------------------------------------------------------------------------------ +string_type PackageStr::GetDesc() const +{ + return _T("A package for string operations."); +} + +//------------------------------------------------------------------------------ +string_type PackageStr::GetPrefix() const +{ + return _T(""); +} + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageUnit.cpp b/src/third-party/headers/muparserx/mpPackageUnit.cpp new file mode 100644 index 0000000000..7420e75e30 --- /dev/null +++ b/src/third-party/headers/muparserx/mpPackageUnit.cpp @@ -0,0 +1,119 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpPackageUnit.h" + +#include "mpParserBase.h" + + +MUP_NAMESPACE_START + +/** \brief This is a macro for defining scaling postfix operators. + + These operators can be used for unit conversions. +*/ +#define MUP_POSTFIX_IMLP(CLASS, IDENT, MUL, DESC) \ + CLASS::CLASS(IPackage*) \ + :IOprtPostfix(_T(IDENT)) \ + {} \ + \ + void CLASS::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) \ + { \ + if (!a_pArg[0]->IsScalar()) \ + { \ + ErrorContext err(ecTYPE_CONFLICT, \ + GetExprPos(), \ + a_pArg[0]->ToString(), \ + a_pArg[0]->GetType(), \ + 'c', \ + 1); \ + throw ParserError(err); \ + } \ + \ + *ret = a_pArg[0]->GetComplex() * MUL; \ + } \ + \ + const char_type* CLASS::GetDesc() const \ + { \ + return _T(DESC); \ + } \ + \ + IToken* CLASS::Clone() const \ + { \ + return new CLASS(*this); \ + } + + MUP_POSTFIX_IMLP(OprtNano, "n", (float_type)1e-9, "n - unit multiplicator 1e-9") + MUP_POSTFIX_IMLP(OprtMicro, "u", (float_type)1e-6, "u - unit multiplicator 1e-6") + MUP_POSTFIX_IMLP(OprtMilli, "m", (float_type)1e-3, "m - unit multiplicator 1e-3") + MUP_POSTFIX_IMLP(OprtKilo, "k", (float_type)1e3, "k - unit multiplicator 1e3") + MUP_POSTFIX_IMLP(OprtMega, "M", (float_type)1e6, "M - unit multiplicator 1e6") + MUP_POSTFIX_IMLP(OprtGiga, "G", (float_type)1e9, "G - unit multiplicator 1e9") + +#undef MUP_POSTFIX_IMLP + +//------------------------------------------------------------------------------ +std::unique_ptr PackageUnit::s_pInstance; + +//------------------------------------------------------------------------------ +IPackage* PackageUnit::Instance() +{ + if (s_pInstance.get()==nullptr) + { + s_pInstance.reset(new PackageUnit); + } + + return s_pInstance.get(); +} + +//------------------------------------------------------------------------------ +void PackageUnit::AddToParser(ParserXBase *pParser) +{ + pParser->DefinePostfixOprt(new OprtNano(this)); + pParser->DefinePostfixOprt(new OprtMicro(this)); + pParser->DefinePostfixOprt(new OprtMilli(this)); + pParser->DefinePostfixOprt(new OprtKilo(this)); + pParser->DefinePostfixOprt(new OprtMega(this)); + pParser->DefinePostfixOprt(new OprtGiga(this)); +} + +//------------------------------------------------------------------------------ +string_type PackageUnit::GetDesc() const +{ + return _T("Postfix operators for basic unit conversions."); +} + +//------------------------------------------------------------------------------ +string_type PackageUnit::GetPrefix() const +{ + return _T(""); +} + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpParser.cpp b/src/third-party/headers/muparserx/mpParser.cpp new file mode 100644 index 0000000000..59ea64d8ba --- /dev/null +++ b/src/third-party/headers/muparserx/mpParser.cpp @@ -0,0 +1,91 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ + +#include "mpParser.h" + +//--- Standard includes ---------------------------------------------------- +#include +#include +#include + +//--- Parser framework ----------------------------------------------------- +#include "mpPackageUnit.h" +#include "mpPackageStr.h" +#include "mpPackageCmplx.h" +#include "mpPackageNonCmplx.h" +#include "mpPackageCommon.h" +#include "mpPackageMatrix.h" + +using namespace std; + + +/** \brief Namespace for mathematical applications. */ +MUP_NAMESPACE_START + + //--------------------------------------------------------------------------- + /** \brief Default constructor. + + Call ParserXBase class constructor and initiate function, operator + and constant initialization. + */ + ParserX::ParserX(unsigned ePackages) + :ParserXBase() + { + DefineNameChars(_T("0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")); + DefineOprtChars(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+-*^/?<>=#!$%&|~'_µ{}")); + DefineInfixOprtChars(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ()/+-*^?<>=#!$%&|~'_")); + + if (ePackages & pckUNIT) + AddPackage(PackageUnit::Instance()); + + if (ePackages & pckSTRING) + AddPackage(PackageStr::Instance()); + + if (ePackages & pckCOMPLEX) + AddPackage(PackageCmplx::Instance()); + + if (ePackages & pckNON_COMPLEX) + AddPackage(PackageNonCmplx::Instance()); + + if (ePackages & pckCOMMON) + AddPackage(PackageCommon::Instance()); + + if (ePackages & pckMATRIX) + AddPackage(PackageMatrix::Instance()); + } + + //------------------------------------------------------------------------------ + void ParserX::ResetErrorMessageProvider(ParserMessageProviderBase *pProvider) + { + ParserErrorMsg::Reset(pProvider); + } + +} // namespace mu diff --git a/src/third-party/headers/muparserx/mpParserBase.cpp b/src/third-party/headers/muparserx/mpParserBase.cpp new file mode 100644 index 0000000000..cddb65103a --- /dev/null +++ b/src/third-party/headers/muparserx/mpParserBase.cpp @@ -0,0 +1,1301 @@ +/** \file + \brief Implementation of the muParserX engine. + +
+			   __________                                 ____  ___
+	 _____  __ _\______   \_____ _______  ______ __________\   \/  /
+	/     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
+	|  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
+	|__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+		  \/                     \/           \/     \/           \_/
+	Copyright (C) 2016 Ingo Berg
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright notice,
+	this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright notice,
+	this list of conditions and the following disclaimer in the documentation
+	and/or other materials provided with the distribution.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+	IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+	WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+	POSSIBILITY OF SUCH DAMAGE.
+	
+ */ +#include "mpParserBase.h" + +#include +#include +#include +#include + +#include "utGeneric.h" +#include "mpDefines.h" +#include "mpIfThenElse.h" +#include "mpScriptTokens.h" + +using namespace std; + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------ +const char_type *g_sCmdCode[] = { + _T("BRCK. OPEN "), + _T("BRCK. CLOSE "), + _T("IDX OPEN "), + _T("IDX CLOSE "), + _T("CURLY BRCK. OPEN "), + _T("CURLY BRCK. CLOSE"), + _T("ARG_SEP "), + _T("IF "), + _T("ELSE "), + _T("ENDIF "), + _T("JMP "), + _T("VAL "), + _T("FUNC "), + _T("OPRT_BIN "), + _T("OPRT_IFX "), + _T("OPRT_PFX "), + _T("END "), + _T("SCR_ENDL "), + _T("SCR_CMT "), + _T("SCR_WHILE "), + _T("SCR_GOTO "), + _T("SCR_LABEL "), + _T("SCR_FOR "), + _T("SCR_IF "), + _T("SCR_ELSE "), + _T("SCR_ELIF "), + _T("SCR_ENDIF "), + _T("SCR_FUNC "), + _T("UNKNOWN "), + nullptr }; + +//------------------------------------------------------------------------------ +bool ParserXBase::s_bDumpStack = false; +bool ParserXBase::s_bDumpRPN = false; + +//------------------------------------------------------------------------------ +/** \brief Identifiers for built in binary operators. + + When defining custom binary operators with AddOprt(...) make sure not to choose + names conflicting with these definitions. + */ +const char_type* ParserXBase::c_DefaultOprt[] = { + _T("("), + _T(")"), + _T("["), + _T("]"), + _T("{"), + _T("}"), + _T(","), + _T("?"), + _T(":"), + 0 }; + +//------------------------------------------------------------------------------ +/** \brief Default constructor. */ +ParserXBase::ParserXBase() + :m_FunDef() + , m_PostOprtDef() + , m_InfixOprtDef() + , m_OprtDef() + , m_valDef() + , m_varDef() + , m_pParserEngine(&ParserXBase::ParseFromString) + , m_pTokenReader() + , m_valDynVarShadow() + , m_sNameChars() + , m_sOprtChars() + , m_sInfixOprtChars() + , m_bIsQueryingExprVar(false) + , m_bAutoCreateVar(false) + , m_rpn() + , m_vStackBuffer() +{ + InitTokenReader(); +} + +//--------------------------------------------------------------------------- +/** \brief Copy constructor. + \param a_Parser Reference to the other parser object + + Implemented by calling Assign(a_Parser) + */ +ParserXBase::ParserXBase(const ParserXBase &a_Parser) + :m_FunDef() + , m_PostOprtDef() + , m_InfixOprtDef() + , m_OprtDef() + , m_valDef() + , m_varDef() + , m_pParserEngine(&ParserXBase::ParseFromString) + , m_pTokenReader() + , m_valDynVarShadow() + , m_sNameChars() + , m_sOprtChars() + , m_sInfixOprtChars() + , m_bAutoCreateVar() + , m_rpn() + , m_vStackBuffer() +{ + m_pTokenReader.reset(new TokenReader(this)); + Assign(a_Parser); +} + +//--------------------------------------------------------------------------- +/** \brief Destructor. + \throw nothrow + */ +ParserXBase::~ParserXBase() +{ + // It is important to release the stack buffer before + // releasing the value cache. Since it may contain + // Values referencing the cache. + m_vStackBuffer.clear(); + m_cache.ReleaseAll(); +} + +//--------------------------------------------------------------------------- +/** \brief Assignement operator. + \param a_Parser Object to copy to this. + \return *this + \throw nothrow + + Implemented by calling Assign(a_Parser). Self assignement is suppressed. + */ +ParserXBase& ParserXBase::operator=(const ParserXBase &a_Parser) +{ + Assign(a_Parser); + return *this; +} + +//--------------------------------------------------------------------------- +/** \brief Copy state of a parser object to this. + \param a_Parser the source object. + + Clears Variables and Functions of this parser. + Copies the states of all internal variables. + Resets parse function to string parse mode. + */ +void ParserXBase::Assign(const ParserXBase &ref) +{ + if (&ref == this) + return; + + // Don't copy bytecode instead cause the parser to create new bytecode + // by resetting the parse function. + ReInit(); + + m_pTokenReader.reset(ref.m_pTokenReader->Clone(this)); + + m_OprtDef = ref.m_OprtDef; + m_FunDef = ref.m_FunDef; + m_PostOprtDef = ref.m_PostOprtDef; + m_InfixOprtDef = ref.m_InfixOprtDef; + m_valDef = ref.m_valDef; + m_valDynVarShadow = ref.m_valDynVarShadow; + m_varDef = ref.m_varDef; // Copy user defined variables + + // Copy charsets + m_sNameChars = ref.m_sNameChars; + m_sOprtChars = ref.m_sOprtChars; + m_sInfixOprtChars = ref.m_sInfixOprtChars; + + m_bAutoCreateVar = ref.m_bAutoCreateVar; + + // Things that should not be copied: + // - m_vStackBuffer + // - m_cache + // - m_rpn +} + +//--------------------------------------------------------------------------- +/** \brief Evaluate the expression. + \pre A formula must be set. + \pre Variables must have been set (if needed) + \sa SetExpr + \return The evaluation result + \throw ParseException if no Formula is set or in case of any other error related to the formula. + + A note on const correctness: + I consider it important that Calc is a const function. + Due to caching operations Calc changes only the state of internal variables with one exception + m_UsedVar this is reset during string parsing and accessible from the outside. Instead of making + Calc non const GetExprVar is non const because it explicitely calls Eval() forcing this update. + */ +const IValue& ParserXBase::Eval() const +{ + return (this->*m_pParserEngine)(); +} + +//--------------------------------------------------------------------------- +/** \brief Return the strings of all Operator identifiers. + \return Returns a pointer to the c_DefaultOprt array of const char *. + \throw nothrow + + GetOprt is a const function returning a pinter to an array of const char pointers. + */ +const char_type** ParserXBase::GetOprtDef() const +{ + return (const char_type **)(&c_DefaultOprt[0]); +} + +//--------------------------------------------------------------------------- +/** \brief Define the set of valid characters to be used in names of + functions, variables, constants. + */ +void ParserXBase::DefineNameChars(const char_type *a_szCharset) +{ + m_sNameChars = a_szCharset; +} + +//--------------------------------------------------------------------------- +/** \brief Define the set of valid characters to be used in names of + binary operators and postfix operators. + \param a_szCharset A string containing all characters that can be used + in operator identifiers. + */ +void ParserXBase::DefineOprtChars(const char_type *a_szCharset) +{ + m_sOprtChars = a_szCharset; +} + +//--------------------------------------------------------------------------- +/** \brief Define the set of valid characters to be used in names of + infix operators. + \param a_szCharset A string containing all characters that can be used + in infix operator identifiers. + */ +void ParserXBase::DefineInfixOprtChars(const char_type *a_szCharset) +{ + m_sInfixOprtChars = a_szCharset; +} + +//--------------------------------------------------------------------------- +/** \brief Virtual function that defines the characters allowed in name identifiers. + \sa #ValidOprtChars, #ValidPrefixOprtChars + */ +const char_type* ParserXBase::ValidNameChars() const +{ + MUP_VERIFY(m_sNameChars.size()); + return m_sNameChars.c_str(); +} + +//--------------------------------------------------------------------------- +/** \brief Virtual function that defines the characters allowed in operator definitions. + \sa #ValidNameChars, #ValidPrefixOprtChars + */ +const char_type* ParserXBase::ValidOprtChars() const +{ + MUP_VERIFY(m_sOprtChars.size()); + return m_sOprtChars.c_str(); +} + +//--------------------------------------------------------------------------- +/** \brief Virtual function that defines the characters allowed in infix operator definitions. + \sa #ValidNameChars, #ValidOprtChars + */ +const char_type* ParserXBase::ValidInfixOprtChars() const +{ + MUP_VERIFY(m_sInfixOprtChars.size()); + return m_sInfixOprtChars.c_str(); +} + +//--------------------------------------------------------------------------- +/** \brief Initialize the token reader. + \post m_pTokenReader.Get()!=0 + \throw nothrow + + Create new token reader object and submit pointers to function, operator, + constant and variable definitions. + */ +void ParserXBase::InitTokenReader() +{ + m_pTokenReader.reset(new TokenReader(this)); +} + +//--------------------------------------------------------------------------- +/** \brief Reset parser to string parsing mode and clear internal buffers. + \throw nothrow + + Resets the token reader. + */ +void ParserXBase::ReInit() const +{ + m_pParserEngine = &ParserXBase::ParseFromString; + m_pTokenReader->ReInit(); + m_rpn.Reset(); + m_vStackBuffer.clear(); + m_nPos = 0; +} + +//--------------------------------------------------------------------------- +/** \brief Adds a new package to the parser. + + The parser becomes the owner of the package pointer and is responsible for + its deletion. + */ +void ParserXBase::AddPackage(IPackage *p) +{ + p->AddToParser(this); +} + +//--------------------------------------------------------------------------- +/** \brief Add a value reader object to muParserX. + \param a_pReader Pointer to the value reader object. + */ +void ParserXBase::AddValueReader(IValueReader *a_pReader) +{ + m_pTokenReader->AddValueReader(a_pReader); +} + +//--------------------------------------------------------------------------- +/** \brief Check if a given name contains invalid characters. + \param a_strName The name to check + \param a_szCharSet The characterset + \throw ParserException if the name contains invalid charakters. + */ +void ParserXBase::CheckName(const string_type &a_strName, + const string_type &a_szCharSet) const +{ + if (!a_strName.length() || + (a_strName.find_first_not_of(a_szCharSet) != string_type::npos) || + (a_strName[0] >= (char_type)'0' && a_strName[0] <= (char_type)'9')) + { + Error(ecINVALID_NAME); + } +} + +//--------------------------------------------------------------------------- +/** \brief Set the mathematical expression. + \param a_sExpr String with the expression + \throw ParserException in case of syntax errors. + + Triggers first time calculation thus the creation of the bytecode and + scanning of used variables. + */ +void ParserXBase::SetExpr(const string_type &a_sExpr) +{ + m_pTokenReader->SetExpr(a_sExpr); + ReInit(); +} + +//--------------------------------------------------------------------------- +/** \brief Add a user defined variable. + \param a_sName The variable name + \param a_Var The variable to be added to muParserX + */ +void ParserXBase::DefineVar(const string_type &ident, const Variable &var) +{ + CheckName(ident, ValidNameChars()); + + CheckForEntityExistence(ident, ecVARIABLE_DEFINED); + + m_varDef[ident] = ptr_tok_type(var.Clone()); +} + +void ParserXBase::CheckForEntityExistence(const string_type &ident, EErrorCodes error_code) +{ + if (IsVarDefined(ident) || + IsConstDefined(ident) || + IsFunDefined(ident) || + IsOprtDefined(ident) || + IsPostfixOprtDefined(ident) || + IsInfixOprtDefined(ident)) + throw ParserError(ErrorContext(error_code, 0, ident)); +} + +//--------------------------------------------------------------------------- +/** \brief Define a parser Constant. + \param a_sName The name of the constant + \param a_Val Const reference to the constants value + + Parser constants are handed over by const reference as opposed to variables + which are handed over by reference. Consequently the parser can not change + their value. + */ +void ParserXBase::DefineConst(const string_type &ident, const Value &val) +{ + CheckName(ident, ValidNameChars()); + + CheckForEntityExistence(ident, ecCONSTANT_DEFINED); + + m_valDef[ident] = ptr_tok_type(val.Clone()); +} + +//--------------------------------------------------------------------------- +/** \brief Add a callback object to the parser. + \param a_pFunc Pointer to the intance of a parser callback object + representing the function. + \sa GetFunDef, functions + + The parser takes ownership over the callback object. + */ +void ParserXBase::DefineFun(const ptr_cal_type &fun) +{ + if (IsFunDefined(fun->GetIdent())) + throw ParserError(ErrorContext(ecFUNOPRT_DEFINED, 0, fun->GetIdent())); + + fun->SetParent(this); + m_FunDef[fun->GetIdent()] = ptr_tok_type(fun->Clone()); +} + +//--------------------------------------------------------------------------- +/** \brief Define a binary operator. + \param a_pCallback Pointer to the callback object + */ +void ParserXBase::DefineOprt(const TokenPtr &oprt) +{ + if (IsOprtDefined(oprt->GetIdent())) + throw ParserError(ErrorContext(ecFUNOPRT_DEFINED, 0, oprt->GetIdent())); + + oprt->SetParent(this); + m_OprtDef[oprt->GetIdent()] = ptr_tok_type(oprt->Clone()); +} + +//--------------------------------------------------------------------------- +/** \brief Add a user defined operator. + \post Will reset the Parser to string parsing mode. + \param a_pOprt Pointer to a unary postfix operator object. The parser will + become the new owner of this object hence will destroy it. + */ +void ParserXBase::DefinePostfixOprt(const TokenPtr &oprt) +{ + if (IsPostfixOprtDefined(oprt->GetIdent())) + throw ParserError(ErrorContext(ecFUNOPRT_DEFINED, 0, oprt->GetIdent())); + + // Operator is not added yet, add it. + oprt->SetParent(this); + m_PostOprtDef[oprt->GetIdent()] = ptr_tok_type(oprt->Clone()); +} + +//--------------------------------------------------------------------------- +/** \brief Add a user defined operator. + \param a_pOprt Pointer to a unary postfix operator object. The parser will + become the new owner of this object hence will destroy it. +*/ +void ParserXBase::DefineInfixOprt(const TokenPtr &oprt) +{ + if (IsInfixOprtDefined(oprt->GetIdent())) + throw ParserError(ErrorContext(ecFUNOPRT_DEFINED, 0, oprt->GetIdent())); + + // Function is not added yet, add it. + oprt->SetParent(this); + m_InfixOprtDef[oprt->GetIdent()] = ptr_tok_type(oprt->Clone()); +} + +//--------------------------------------------------------------------------- +void ParserXBase::RemoveVar(const string_type &ident) +{ + m_varDef.erase(ident); + ReInit(); +} + +//--------------------------------------------------------------------------- +void ParserXBase::RemoveConst(const string_type &ident) +{ + m_valDef.erase(ident); + ReInit(); +} + +//--------------------------------------------------------------------------- +void ParserXBase::RemoveFun(const string_type &ident) +{ + m_FunDef.erase(ident); + ReInit(); +} + +//--------------------------------------------------------------------------- +void ParserXBase::RemoveOprt(const string_type &ident) +{ + m_OprtDef.erase(ident); + ReInit(); +} + +//--------------------------------------------------------------------------- +void ParserXBase::RemovePostfixOprt(const string_type &ident) +{ + m_PostOprtDef.erase(ident); + ReInit(); +} + +//--------------------------------------------------------------------------- +void ParserXBase::RemoveInfixOprt(const string_type &ident) +{ + m_InfixOprtDef.erase(ident); + ReInit(); +} + +//--------------------------------------------------------------------------- +bool ParserXBase::IsVarDefined(const string_type &ident) const +{ + return m_varDef.find(ident) != m_varDef.end(); +} + +//--------------------------------------------------------------------------- +bool ParserXBase::IsConstDefined(const string_type &ident) const +{ + return m_valDef.find(ident) != m_valDef.end(); +} + +//--------------------------------------------------------------------------- +bool ParserXBase::IsFunDefined(const string_type &ident) const +{ + return m_FunDef.find(ident) != m_FunDef.end(); +} + +//--------------------------------------------------------------------------- +bool ParserXBase::IsOprtDefined(const string_type &ident) const +{ + return m_OprtDef.find(ident) != m_OprtDef.end(); +} + +//--------------------------------------------------------------------------- +bool ParserXBase::IsPostfixOprtDefined(const string_type &ident) const +{ + return m_PostOprtDef.find(ident) != m_PostOprtDef.end(); +} + +//--------------------------------------------------------------------------- +bool ParserXBase::IsInfixOprtDefined(const string_type &ident) const +{ + return m_InfixOprtDef.find(ident) != m_InfixOprtDef.end(); +} + +//--------------------------------------------------------------------------- +/** \brief Return a map containing the used variables only. */ +const var_maptype& ParserXBase::GetExprVar() const +{ + utils::scoped_setter guard(m_bIsQueryingExprVar, true); + + // Create RPN, but do not compute the result or switch to RPN + // parsing mode. The expression may contain yet to be defined variables. + CreateRPN(); + return m_pTokenReader->GetUsedVar(); +} + +//--------------------------------------------------------------------------- +/** \brief Return a map containing the used variables only. */ +const var_maptype& ParserXBase::GetVar() const +{ + return m_varDef; +} + +//--------------------------------------------------------------------------- +/** \brief Return a map containing all parser constants. */ +const val_maptype& ParserXBase::GetConst() const +{ + return m_valDef; +} + +//--------------------------------------------------------------------------- +/** \brief Return prototypes of all parser functions. + \return #m_FunDef + \sa FunProt, functions + \throw nothrow + + The return type is a map of the public type #funmap_type containing the prototype + definitions for all numerical parser functions. String functions are not part of + this map. The Prototype definition is encapsulated in objects of the class FunProt + one per parser function each associated with function names via a map construct. + */ +const fun_maptype& ParserXBase::GetFunDef() const +{ + return m_FunDef; +} + +//--------------------------------------------------------------------------- +/** \brief Retrieve the mathematical expression. */ +const string_type& ParserXBase::GetExpr() const +{ + return m_pTokenReader->GetExpr(); +} + +//--------------------------------------------------------------------------- +/** \brief Get the version number of muParserX. + \return A string containing the version number of muParserX. + */ +string_type ParserXBase::GetVersion() +{ + return MUP_PARSER_VERSION; +} + +//--------------------------------------------------------------------------- +void ParserXBase::ApplyRemainingOprt(Stack &stOpt) const + +{ + while (stOpt.size() && + stOpt.top()->GetCode() != cmBO && + stOpt.top()->GetCode() != cmIO && + stOpt.top()->GetCode() != cmCBO && + stOpt.top()->GetCode() != cmIF) + { + ptr_tok_type &op = stOpt.top(); + switch (op->GetCode()) + { + case cmOPRT_INFIX: + case cmOPRT_BIN: ApplyFunc(stOpt, 2); break; + case cmELSE: ApplyIfElse(stOpt); break; + default: Error(ecINTERNAL_ERROR); + } // switch operator token type + } // While operator stack not empty +} + +//--------------------------------------------------------------------------- +/** \brief Simulates the call of a parser function with its corresponding arguments. + \param a_stOpt The operator stack + \param a_stVal The value stack + \param a_iArgCount The number of function arguments + */ +void ParserXBase::ApplyFunc(Stack &a_stOpt, + int a_iArgCount) const +{ + if (a_stOpt.empty()) + return; + + ptr_tok_type tok = a_stOpt.pop(); + ICallback *pFun = tok->AsICallback(); + + int iArgCount = (pFun->GetArgc() >= 0) ? pFun->GetArgc() : a_iArgCount; + pFun->SetNumArgsPresent(iArgCount); + + m_nPos -= (iArgCount - 1); + m_rpn.Add(tok); +} + +//--------------------------------------------------------------------------- +/** \brief Simulates the effect of the execution of an if-then-else block. +*/ +void ParserXBase::ApplyIfElse(Stack &a_stOpt) const +{ + while (a_stOpt.size() && a_stOpt.top()->GetCode() == cmELSE) + { + MUP_VERIFY(a_stOpt.size() > 0); + MUP_VERIFY(m_nPos >= 3); + MUP_VERIFY(a_stOpt.top()->GetCode() == cmELSE); + + ptr_tok_type opElse = a_stOpt.pop(); + ptr_tok_type opIf = a_stOpt.pop(); + MUP_VERIFY(opElse->GetCode() == cmELSE) + MUP_VERIFY(opIf->GetCode() == cmIF) + + // If then else hat 3 argumente und erzeugt einen rückgabewert (3-1=2) + m_nPos -= 2; + m_rpn.Add(ptr_tok_type(new TokenIfThenElse(cmENDIF))); + } +} + +//--------------------------------------------------------------------------- +void ParserXBase::DumpRPN() const +{ + m_rpn.AsciiDump(); +} + +//--------------------------------------------------------------------------- +void ParserXBase::CreateRPN() const +{ + if (!m_pTokenReader->GetExpr().length()) + Error(ecUNEXPECTED_EOF, 0); + + // The Stacks take the ownership over the tokens + Stack stOpt; + Stack stArgCount; + Stack stIdxCount; + ptr_tok_type pTok, pTokPrev; + Value val; + + ReInit(); + + for (;;) + { + pTokPrev = pTok; + pTok = m_pTokenReader->ReadNextToken(); + +#if defined(MUP_DUMP_TOKENS) + console() << pTok->AsciiDump() << endl; +#endif + + ECmdCode eCmd = pTok->GetCode(); + switch (eCmd) + { + case cmVAL: + m_nPos++; + m_rpn.Add(pTok); + break; + + case cmCBC: + case cmIC: + { + ECmdCode eStarter = (ECmdCode)(eCmd - 1); + MUP_VERIFY(eStarter == cmCBO || eStarter == cmIO); + + // The argument count for parameterless functions is zero + // by default an opening bracket sets parameter count to 1 + // in preparation of arguments to come. If the last token + // was an opening bracket we know better... + if (pTokPrev.Get() != nullptr && pTokPrev->GetCode() == eStarter) + --stArgCount.top(); + + ApplyRemainingOprt(stOpt); + + // if opt is "]" and opta is "[" the bracket content has been evaluated. + // Now check whether there is an index operator on the stack. + if (stOpt.size() && stOpt.top()->GetCode() == eStarter) + { + // + // Find out how many dimensions were used in the index operator. + // + int iArgc = stArgCount.pop(); + stOpt.pop(); // Take opening bracket from stack + + ICallback *pOprtIndex = pTok->AsICallback(); + MUP_VERIFY(pOprtIndex != nullptr); + + pOprtIndex->SetNumArgsPresent(iArgc); + m_rpn.Add(pOprtIndex); + + // If this is an index operator there must be something else in the register (the variable to index) + MUP_VERIFY(eCmd != cmIC || m_nPos >= (int)iArgc + 1); + + // Reduce the index into the value registers accordingly + m_nPos -= iArgc; + + if (eCmd == cmCBC) + { + ++m_nPos; + } + } // if opening index bracket is on top of operator stack + } + break; + + case cmBC: + { + // The argument count for parameterless functions is zero + // by default an opening bracket sets parameter count to 1 + // in preparation of arguments to come. If the last token + // was an opening bracket we know better... + if (pTokPrev.Get() != nullptr && pTokPrev->GetCode() == cmBO) + --stArgCount.top(); + + ApplyRemainingOprt(stOpt); + + // if opt is ")" and opta is "(" the bracket content has been evaluated. + // Now its time to check if there is either a function or a sign pending. + // - Neither the opening nor the closing bracket will be pushed back to + // the operator stack + // - Check if a function is standing in front of the opening bracket, + // if so evaluate it afterwards to apply an infix operator. + if (stOpt.size() && stOpt.top()->GetCode() == cmBO) + { + // + // Here is the stuff to evaluate a function token + // + int iArgc = stArgCount.pop(); + + stOpt.pop(); // Take opening bracket from stack + if (stOpt.empty()) + break; + + if ((stOpt.top()->GetCode() != cmFUNC) && (stOpt.top()->GetCode() != cmOPRT_INFIX)) + break; + + ICallback *pFun = stOpt.top()->AsICallback(); + + if (pFun->GetArgc() != -1 && iArgc > pFun->GetArgc()) + Error(ecTOO_MANY_PARAMS, pTok->GetExprPos(), pFun); + + if (iArgc < pFun->GetArgc()) + Error(ecTOO_FEW_PARAMS, pTok->GetExprPos(), pFun); + + // Apply function, if present + if (stOpt.size() && + stOpt.top()->GetCode() != cmOPRT_INFIX && + stOpt.top()->GetCode() != cmOPRT_BIN) + { + ApplyFunc(stOpt, iArgc); + } + } + } + break; + + case cmELSE: + ApplyRemainingOprt(stOpt); + m_rpn.Add(pTok); + stOpt.push(pTok); + break; + + case cmSCRIPT_NEWLINE: + ApplyRemainingOprt(stOpt); + m_rpn.AddNewline(pTok, m_nPos); + stOpt.clear(); + m_nPos = 0; + break; + + case cmARG_SEP: + if (stArgCount.empty()) + Error(ecUNEXPECTED_COMMA, m_pTokenReader->GetPos() - 1); + + ++stArgCount.top(); + + ApplyRemainingOprt(stOpt); + break; + + case cmEOE: + ApplyRemainingOprt(stOpt); + m_rpn.Finalize(); + break; + + case cmIF: + case cmOPRT_BIN: + { + while (stOpt.size() && + stOpt.top()->GetCode() != cmBO && + stOpt.top()->GetCode() != cmIO && + stOpt.top()->GetCode() != cmCBO && + stOpt.top()->GetCode() != cmELSE && + stOpt.top()->GetCode() != cmIF) + { + IToken *pOprt1 = stOpt.top().Get(); + IToken *pOprt2 = pTok.Get(); + MUP_VERIFY(pOprt1 != nullptr && pOprt2 != nullptr); + MUP_VERIFY(pOprt1->AsIPrecedence() && pOprt2->AsIPrecedence()); + + int nPrec1 = pOprt1->AsIPrecedence()->GetPri(), + nPrec2 = pOprt2->AsIPrecedence()->GetPri(); + + if (pOprt1->GetCode() == pOprt2->GetCode()) + { + // Deal with operator associativity + EOprtAsct eOprtAsct = pOprt1->AsIPrecedence()->GetAssociativity(); + if ((eOprtAsct == oaRIGHT && (nPrec1 <= nPrec2)) || + (eOprtAsct == oaLEFT && (nPrec1 < nPrec2))) + { + break; + } + } + else if (nPrec1 < nPrec2) + { + break; + } + + // apply the operator now + // (binary operators are identic to functions with two arguments) + ApplyFunc(stOpt, 2); + } // while ( ... ) + + if (pTok->GetCode() == cmIF) + m_rpn.Add(pTok); + + stOpt.push(pTok); + } + break; + + // + // Postfix Operators + // + case cmOPRT_POSTFIX: + MUP_VERIFY(m_nPos); + m_rpn.Add(pTok); + break; + + case cmCBO: + case cmIO: + case cmBO: + stOpt.push(pTok); + stArgCount.push(1); + break; + + // + // Functions + // + case cmOPRT_INFIX: + case cmFUNC: + { + ICallback *pFunc = pTok->AsICallback(); + MUP_VERIFY(pFunc != nullptr); + stOpt.push(pTok); + } + break; + + default: + Error(ecINTERNAL_ERROR); + } // switch Code + + if (ParserXBase::s_bDumpStack) + { + StackDump(stOpt); + } + + if (pTok->GetCode() == cmEOE) + break; + } // for (all tokens) + + if (ParserXBase::s_bDumpRPN) + { + m_rpn.AsciiDump(); + } + + if (m_nPos > 1) + { + Error(ecUNEXPECTED_COMMA, -1); + } +} + +//--------------------------------------------------------------------------- +/** \brief One of the two main parse functions. + \sa ParseCmdCode(), ParseValue() + + Parse expression from input string. Perform syntax checking and create bytecode. + After parsing the string and creating the bytecode the function pointer + #m_pParseFormula will be changed to the second parse routine the uses bytecode instead of string parsing. + */ +const IValue& ParserXBase::ParseFromString() const +{ + CreateRPN(); + + // Umsachalten auf RPN + m_vStackBuffer.assign(m_rpn.GetRequiredStackSize(), ptr_val_type()); + for (std::size_t i = 0; i < m_vStackBuffer.size(); ++i) + { + Value *pValue = new Value; + pValue->BindToCache(&m_cache); + m_vStackBuffer[i].Reset(pValue); + } + + m_pParserEngine = &ParserXBase::ParseFromRPN; + + return (this->*m_pParserEngine)(); +} + +//--------------------------------------------------------------------------- +const IValue& ParserXBase::ParseFromRPN() const +{ + ptr_val_type *pStack = &m_vStackBuffer[0]; + if (m_rpn.GetSize() == 0) + { + // Passiert bei leeren strings oder solchen, die nur Leerzeichen enthalten + ErrorContext err; + err.Expr = m_pTokenReader->GetExpr(); + err.Errc = ecUNEXPECTED_EOF; + err.Pos = 0; + throw ParserError(err); + } + + const ptr_tok_type *pRPN = &(m_rpn.GetData()[0]); + + int sidx = -1; + std::size_t lenRPN = m_rpn.GetSize(); + for (std::size_t i = 0; i < lenRPN; ++i) + { + IToken *pTok = pRPN[i].Get(); + ECmdCode eCode = pTok->GetCode(); + + switch (eCode) + { + case cmSCRIPT_NEWLINE: + sidx = -1; + continue; + + case cmVAL: + { + IValue *pVal = static_cast(pTok); + + sidx++; + MUP_VERIFY(sidx < (int)m_vStackBuffer.size()); + if (pVal->IsVariable()) + { + pStack[sidx].Reset(pVal); + } + else + { + ptr_val_type &val = pStack[sidx]; + if (val->IsVariable()) + val.Reset(m_cache.CreateFromCache()); + + *val = *(static_cast(pTok)); + } + } + continue; + /* + // Deal with: + // - Index operator: [,,,] + // - Array constrution operator: {,,,} + case cmCBC: + { + ICallback *pFun = static_cast(pTok); + int nArgs = pFun->GetArgsPresent(); + sidx -= nArgs - 1; + MUP_VERIFY(sidx >= 0); + + ptr_val_type &val = pStack[sidx]; // Pointer to the variable or value beeing indexed + if (val->IsVariable()) + { + ptr_val_type buf(m_cache.CreateFromCache()); + pFun->Eval(buf, &val, nArgs); + val = buf; + } + else + { + pFun->Eval(val, &val, nArgs); + } + } + continue; + */ + case cmIC: + { + ICallback *pIdxOprt = static_cast(pTok); + int nArgs = pIdxOprt->GetArgsPresent(); + sidx -= nArgs - 1; + MUP_VERIFY(sidx >= 0); + + ptr_val_type &idx = pStack[sidx]; // Pointer to the first index + ptr_val_type &val = pStack[--sidx]; // Pointer to the variable or value beeing indexed + pIdxOprt->Eval(val, &idx, nArgs); + } + continue; + + case cmCBC: + case cmOPRT_POSTFIX: + case cmFUNC: + case cmOPRT_BIN: + case cmOPRT_INFIX: + { + ICallback *pFun = static_cast(pTok); + int nArgs = pFun->GetArgsPresent(); + sidx -= nArgs - 1; + MUP_VERIFY(sidx >= 0); + + ptr_val_type &val = pStack[sidx]; + try + { + if (val->IsVariable()) + { + ptr_val_type buf(m_cache.CreateFromCache()); + pFun->Eval(buf, &val, nArgs); + val = buf; + } + else + { + pFun->Eval(val, &val, nArgs); + } + } + catch (ParserError &exc) + { + // Not too happy about that: + // Multiarg functions may throw specific error codes when evaluating. + // These codes would be converted to ecEVAL here. I omit the conversion + // for certain handpicked errors. (The reason this catch block exists is + // that not all exceptions contain proper metadata when thrown out of + // a function.) + if (exc.GetCode() == ecTOO_FEW_PARAMS || + exc.GetCode() == ecDOMAIN_ERROR || + exc.GetCode() == ecOVERFLOW || + exc.GetCode() == ecINVALID_NUMBER_OF_PARAMETERS || + exc.GetCode() == ecASSIGNEMENT_TO_VALUE) + { + exc.GetContext().Pos = pFun->GetExprPos(); + throw; + } + // + else + { + ErrorContext err; + err.Expr = m_pTokenReader->GetExpr(); + err.Ident = pFun->GetIdent(); + err.Errc = ecEVAL; + err.Pos = pFun->GetExprPos(); + err.Hint = exc.GetMsg(); + throw ParserError(err); + } + } + catch (MatrixError & /*exc*/) + { + ErrorContext err; + err.Expr = m_pTokenReader->GetExpr(); + err.Ident = pFun->GetIdent(); + err.Errc = ecMATRIX_DIMENSION_MISMATCH; + err.Pos = pFun->GetExprPos(); + throw ParserError(err); + } + } + continue; + + case cmIF: + MUP_VERIFY(sidx >= 0); + if (pStack[sidx--]->GetBool() == false) + i += static_cast(pTok)->GetOffset(); + continue; + + case cmELSE: + case cmJMP: + i += static_cast(pTok)->GetOffset(); + continue; + + case cmENDIF: + continue; + + default: + Error(ecINTERNAL_ERROR); + } // switch token + } // for all RPN tokens + + return *pStack[0]; +} + +//--------------------------------------------------------------------------- +void ParserXBase::Error(EErrorCodes a_iErrc, int a_iPos, const IToken *a_pTok) const +{ + ErrorContext err; + err.Errc = a_iErrc; + err.Pos = a_iPos; + err.Expr = m_pTokenReader->GetExpr(); + err.Ident = (a_pTok) ? a_pTok->GetIdent() : _T(""); + throw ParserError(err); +} + +//------------------------------------------------------------------------------ +/** \brief Clear all user defined variables. + \throw nothrow + + Resets the parser to string parsing mode by calling #ReInit. + */ +void ParserXBase::ClearVar() +{ + m_varDef.clear(); + m_valDynVarShadow.clear(); + ReInit(); +} + +//------------------------------------------------------------------------------ +/** \brief Clear the expression. + \throw nothrow + + Clear the expression and existing bytecode. + */ +void ParserXBase::ClearExpr() +{ + m_pTokenReader->SetExpr(_T("")); + ReInit(); +} + +//------------------------------------------------------------------------------ +/** \brief Clear all function definitions. + \throw nothrow + */ +void ParserXBase::ClearFun() +{ + m_FunDef.clear(); + ReInit(); +} + +//------------------------------------------------------------------------------ +/** \brief Clear all user defined constants. + \throw nothrow + + Both numeric and string constants will be removed from the internal storage. + */ +void ParserXBase::ClearConst() +{ + m_valDef.clear(); + ReInit(); +} + +//------------------------------------------------------------------------------ +/** \brief Clear all user defined postfix operators. + \throw nothrow + */ +void ParserXBase::ClearPostfixOprt() +{ + m_PostOprtDef.clear(); + ReInit(); +} + +//------------------------------------------------------------------------------ +/** \brief Clear all user defined binary operators. + \throw nothrow + */ +void ParserXBase::ClearOprt() +{ + m_OprtDef.clear(); + ReInit(); +} + +//------------------------------------------------------------------------------ +/** \brief Clear the user defined Prefix operators. + \throw nothrow + */ +void ParserXBase::ClearInfixOprt() +{ + m_InfixOprtDef.clear(); + ReInit(); +} + +//------------------------------------------------------------------------------ +void ParserXBase::EnableAutoCreateVar(bool bStat) +{ + m_bAutoCreateVar = bStat; +} + +//------------------------------------------------------------------------------ +void ParserXBase::EnableOptimizer(bool bStat) +{ + m_rpn.EnableOptimizer(bStat); +} + +//--------------------------------------------------------------------------- +/** \brief Enable the dumping of bytecode amd stack content on the console. + \param bDumpCmd Flag to enable dumping of the current bytecode to the console. + \param bDumpStack Flag to enable dumping of the stack content is written to the console. + + This function is for debug purposes only! + */ +void ParserXBase::EnableDebugDump(bool bDumpRPN, bool bDumpStack) +{ + ParserXBase::s_bDumpRPN = bDumpRPN; + ParserXBase::s_bDumpStack = bDumpStack; +} + +//------------------------------------------------------------------------------ +bool ParserXBase::IsAutoCreateVarEnabled() const +{ + return m_bAutoCreateVar; +} + +//------------------------------------------------------------------------------ +/** \brief Dump stack content. + + This function is used for debugging only. + */ +void ParserXBase::StackDump(const Stack &a_stOprt) const +{ + using std::cout; + Stack stOprt(a_stOprt); + + string_type sInfo = _T("StackDump> "); + console() << sInfo; + + if (stOprt.empty()) + console() << _T("\n") << sInfo << _T("Operator stack is empty.\n"); + else + console() << _T("\n") << sInfo << _T("Operator stack:\n"); + + while (!stOprt.empty()) + { + ptr_tok_type tok = stOprt.pop(); + console() << sInfo << _T(" ") << g_sCmdCode[tok->GetCode()] << _T(" \"") << tok->GetIdent() << _T("\" \n"); + } + + console() << endl; +} +} // namespace mu diff --git a/src/third-party/headers/muparserx/mpParserMessageProvider.cpp b/src/third-party/headers/muparserx/mpParserMessageProvider.cpp new file mode 100644 index 0000000000..dbd442743a --- /dev/null +++ b/src/third-party/headers/muparserx/mpParserMessageProvider.cpp @@ -0,0 +1,181 @@ +#include "mpParserMessageProvider.h" +#include +#include "mpError.h" + + +MUP_NAMESPACE_START + + //------------------------------------------------------------------------------------------------- + // + // class ParserMessageProviderBase - Base class for message providers + // + //------------------------------------------------------------------------------------------------- + + ParserMessageProviderBase::ParserMessageProviderBase() + :m_vErrMsg(0) + {} + + //----------------------------------------------------------------------------------------------- + ParserMessageProviderBase::~ParserMessageProviderBase() + {} + + //----------------------------------------------------------------------------------------------- + void ParserMessageProviderBase::Init() + { + InitErrorMessages(); + for (int i=0; i\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ + +#include +#include + +#include "mpRPN.h" +#include "mpIToken.h" +#include "mpICallback.h" +#include "mpError.h" +#include "mpStack.h" +#include "mpIfThenElse.h" +#include "mpScriptTokens.h" + +MUP_NAMESPACE_START + +//--------------------------------------------------------------------------- +RPN::RPN() + :m_vRPN() + , m_nStackPos(-1) + , m_nLine(0) + , m_nMaxStackPos(0) + , m_bEnableOptimizer(false) +{} + +//--------------------------------------------------------------------------- +RPN::~RPN() +{} + +//--------------------------------------------------------------------------- +void RPN::Add(ptr_tok_type tok) +{ + m_vRPN.push_back(tok); + if (tok->AsIValue() != nullptr) + { + m_nStackPos++; + } + else if (tok->AsICallback()) + { + ICallback *pFun = tok->AsICallback(); + MUP_VERIFY(pFun != nullptr); + m_nStackPos -= pFun->GetArgsPresent() - 1; + } + + MUP_VERIFY(m_nStackPos >= 0); + m_nMaxStackPos = std::max(m_nStackPos, m_nMaxStackPos); +} + +//--------------------------------------------------------------------------- +void RPN::AddNewline(ptr_tok_type tok, int n) +{ + static_cast(tok.Get())->SetStackOffset(n); + m_vRPN.push_back(tok); + m_nStackPos -= n; + m_nLine++; +} + +//--------------------------------------------------------------------------- +void RPN::Pop(int num) +{ + if (m_vRPN.size() == 0) + return; + + for (int i = 0; i < num; ++i) + { + ptr_tok_type tok = m_vRPN.back(); + + if (tok->AsIValue() != 0) + m_nStackPos--; + + m_vRPN.pop_back(); + } +} + +//--------------------------------------------------------------------------- +void RPN::Reset() +{ + m_vRPN.clear(); + m_nStackPos = -1; + m_nMaxStackPos = 0; + m_nLine = 0; +} + +//--------------------------------------------------------------------------- +/** \brief + + At the moment this will only ass the jump distances to the if-else clauses + found in the expression. +*/ +void RPN::Finalize() +{ + // Determine the if-then-else jump offsets + Stack stIf, stElse; + int idx; + for (int i = 0; i < static_cast(m_vRPN.size()); ++i) + { + switch (m_vRPN[i]->GetCode()) + { + case cmIF: + stIf.push(i); + break; + + case cmELSE: + stElse.push(i); + idx = stIf.pop(); + static_cast(m_vRPN[idx].Get())->SetOffset(i - idx); + break; + + case cmENDIF: + idx = stElse.pop(); + static_cast(m_vRPN[idx].Get())->SetOffset(i - idx); + break; + + default: + continue; + } + } +} + +//--------------------------------------------------------------------------- +void RPN::EnableOptimizer(bool bStat) +{ + m_bEnableOptimizer = bStat; +} + +//--------------------------------------------------------------------------- +std::size_t RPN::GetSize() const +{ + return m_vRPN.size(); +} + +//--------------------------------------------------------------------------- +const token_vec_type& RPN::GetData() const +{ + return m_vRPN; +} + +//--------------------------------------------------------------------------- +int RPN::GetRequiredStackSize() const +{ + return m_nMaxStackPos + 1; +} + +//--------------------------------------------------------------------------- +void RPN::AsciiDump() const +{ + console() << "Number of tokens: " << m_vRPN.size() << "\n"; + console() << "MaxStackPos: " << m_nMaxStackPos << "\n"; + for (std::size_t i = 0; i < m_vRPN.size(); ++i) + { + ptr_tok_type pTok = m_vRPN[i]; + console() << std::setw(2) << i << " : " + << std::setw(2) << pTok->GetExprPos() << " : " + << pTok->AsciiDump() << std::endl; + } +} + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpScriptTokens.cpp b/src/third-party/headers/muparserx/mpScriptTokens.cpp new file mode 100644 index 0000000000..d044032614 --- /dev/null +++ b/src/third-party/headers/muparserx/mpScriptTokens.cpp @@ -0,0 +1,74 @@ +/* + __________ ____ ___ + _____ __ _\______ \_____ _______ ______ __________\ \/ / + / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / + | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ + |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ + \/ \/ \/ \/ \_/ + Copyright (C) 2016, Ingo Berg + All rights reserved. + + Redistribution and use in source and binary forms, with or without + modification, are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright notice, + this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above copyright notice, + this list of conditions and the following disclaimer in the documentation + and/or other materials provided with the distribution. + + THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND + ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED + WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. + IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, + INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT + NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR + PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, + WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) + ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE + POSSIBILITY OF SUCH DAMAGE. +*/ +#include "mpScriptTokens.h" +#include "mpTypes.h" + + +MUP_NAMESPACE_START + + //--------------------------------------------------------------------------- + TokenNewline::TokenNewline() + :IToken(cmSCRIPT_NEWLINE) + ,m_nOffset(0) + {} + + //--------------------------------------------------------------------------- + IToken* TokenNewline::Clone() const + { + return new TokenNewline(*this); + } + + //--------------------------------------------------------------------------- + void TokenNewline::SetStackOffset(int nOffset) + { + m_nOffset = nOffset; + } + + //--------------------------------------------------------------------------- + int TokenNewline::GetStackOffset() const + { + return m_nOffset; + } + + //--------------------------------------------------------------------------- + string_type TokenNewline::AsciiDump() const + { + stringstream_type ss; + + ss << g_sCmdCode[ GetCode() ]; + ss << _T(" [addr=0x") << std::hex << this << std::dec; + ss << _T("; pos=") << GetExprPos(); + ss << _T("; offset=") << m_nOffset; + ss << _T("]"); + return ss.str(); + } + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpTest.cpp b/src/third-party/headers/muparserx/mpTest.cpp new file mode 100644 index 0000000000..7055c592d5 --- /dev/null +++ b/src/third-party/headers/muparserx/mpTest.cpp @@ -0,0 +1,1809 @@ +/** \file + \brief Implementation of the unit test for muParserX. + +
+				  __________                                 ____  ___
+	  _____  __  _\______   \_____ _______  ______ __________\   \/  /
+	 /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
+	|  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
+	|__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+		  \/                     \/           \/     \/           \_/
+	Copyright (C) 2016 Ingo Berg
+	All rights reserved.
+
+	muParserX - A C++ math parser library with array and string support
+	Copyright (c) 2016, Ingo Berg
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright notice,
+	this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright notice,
+	this list of conditions and the following disclaimer in the documentation
+	and/or other materials provided with the distribution.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+	IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+	WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+	POSSIBILITY OF SUCH DAMAGE.
+	
+ */ +#include "mpTest.h" +#include "mpValue.h" + +#include +#include +#include +#include +#include +#include + +#define MUP_CONST_PI 3.141592653589793238462643 +#define MUP_CONST_E 2.718281828459045235360287 + +using namespace std; + +MUP_NAMESPACE_START + +//----------------------------------------------------------------------------------------------- +// +// class OprtStrAdd +// +//----------------------------------------------------------------------------------------------- + +class DbgSillyAdd : public IOprtBin +{ +public: + + DbgSillyAdd() + :IOprtBin(_T("++"), (int)prADD_SUB, oaLEFT) + {} + + //----------------------------------------------------------------------------------------------- + void Eval(ptr_val_type& ret, const ptr_val_type *arg, int argc) + { + assert(argc == 2); + float_type a = arg[0]->GetFloat(); + float_type b = arg[1]->GetFloat(); + *ret = a + b; + } + + //----------------------------------------------------------------------------------------------- + const char_type* GetDesc() const + { + return _T("internally used operator without special meaning for unit testing"); + } + + //----------------------------------------------------------------------------------------------- + IToken* Clone() const + { + return new DbgSillyAdd(*this); + } +}; + +//------------------------------------------------------------------------------ +class FunTest0 : public ICallback +{ +public: + FunTest0() : ICallback(cmFUNC, _T("test0"), 0) + {} + + virtual void Eval(ptr_val_type &ret, const ptr_val_type * /*a_pArg*/, int /*a_iArgc*/) + { + *ret = 0.0; + } + + virtual const char_type* GetDesc() const + { + return _T(""); + } + + virtual IToken* Clone() const + { + return new FunTest0(*this); + } +}; // class FunTest0 + +//--------------------------------------------------------------------------- +int ParserTester::c_iCount = 0; + +//--------------------------------------------------------------------------- +ParserTester::ParserTester() + :m_vTestFun() + , m_stream(&console()) +{ + AddTest(&ParserTester::TestParserValue); + AddTest(&ParserTester::TestUndefVar); + AddTest(&ParserTester::TestErrorCodes); + AddTest(&ParserTester::TestEqn); + AddTest(&ParserTester::TestIfElse); + AddTest(&ParserTester::TestStringFun); + AddTest(&ParserTester::TestMatrix); + AddTest(&ParserTester::TestComplex); + AddTest(&ParserTester::TestVector); + AddTest(&ParserTester::TestBinOp); + AddTest(&ParserTester::TestPostfix); + AddTest(&ParserTester::TestInfix); + AddTest(&ParserTester::TestMultiArg); + AddTest(&ParserTester::TestScript); + AddTest(&ParserTester::TestValReader); + AddTest(&ParserTester::TestIssueReports); + + ParserTester::c_iCount = 0; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestIssueReports() +{ + int iNumErr = 0; + *m_stream << _T("testing github issue reports..."); + + // Github: Issue 55 + iNumErr += ThrowTest(_T("{0,{0}}*{0,{0}}*{,{0}}*{0,{0}0,{0}}*{0,{0}}*{,{0}}*{0}*{000}"), ecUNEXPECTED_COMMA); + + // Github: Issue 56 + iNumErr += ThrowTest(_T("0M[,1][0/1M[0M]M]"), ecUNEXPECTED_COMMA); + + // Github Issue 57: + iNumErr += ThrowTest(_T("{?{{{{:44"), ecUNEXPECTED_CONDITIONAL); + + // Github Issue 60 + iNumErr += ThrowTest(_T("0<01?1=:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1<:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1>:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1+:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1*:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1/:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1&:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1<<:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("0<01?1>>:1"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("{ ? 0 : 7m}-{7, -00007m}-{7M}"), ecUNEXPECTED_CONDITIONAL); + iNumErr += ThrowTest(_T("{ { { ? 2 }, 7:2 }*7m }"), ecUNEXPECTED_CONDITIONAL); + + // Not too happy about the undefined code, but better than a crash of an assertion at runtime + iNumErr += ThrowTest(_T("{0<0?0,0:0<0}"), ecUNDEFINED); + + // Github Issue 63 + iNumErr += ThrowTest(_T("0<0-0--eye()"), ecINVALID_NUMBER_OF_PARAMETERS); + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestUndefVar() +{ + int iNumErr = 0; + *m_stream << _T("testing implicit definition of undefined variables..."); + + // Test 1: No variables defined, test detection of undefined variables + { + ParserX p; + p.SetExpr(_T("a+b+c+d")); + const mup::var_maptype &expr_var = p.GetExprVar(); + const mup::var_maptype &var = p.GetVar(); + + // The expression contains 4 undefined variables + if (expr_var.size() != 4) + iNumErr++; + + // There are no variables defined + if (var.size() != 0) + iNumErr++; + } + + // Test 2: Variables were defined explicitely, test detection of variables + { + ParserX p; + + // Now define the variables and perform the check again + Value vVarVal[] = { 1.0, 2.0, 3.0, 4.0 }; + p.DefineVar(_T("a"), Variable(&vVarVal[0])); + p.DefineVar(_T("b"), Variable(&vVarVal[1])); + p.DefineVar(_T("c"), Variable(&vVarVal[2])); + p.DefineVar(_T("d"), Variable(&vVarVal[3])); + + p.SetExpr(_T("a+b+c+d")); + const mup::var_maptype &expr_var = p.GetExprVar(); + const mup::var_maptype &var = p.GetVar(); + + // The expression contains 4 undefined variables + if (expr_var.size() != 4) + iNumErr++; + + // There are no variables defined + if (var.size() != 4) + iNumErr++; + } + + // Test 3: Variables were defined implicitels, test detection of undefined variables + { + ParserX p; + + // Now define the variables and perform the check again + p.EnableAutoCreateVar(true); + + p.SetExpr(_T("a+b+c+d")); + const mup::var_maptype &expr_var = p.GetExprVar(); + const mup::var_maptype &var = p.GetVar(); + + // The expression contains 4 undefined variables + if (expr_var.size() != 4) + iNumErr++; + + // There are no variables defined + if (var.size() != 4) + iNumErr++; + } + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestMatrix() +{ + int iNumErr = 0; + *m_stream << _T("testing matrix calculations..."); + + Value unity(3, 3, 0); + unity.At(0, 0) = 1.0; + unity.At(1, 1) = 1.0; + unity.At(2, 2) = 1.0; + + Value va(3, 0); + va.At(0) = 1.0; + va.At(1) = 2.0; + va.At(2) = 3.0; + + //Value m2(3, 3, 0); + //m2.At(0, 0) = 1; m2.At(0, 1) = 2; m2.At(0, 2) = 3; + //m2.At(1, 0) = 4; m2.At(1, 1) = 5; m2.At(1, 2) = 6; + //m2.At(2, 0) = 7; m2.At(2, 1) = 8; m2.At(2, 2) = 9; + + Value m1_plus_m2(3, 3, 0); + m1_plus_m2.At(0, 0) = 2.0; m1_plus_m2.At(0, 1) = 2.0; m1_plus_m2.At(0, 2) = 3.0; + m1_plus_m2.At(1, 0) = 4.0; m1_plus_m2.At(1, 1) = 6.0; m1_plus_m2.At(1, 2) = 6.0; + m1_plus_m2.At(2, 0) = 7.0; m1_plus_m2.At(2, 1) = 8.0; m1_plus_m2.At(2, 2) = 10.0; + + Value m2_minus_m1(3, 3, 0); + m2_minus_m1.At(0, 0) = 0.0; m2_minus_m1.At(0, 1) = 2.0; m2_minus_m1.At(0, 2) = 3.0; + m2_minus_m1.At(1, 0) = 4.0; m2_minus_m1.At(1, 1) = 4.0; m2_minus_m1.At(1, 2) = 6.0; + m2_minus_m1.At(2, 0) = 7.0; m2_minus_m1.At(2, 1) = 8.0; m2_minus_m1.At(2, 2) = 8.0; + + Value m2_times_10(3, 3, 0); + m2_times_10.At(0, 0) = 10.0; m2_times_10.At(0, 1) = 20.0; m2_times_10.At(0, 2) = 30.0; + m2_times_10.At(1, 0) = 40.0; m2_times_10.At(1, 1) = 50.0; m2_times_10.At(1, 2) = 60.0; + m2_times_10.At(2, 0) = 70.0; m2_times_10.At(2, 1) = 80.0; m2_times_10.At(2, 2) = 90.0; + + Value va_times_vb_transp(3, 3, 0); + va_times_vb_transp.At(0, 0) = 4.0; va_times_vb_transp.At(0, 1) = 3.0; va_times_vb_transp.At(0, 2) = 2.0; + va_times_vb_transp.At(1, 0) = 8.0; va_times_vb_transp.At(1, 1) = 6.0; va_times_vb_transp.At(1, 2) = 4.0; + va_times_vb_transp.At(2, 0) = 12.0; va_times_vb_transp.At(2, 1) = 9.0; va_times_vb_transp.At(2, 2) = 6.0; + + Value size_3x6(1, 2, 0); + size_3x6.At(0, 0) = 3.0; + size_3x6.At(0, 1) = 6.0; + + Value size_3x3(1, 2, 0); + size_3x3.At(0, 0) = 3.0; + size_3x3.At(0, 1) = 3.0; + + Value size_3x1(1, 2, 0); + size_3x1.At(0, 0) = 3.0; + size_3x1.At(0, 1) = 1.0; + + Value size_1x3(1, 2, 0); + size_1x3.At(0, 0) = 1.0; + size_1x3.At(0, 1) = 3.0; + + // Check matrix dimension mismatch error + iNumErr += ThrowTest(_T("\"hallo\"+m1"), ecEVAL); + iNumErr += ThrowTest(_T("m1+\"hallo\""), ecEVAL); + iNumErr += ThrowTest(_T("va+m1"), ecMATRIX_DIMENSION_MISMATCH); + iNumErr += ThrowTest(_T("m1+va"), ecMATRIX_DIMENSION_MISMATCH); + iNumErr += ThrowTest(_T("va-m1"), ecMATRIX_DIMENSION_MISMATCH); + iNumErr += ThrowTest(_T("m1-va"), ecMATRIX_DIMENSION_MISMATCH); + iNumErr += ThrowTest(_T("va*m1"), ecMATRIX_DIMENSION_MISMATCH); + iNumErr += ThrowTest(_T("va+eye(2)"), ecMATRIX_DIMENSION_MISMATCH); + + // Issue 63: + iNumErr += ThrowTest(_T("0-0-eye()"), ecINVALID_NUMBER_OF_PARAMETERS); + + iNumErr += ThrowTest(_T("m1[1]"), ecINDEX_DIMENSION); + iNumErr += ThrowTest(_T("m1[1,2,3]"), ecINDEX_DIMENSION); + iNumErr += ThrowTest(_T("va[1,2]"), ecINDEX_OUT_OF_BOUNDS); // va has 1 column, 3 rows -> the coulumn index is referencing the third column + iNumErr += ThrowTest(_T("a+m1"), ecEVAL); + iNumErr += ThrowTest(_T("m1+a"), ecEVAL); + iNumErr += ThrowTest(_T("a-m1"), ecEVAL); + iNumErr += ThrowTest(_T("m1-a"), ecEVAL); + iNumErr += ThrowTest(_T("va[,1]"), ecUNEXPECTED_COMMA); + iNumErr += ThrowTest(_T("va[{1]"), ecMISSING_CURLY_BRACKET); + iNumErr += ThrowTest(_T("{,1}"), ecUNEXPECTED_COMMA); + + // sample expressions + iNumErr += EqnTest(_T("m1"), unity, true); + iNumErr += EqnTest(_T("m1*m1"), unity, true); + iNumErr += EqnTest(_T("m1+m2"), m1_plus_m2, true); + iNumErr += EqnTest(_T("m2-m1"), m2_minus_m1, true); + iNumErr += EqnTest(_T("10*m2"), m2_times_10, true); + iNumErr += EqnTest(_T("m2*10"), m2_times_10, true); + iNumErr += EqnTest(_T("5*m2*b"), m2_times_10, true); + iNumErr += EqnTest(_T("b*m2*5"), m2_times_10, true); + iNumErr += EqnTest(_T("m1*va"), va, true); + + // ones + Value ones_3(3, 1.0); + Value ones_3x3(3, 3, 1.0); + iNumErr += ThrowTest(_T("ones(1,2,3)"), ecINVALID_NUMBER_OF_PARAMETERS); + iNumErr += ThrowTest(_T("ones()"), ecINVALID_NUMBER_OF_PARAMETERS); + iNumErr += EqnTest(_T("ones(1,1)"), 1.0, true); + iNumErr += EqnTest(_T("ones(1)"), 1.0, true); + iNumErr += EqnTest(_T("ones(3,3)"), ones_3x3, true); + iNumErr += EqnTest(_T("ones(3,1)"), ones_3, true); + iNumErr += EqnTest(_T("ones(3)"), ones_3, true); + + iNumErr += EqnTest(_T("size(ones(3,3))"), size_3x3, true); // check return value dimension + iNumErr += EqnTest(_T("size(ones(1,3))"), size_1x3, true); // check return value dimension + iNumErr += EqnTest(_T("size(ones(3,1))"), size_3x1, true); // check return value dimension + iNumErr += EqnTest(_T("size(ones(3))"), size_3x3, true); // check return value dimension + + // zeros + iNumErr += ThrowTest(_T("zeros()"), ecINVALID_NUMBER_OF_PARAMETERS); + iNumErr += EqnTest(_T("size(zeros(3,3))"), size_3x3, true); // check return value dimension + iNumErr += EqnTest(_T("size(zeros(1,3))"), size_1x3, true); // check return value dimension + iNumErr += EqnTest(_T("size(zeros(3,1))"), size_3x1, true); // check return value dimension + iNumErr += EqnTest(_T("size(zeros(3))"), size_3x3, true); // check return value dimension + + // eye + iNumErr += ThrowTest(_T("eye()"), ecINVALID_NUMBER_OF_PARAMETERS); + iNumErr += EqnTest(_T("size(eye(3,3))"), size_3x3, true); // check return value dimension + iNumErr += EqnTest(_T("size(eye(1,3))"), size_1x3, true); // check return value dimension + iNumErr += EqnTest(_T("size(eye(3,1))"), size_3x1, true); // check return value dimension + iNumErr += EqnTest(_T("size(eye(3))"), size_3x3, true); // check return value dimension + + iNumErr += EqnTest(_T("size(eye(3,6))"), size_3x6, true); // check return value dimension + + // transposition + iNumErr += EqnTest(_T("va'*vb"), 16.0, true); + iNumErr += EqnTest(_T("2*va'*vb"), 32.0, true); + iNumErr += EqnTest(_T("va*vb'"), va_times_vb_transp, true); + + // index operator + // erster index: Zeilenindex, zweiter index: Spaltenindex + iNumErr += EqnTest(_T("va[0]"), 1.0, true); + iNumErr += EqnTest(_T("va[1]"), 2.0, true); + iNumErr += EqnTest(_T("va[2]"), 3.0, true); + // Use two dimensional index operator on a vector + iNumErr += EqnTest(_T("va[0,0]"), 1.0, true); + iNumErr += EqnTest(_T("va[1,0]"), 2.0, true); + iNumErr += EqnTest(_T("va[2,0]"), 3.0, true); + + // Now test the same with a transposed vector: + iNumErr += EqnTest(_T("va'[0]"), 1.0, true); + iNumErr += EqnTest(_T("va'[1]"), 2.0, true); + iNumErr += EqnTest(_T("va'[2]"), 3.0, true); + // Use two dimensional index operator on a vector + iNumErr += EqnTest(_T("va'[0,0]"), 1.0, true); + iNumErr += EqnTest(_T("va'[0,1]"), 2.0, true); + iNumErr += EqnTest(_T("va'[0,2]"), 3.0, true); + iNumErr += EqnTest(_T("(va')[0,2]"), 3.0, true); // <- Index operator after closing bracket is ok + + // vector creation + iNumErr += EqnTest(_T("{1,2,3}'"), va, true); + iNumErr += EqnTest(_T("{a,2,3}'"), va, true); // that was an actual bug: variable a was overwritten + + // assignment to element: + iNumErr += ThrowTest(_T("va'[0]=123"), ecASSIGNEMENT_TO_VALUE); + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestComplex() +{ + int iNumErr = 0; + *m_stream << _T("testing complex calculations..."); + + // complex numbers + // ca=1+i, cb=2+3i, cc=3+4i + iNumErr += EqnTest(_T("ca==1+i"), true, true); + iNumErr += EqnTest(_T("ca==ca"), true, true); + iNumErr += EqnTest(_T("ca!=1+i"), false, true); + iNumErr += EqnTest(_T("ca!=ca"), false, true); + iNumErr += EqnTest(_T("ca!=cb"), true, true); + iNumErr += EqnTest(_T("ca!=va"), true, true); + iNumErr += EqnTest(_T("ca==va"), false, true); + + // When comparing complex number Matlab/Octave compare only the real part + // I'll do the same... + iNumErr += EqnTest(_T("ca<10+i"), true, true); + iNumErr += EqnTest(_T("ca>10+i"), false, true); + iNumErr += EqnTest(_T("ca<=10+i"), true, true); + iNumErr += EqnTest(_T("ca>=10+i"), false, true); + iNumErr += EqnTest(_T("ca<=1"), true, true); + iNumErr += EqnTest(_T("ca>=1"), true, true); + + // complex numbers + iNumErr += EqnTest(_T("i*i"), -1.0, true, 0); + iNumErr += EqnTest(_T("1i"), cmplx_type(0, 1), true, 0); + iNumErr += EqnTest(_T("norm(3+4i)"), 25.0, true, 0); + iNumErr += EqnTest(_T("norm(4i+3)"), 25.0, true, 0); + iNumErr += EqnTest(_T("norm(3i+4)"), 25.0, true, 0); + iNumErr += EqnTest(_T("real(4.1i+3.1)"), (float_type)3.1, true, 0); + iNumErr += EqnTest(_T("imag(3.1i+4.1)"), (float_type)3.1, true, 0); + iNumErr += EqnTest(_T("real(3.1)"), (float_type)3.1, true, 0); + iNumErr += EqnTest(_T("imag(2.1i)"), (float_type)2.1, true, 0); + iNumErr += EqnTest(_T("-(4i+5)"), cmplx_type(-5, -4), true, 0); + iNumErr += EqnTest(_T("sqrt(-1)"), cmplx_type(0, 1), true, 0); + iNumErr += EqnTest(_T("(-1)^0.5"), cmplx_type(0, 1), true, 0); + iNumErr += EqnTest(_T("(-3)^(4/3)"), std::pow(cmplx_type(-3, 0), + cmplx_type(4.0 / 3, 0)), true, 0); + + // Issue 41: Complex pow of small numbers zeros out the imaginary part + // https://code.google.com/p/muparserx/issues/detail?id=41 + iNumErr += EqnTest(_T("(1e-15 + 1e-15*i) ^ 2"), std::pow(cmplx_type(1e-15, 1e-15), 2), true, 0); + + iNumErr += EqnTest(_T("sqrt(i*i)"), cmplx_type(0, 1), true, 0); + iNumErr += EqnTest(_T("sqrt(f)"), cmplx_type(0, 1), true, 1); + iNumErr += EqnTest(_T("sqrt(2-3)"), cmplx_type(0, 1), true, 0); + iNumErr += EqnTest(_T("sqrt(a-b)"), cmplx_type(0, 1), true, 2); + iNumErr += EqnTest(_T("sqrt((2-3))"), cmplx_type(0, 1), true, 0); + iNumErr += EqnTest(_T("sqrt((a-b))"), cmplx_type(0, 1), true, 2); + iNumErr += EqnTest(_T("sqrt(-(1))"), cmplx_type(0, 1), true, 0); + iNumErr += EqnTest(_T("sqrt((-1))"), cmplx_type(0, 1), true, 0); + iNumErr += EqnTest(_T("sqrt(-(-1))"), cmplx_type(1, 0), true, 0); + iNumErr += EqnTest(_T("sqrt(1)"), cmplx_type(1, 0), true, 0); + iNumErr += EqnTest(_T("a=1+2i"), cmplx_type(1, 2), true, 1); + iNumErr += EqnTest(_T("-(1+2i)"), cmplx_type(-1, -2), true, 0); + iNumErr += EqnTest(_T("-(-1-2i)"), cmplx_type(1, 2), true, 0); + iNumErr += EqnTest(_T("a*i"), cmplx_type(0, 1), true, 1); + iNumErr += EqnTest(_T("-(a+b*i)"), cmplx_type(-1, -2), true, 2); + iNumErr += EqnTest(_T("-(-a-b*i)"), cmplx_type(1, 2), true, 2); + iNumErr += EqnTest(_T("(2+4i)*(8-6i)"), cmplx_type(40, 20), true, 0); + + // Issue 17: Wrong result on complex power. + iNumErr += EqnTest(_T("(-0.27 + 0.66*i)^2"), cmplx_type(-0.3627, -0.3564), true, 0); + iNumErr += EqnTest(_T("(-1+5i)^2"), cmplx_type(-24, -10), true, 0); + + iNumErr += EqnTest(_T("c=(a=1+2i)"), cmplx_type(1, 2), true, 2); + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestParserValue() +{ + int iNumErr = 0; + *m_stream << _T("testing parser value types..."); + + // Define values and variables for each type + Value bVal = true; + Value fVal = (float_type)3.14; + Value sVal = string_type(_T("hello world")); + Value sVal1 = _T("hello world"); // Test assignment from const char* to string + Value cVal = cmplx_type(1, 1); + Value aVal(2, 0); + aVal.At(0) = (float_type)2.0; + aVal.At(1) = (float_type)3.0; + + // Create a 3x3 matrix + Value matrix(3, 0); + matrix.At(0) = Value(3, 0); + matrix.At(1) = Value(3, 0); + matrix.At(2) = Value(3, 0); + + Variable bVar(&bVal), + fVar(&fVal), + sVar(&sVal), + sVar1(&sVal1), + cVar(&cVal), + aVar(&aVal); + + // Check the value types + try + { + // Test if matrix values do work + if (!matrix.IsMatrix() || matrix.GetRows() != 3) + iNumErr++; + + std::size_t sz = matrix.GetRows(); + for (std::size_t i = 0; i < sz; ++i) + { + std::size_t dim_row = matrix.At(static_cast(i)).GetRows(); + if (dim_row != 3) + { + iNumErr++; + console() << _T("\n Array dimension mismatch in matrix row ") << i + << _T(" (expected=3; dim=") << dim_row << _T(")"); + } + } + + // test type checking of values + if (!fVal.IsScalar() || fVal.IsMatrix() || fVal.GetType() != 'f') iNumErr++; + if (!cVal.IsScalar() || cVal.IsMatrix() || cVal.GetType() != 'c') iNumErr++; + if (aVal.IsScalar() || !aVal.IsMatrix() || aVal.GetType() != 'm') iNumErr++; + if (sVal.IsScalar() || sVal.IsMatrix() || sVal.GetType() != 's') iNumErr++; + if (sVal1.IsScalar() || sVal1.IsMatrix() || sVal1.GetType() != 's') iNumErr++; + if (bVal.IsScalar() || bVal.IsMatrix() || bVal.GetType() != 'b') iNumErr++; + + // test type checking of variables + if (!fVar.IsScalar() || fVar.IsMatrix() || fVar.GetType() != 'f') iNumErr++; + if (!cVar.IsScalar() || cVar.IsMatrix() || cVar.GetType() != 'c') iNumErr++; + if (aVar.IsScalar() || !aVar.IsMatrix() || aVar.GetType() != 'm') iNumErr++; + if (sVar.IsScalar() || sVar.IsMatrix() || sVar.GetType() != 's') iNumErr++; + if (sVar1.IsScalar() || sVar1.IsMatrix() || sVar1.GetType() != 's') iNumErr++; + if (bVar.IsScalar() || bVar.IsMatrix() || bVar.GetType() != 'b') iNumErr++; + + // Issue 33: https://code.google.com/p/muparserx/issues/detail?id=33 + // Remark: Type information was not properly set when invoking +=, -= operators + { + Value x = 1.0; + Value y = cmplx_type(0, 1); + x += y; + if (x.GetImag() != 1 || x.GetFloat() != 1 || x.GetType() != 'c') + { + *m_stream << _T("\nValue::operator+=(...) failed."); + iNumErr++; + } + + x = 1.0; + y = cmplx_type(0, 1); + x -= y; + if (x.GetImag() != -1 || x.GetFloat() != 1 || x.GetType() != 'c') + { + *m_stream << _T("\nValue::operator-=(...) failed."); + iNumErr++; + } + } + } + catch (...) + { + iNumErr++; + } + + bool bError; + +#define VALUE_THROWCHECK(VAR, FAIL, MEMBER) \ + bError = (FAIL); \ + try \ + { \ + VAR.MEMBER(); \ + } \ + catch (...) \ + { \ + bError ^= true; \ + } \ + iNumErr += (bError) ? 1 : 0; \ + c_iCount++; + + // Check if the getter functions really throw an exception + // when used with an incorrect value type + // Case 1: test float values + VALUE_THROWCHECK(fVal, false, GetFloat) + VALUE_THROWCHECK(fVal, false, GetImag) + VALUE_THROWCHECK(fVal, true, GetBool) + VALUE_THROWCHECK(fVal, true, GetString) + VALUE_THROWCHECK(fVal, true, GetArray) + // for variables + VALUE_THROWCHECK(fVar, false, GetFloat) + VALUE_THROWCHECK(fVar, false, GetImag) + VALUE_THROWCHECK(fVar, true, GetBool) + VALUE_THROWCHECK(fVar, true, GetString) + VALUE_THROWCHECK(fVar, true, GetArray) + + // Case 2: test bool values + VALUE_THROWCHECK(bVal, false, GetFloat) + VALUE_THROWCHECK(bVal, true, GetImag) + VALUE_THROWCHECK(bVal, false, GetBool) + VALUE_THROWCHECK(bVal, true, GetString) + VALUE_THROWCHECK(bVal, true, GetArray) + // for variables + VALUE_THROWCHECK(bVar, false, GetFloat) + VALUE_THROWCHECK(bVar, true, GetImag) + VALUE_THROWCHECK(bVar, false, GetBool) + VALUE_THROWCHECK(bVar, true, GetString) + VALUE_THROWCHECK(bVar, true, GetArray) + + // Case 3: test string values + // VALUE_THROWCHECK(sVal, true, GetFloat) + VALUE_THROWCHECK(sVal, true, GetImag) + VALUE_THROWCHECK(sVal, true, GetBool) + VALUE_THROWCHECK(sVal, false, GetString) + VALUE_THROWCHECK(sVal, true, GetArray) + // for variables + // VALUE_THROWCHECK(sVar, true, GetFloat) + VALUE_THROWCHECK(sVar, true, GetImag) + VALUE_THROWCHECK(sVar, true, GetBool) + VALUE_THROWCHECK(sVar, false, GetString) + VALUE_THROWCHECK(sVar, true, GetArray) + + // Case 4: test array values + // VALUE_THROWCHECK(aVal, true, GetFloat) + VALUE_THROWCHECK(aVal, true, GetImag) + VALUE_THROWCHECK(aVal, true, GetBool) + VALUE_THROWCHECK(aVal, true, GetString) + VALUE_THROWCHECK(aVal, false, GetArray) + // for variables + // VALUE_THROWCHECK(aVar, true, GetFloat) + VALUE_THROWCHECK(aVar, true, GetImag) + VALUE_THROWCHECK(aVar, true, GetBool) + VALUE_THROWCHECK(aVar, true, GetString) + VALUE_THROWCHECK(aVar, false, GetArray) + + // Case 5: test complex values + // VALUE_THROWCHECK(cVal, false, GetFloat) + VALUE_THROWCHECK(cVal, false, GetImag) + VALUE_THROWCHECK(cVal, true, GetBool) + VALUE_THROWCHECK(cVal, true, GetString) + VALUE_THROWCHECK(cVal, true, GetArray) + // for variables + // VALUE_THROWCHECK(cVar, false, GetFloat) + VALUE_THROWCHECK(cVar, false, GetImag) + VALUE_THROWCHECK(cVar, true, GetBool) + VALUE_THROWCHECK(cVar, true, GetString) + VALUE_THROWCHECK(cVar, true, GetArray) +#undef VALUE_THROWCHECK + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestErrorCodes() +{ + int iNumErr = 0; + *m_stream << _T("testing error codes..."); + + iNumErr += ThrowTest(_T("a,b"), ecUNEXPECTED_COMMA); + iNumErr += ThrowTest(_T("(a,b)"), ecUNEXPECTED_COMMA); + iNumErr += ThrowTest(_T("((a,b))"), ecUNEXPECTED_COMMA); + iNumErr += ThrowTest(_T("2*1,2"), ecUNEXPECTED_COMMA); + iNumErr += ThrowTest(_T("sin(1,2)"), ecTOO_MANY_PARAMS); + + // Invalid expression + // Issue 20: http://code.google.com/p/muparserx/issues/detail?id=20 + iNumErr += ThrowTest(_T(" "), ecUNEXPECTED_EOF); + + iNumErr += ThrowTest(_T("sin(nonexistent_var)"), ecUNASSIGNABLE_TOKEN, 4, _T("nonexistent_var")); + + // Invalid function argument types + iNumErr += ThrowTest(_T("sin(\"test\")"), ecEVAL, 0); + iNumErr += ThrowTest(_T("max(1, \"test\")"), ecEVAL, 0); + iNumErr += ThrowTest(_T("max(1,sin(8), \"t\")"), ecEVAL, 0); + iNumErr += ThrowTest(_T("str2dbl(sin(3.14))"), ecEVAL, 0); + + // Invalid unary operator argument types + iNumErr += ThrowTest(_T("\"test\"n"), ecEVAL, 6); // (nano can only be applied to floats) + iNumErr += ThrowTest(_T("(1+3i)/(8*9i)+\"hallo\""), ecEVAL); + iNumErr += ThrowTest(_T("(1+3i)/(8*9i)-\"hallo\""), ecEVAL); + iNumErr += ThrowTest(_T("(1+3i)/(8*9i)*\"hallo\""), ecEVAL); + iNumErr += ThrowTest(_T("(1+3i)/(8*9i)/\"hallo\""), ecEVAL); + iNumErr += ThrowTest(_T("10+va"), ecEVAL, 2); + + // Type conflicts in binary operators + iNumErr += ThrowTest(_T("\"test\" // 8"), ecEVAL, 7); + iNumErr += ThrowTest(_T("8//\"test\""), ecEVAL, 1); + iNumErr += ThrowTest(_T("5//8"), ecEVAL, 1); + iNumErr += ThrowTest(_T("\"t\"//sin(8)"), ecEVAL, 3); + iNumErr += ThrowTest(_T("sin(8)//\"t\""), ecEVAL, 6); + + // Unexpected end of expression + iNumErr += ThrowTest(_T("3+"), ecUNEXPECTED_EOF); + iNumErr += ThrowTest(_T("8*"), ecUNEXPECTED_EOF); + iNumErr += ThrowTest(_T("3+("), ecUNEXPECTED_EOF); + iNumErr += ThrowTest(_T("3+sin"), ecUNEXPECTED_EOF); + iNumErr += ThrowTest(_T("(2+"), ecUNEXPECTED_EOF); + + iNumErr += ThrowTest(_T("3+)"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("3)"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("(3))"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("()"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("(2+)"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("sin(cos)"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("sin(())"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("sin()"), ecTOO_FEW_PARAMS); + iNumErr += ThrowTest(_T("sin)"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("pi)"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("a)"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("2(-m)"), ecUNEXPECTED_PARENS); + iNumErr += ThrowTest(_T("2(m)"), ecUNEXPECTED_PARENS); + + iNumErr += ThrowTest(_T("(1+2"), ecMISSING_PARENS); + iNumErr += ThrowTest(_T("((3)"), ecMISSING_PARENS); + + // The behaviour in the next function depends on whether + // implicit variable creation is allowed or not. (momentarily its active) + iNumErr += ThrowTest(_T("5z)"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("sin(3)xyz"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("5t6"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("5 t 6"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("ksdfj"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("-m"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("m4"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("sin(m)"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("m m"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("m(8)"), ecUNASSIGNABLE_TOKEN); + iNumErr += ThrowTest(_T("4 + m"), ecUNASSIGNABLE_TOKEN); + + // unexpected operator + iNumErr += ThrowTest(_T("5+*3)"), ecUNEXPECTED_OPERATOR); + + // unexpected comma (used without a function) + iNumErr += ThrowTest(_T(",3"), ecUNEXPECTED_COMMA); + iNumErr += ThrowTest(_T("sin(,sin(8))"), ecUNEXPECTED_COMMA); + + // unexpected variable + iNumErr += ThrowTest(_T("a _xxx_ b"), ecUNASSIGNABLE_TOKEN, 2); // if a variable factory is installed ecUNEXPECTED_VAR + + iNumErr += ThrowTest(_T("sin(3)cos(3)"), ecUNEXPECTED_FUN); + iNumErr += ThrowTest(_T("sin(3)3"), ecUNEXPECTED_VAL); + iNumErr += ThrowTest(_T("sin(3)+"), ecUNEXPECTED_EOF); + + // value recognition + iNumErr += ThrowTest(_T("0x"), ecUNASSIGNABLE_TOKEN); // incomplete hex value + iNumErr += ThrowTest(_T("1+0x"), ecUNASSIGNABLE_TOKEN); // incomplete hex value + iNumErr += ThrowTest(_T("a+0x"), ecUNASSIGNABLE_TOKEN); // incomplete hex value + + // index operator + iNumErr += ThrowTest(_T("3n[1]"), ecINDEX_OUT_OF_BOUNDS); // Indexing a scalar is ok, but this index is out of bounds (0 would be ok) + iNumErr += ThrowTest(_T("min(3,]"), ecUNEXPECTED_SQR_BRACKET); + iNumErr += ThrowTest(_T("sin(]"), ecUNEXPECTED_SQR_BRACKET); + iNumErr += ThrowTest(_T("va[]"), ecUNEXPECTED_SQR_BRACKET); + iNumErr += ThrowTest(_T("3+]"), ecUNEXPECTED_SQR_BRACKET); + iNumErr += ThrowTest(_T("sin[a)"), ecUNEXPECTED_SQR_BRACKET); + iNumErr += ThrowTest(_T("1+[8]"), ecUNEXPECTED_SQR_BRACKET); + iNumErr += ThrowTest(_T("1[8]"), ecUNEXPECTED_SQR_BRACKET); + iNumErr += ThrowTest(_T("[1]"), ecUNEXPECTED_SQR_BRACKET); + iNumErr += ThrowTest(_T("]1"), ecUNEXPECTED_SQR_BRACKET); + iNumErr += ThrowTest(_T("va[[3]]"), ecUNEXPECTED_SQR_BRACKET); + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestStringFun() +{ + int iNumErr = 0; + *m_stream << _T("testing string functions..."); + + // escape sequences + iNumErr += EqnTest(_T("\"\\\"quoted_string\\\"\""), _T("\"quoted_string\""), true); // "\"quoted_string\"" -> "quoted_string" + iNumErr += EqnTest(_T("\"\\\"\\\"\""), _T("\"\""), true); // "\"\"" -> "" + iNumErr += EqnTest(_T("\"\\\\\""), _T("\\"), true); // "\\" -> \ (single backslash) + + // String functions + iNumErr += EqnTest(_T("strlen(\"12345\")"), 5.0, true); + iNumErr += EqnTest(_T("strlen(toupper(\"abcde\"))"), 5.0, true); + iNumErr += EqnTest(_T("sin(0)+(float)strlen(\"12345\")"), (float_type)5.0, true); + iNumErr += EqnTest(_T("10*(float)strlen(toupper(\"12345\"))"), (float_type)50.0, true); + iNumErr += EqnTest(_T("\"hello \"//\"world\""), string_type(_T("hello world")), true); + iNumErr += EqnTest(_T("toupper(\"hello \")//\"world\""), string_type(_T("HELLO world")), true); + iNumErr += EqnTest(_T("\"hello \"//toupper(\"world\")//\" !!!\""), string_type(_T("hello WORLD !!!")), true); + + Assessment(iNumErr); + + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestPostfix() +{ + int iNumErr = 0; + *m_stream << _T("testing postfix operators..."); + + // application + iNumErr += EqnTest(_T("1n"), (float_type)1e-9, true); + iNumErr += EqnTest(_T("8n"), (float_type)8e-9, true); + iNumErr += EqnTest(_T("8n"), (float_type)123.0, false); + iNumErr += EqnTest(_T("3m+5"), (float_type)5.003, true); + iNumErr += EqnTest(_T("1000m"), (float_type)1.0, true); + iNumErr += EqnTest(_T("1000 m"), (float_type)1.0, true); + iNumErr += EqnTest(_T("(a)m"), (float_type)1e-3, true); + iNumErr += EqnTest(_T("-(a)m"), (float_type)-1e-3, true); + iNumErr += EqnTest(_T("-2m"), (float_type)-2e-3, true); + iNumErr += EqnTest(_T("a++b"), 3.0, true); + iNumErr += EqnTest(_T("a ++ b"), 3.0, true); + iNumErr += EqnTest(_T("1++2"), 3.0, true); + iNumErr += EqnTest(_T("1 ++ 2"), 3.0, true); + iNumErr += EqnTest(_T("2+(a*1000)m"), (float_type)3.0, true); + // some incorrect results + iNumErr += EqnTest(_T("1000m"), (float_type)0.1, false); + iNumErr += EqnTest(_T("(a)m"), (float_type)2.0, false); + // factorial operator + iNumErr += EqnTest(_T("5!"), 120.0, true); + iNumErr += EqnTest(_T("-5!"), -120.0, true); + iNumErr += ThrowTest(_T("(-5)!"), ecDOMAIN_ERROR); + + // Special tests for systems not supporting IEEE 754 + if (!std::numeric_limits::is_iec559) + { + iNumErr += ThrowTest(_T("123456!"), ecOVERFLOW); + } + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestInfix() +{ + int iNumErr = 0; + *m_stream << _T("testing infix operators..."); + + float_type a = 1; + float_type b = 2; + + iNumErr += EqnTest(_T("-1"), (float_type)-1.0, true); + iNumErr += EqnTest(_T("-(-1)"), (float_type)1.0, true); + iNumErr += EqnTest(_T("-(-1)*2"), (float_type)2.0, true); + iNumErr += EqnTest(_T("-(-2)*sqrt(4)"), (float_type)4.0, true); + iNumErr += EqnTest(_T("-a"), -a, true); + iNumErr += EqnTest(_T("-(a)"), -(a), true); + iNumErr += EqnTest(_T("-(-a)"), -(-a), true); + iNumErr += EqnTest(_T("-(-a)*2"), -(-a) * 2, true); + iNumErr += EqnTest(_T("-(8)"), (float_type)-8.0, true); + iNumErr += EqnTest(_T("-8"), (float_type)-8.0, true); + iNumErr += EqnTest(_T("-(2+1)"), (float_type)-3.0, true); + //iNumErr += EqnTest("-(f1of1(1+2*3)+1*2)", -9.0, true); + //iNumErr += EqnTest("-(-f1of1(1+2*3)+1*2)", 5.0, true); + iNumErr += EqnTest(_T("-sin(8)"), (float_type)-0.989358, true); + iNumErr += EqnTest(_T("-sin(8)"), (float_type)0.989358, false); + iNumErr += EqnTest(_T("3-(-a)"), (float_type)4.0, true); + iNumErr += EqnTest(_T("3--a"), (float_type)4.0, true); + iNumErr += EqnTest(_T("2++4"), (float_type)6.0, true); + iNumErr += EqnTest(_T("--1"), (float_type)1.0, true); + + // sign precedence + // Issue 14: https://code.google.com/p/muparserx/issues/detail?id=14 + iNumErr += EqnTest(_T("-3^2"), -9.0, true); + iNumErr += EqnTest(_T("-b^2^3-b^8"), -std::pow(b, std::pow(2.0, 3.0)) - std::pow(b, 8), true); + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestMultiArg() +{ + int iNumErr = 0; + *m_stream << _T("testing multiarg functions..."); + + // Multiarg functions being called without any parameters + iNumErr += ThrowTest(_T("min()"), ecTOO_FEW_PARAMS); + iNumErr += ThrowTest(_T("max()"), ecTOO_FEW_PARAMS); + iNumErr += ThrowTest(_T("sum()"), ecTOO_FEW_PARAMS); + + // application + iNumErr += EqnTest(_T("max(1,8,9,(int)6)"), (float_type)9.0, true); + iNumErr += EqnTest(_T("max((int)6, 1+2, 4, -9)"), (float_type)6.0, true); + iNumErr += EqnTest(_T("min((int)6, 1+2, 4, -9)"), (float_type)-9.0, true); + + // + iNumErr += EqnTest(_T("a=test0()"), (float_type)0, true); + iNumErr += EqnTest(_T("b=a+test0()"), (float_type)1, true); + + // added as response to this bugreport: + // http://code.google.com/p/muparserx/issues/detail?id=1 + // cause of the error: Function tokens were not cloned in the tokenreader when beeing found. + // a pointer to the one and only function onject was returned instead + // consequently the argument counter was overwritten by the second function call + // causing an assertion later on. + iNumErr += EqnTest(_T("sum(1,2)/sum(3,4)"), (float_type)0.428571, true); + iNumErr += EqnTest(_T("3/sum(3,4,5)"), (float_type)0.25, true); + iNumErr += EqnTest(_T("sum(3)/sum(3,4,5)"), (float_type)0.25, true); + iNumErr += EqnTest(_T("sum(3)+sum(3,4,5)"), (float_type)15, true); + iNumErr += EqnTest(_T("sum(1,2)/sum(3,4,5)"), (float_type)0.25, true); + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestVector() +{ + int iNumErr = 0; + *m_stream << _T("testing vector operations..."); + + // Vector operations + iNumErr += ThrowTest(_T("10+2*va"), ecEVAL); // fail: number + vector + iNumErr += ThrowTest(_T("10+va*2"), ecEVAL); // fail: number + vector + iNumErr += ThrowTest(_T("va+vc"), ecMATRIX_DIMENSION_MISMATCH); // fail: vectors of different size + iNumErr += ThrowTest(_T("va-vc"), ecMATRIX_DIMENSION_MISMATCH); // fail: vectors of different size + iNumErr += ThrowTest(_T("va*vc"), ecMATRIX_DIMENSION_MISMATCH); // fail: vectors of different size + iNumErr += ThrowTest(_T("va*vb"), ecMATRIX_DIMENSION_MISMATCH); // fail: matrix dimension mismatch + iNumErr += ThrowTest(_T("va*va"), ecMATRIX_DIMENSION_MISMATCH); // fail: matrix dimension mismatch + iNumErr += ThrowTest(_T("(va*vb)*b"), ecMATRIX_DIMENSION_MISMATCH); // fail: matrix dimension mismatch + iNumErr += ThrowTest(_T("va[1.23]"), ecTYPE_CONFLICT_IDX, 7); // fail: float value used as index + iNumErr += ThrowTest(_T("va[sin(8)]"), ecTYPE_CONFLICT_IDX, 9); // fail: float value used as index + iNumErr += ThrowTest(_T("va[-1]"), ecINDEX_OUT_OF_BOUNDS); // fail: negative value used as an index + iNumErr += ThrowTest(_T("va[c]"), ecINDEX_OUT_OF_BOUNDS); + iNumErr += ThrowTest(_T("va[(3)]"), ecINDEX_OUT_OF_BOUNDS); + iNumErr += ThrowTest(_T("a[1]"), ecINDEX_OUT_OF_BOUNDS); // indexing a scalar is ok, but this index is out of bounds (0 would be ok...) + iNumErr += ThrowTest(_T("va[1"), ecMISSING_SQR_BRACKET); + iNumErr += ThrowTest(_T("va[1]]"), ecUNEXPECTED_SQR_BRACKET); + + //iNumErr += ThrowTest(_T("va==9"), ecEVAL); + //iNumErr += ThrowTest(_T("va==a"), ecEVAL); + //iNumErr += ThrowTest(_T("a==va"), ecEVAL); + //iNumErr += ThrowTest(_T("9==va"), ecEVAL); + + Value v(3, 0); + v.At(0) = (float_type)5.0; + v.At(1) = (float_type)5.0; + v.At(2) = (float_type)5.0; + iNumErr += EqnTest(_T("va+vb"), v, true); + + v.At(0) = (float_type)5.0; + v.At(1) = (float_type)5.0; + v.At(2) = (float_type)6.0; + iNumErr += EqnTest(_T("va+vb"), v, false); + + v.At(0) = (float_type)-1.0; + v.At(1) = (float_type)-2.0; + v.At(2) = (float_type)-3.0; + iNumErr += EqnTest(_T("-va"), v, true); + + iNumErr += EqnTest(_T("sizeof(va+vb)"), 3.0, true); + iNumErr += EqnTest(_T("sizeof(va-vb)"), 3.0, true); + + iNumErr += EqnTest(_T("va==vb"), false, true); + iNumErr += EqnTest(_T("va!=vb"), true, true); + //iNumErr += EqnTest(_T("vavb"), true, true); + //iNumErr += EqnTest(_T("va<=vb"), false, true); + //iNumErr += EqnTest(_T("va>=vb"), true, true); + + iNumErr += EqnTest(_T("vb[va[0]]"), 3.0, true); + iNumErr += EqnTest(_T("m1[0,0]+m1[1,1]+m1[2,2]"), 3.0, true); + iNumErr += EqnTest(_T("vb[m1[0,0]]"), 3.0, true); + + iNumErr += EqnTest(_T("m1[0,0]=2"), 2.0, true); + iNumErr += EqnTest(_T("m1[1,1]=2"), 2.0, true); + iNumErr += EqnTest(_T("m1[2,2]=2"), 2.0, true); + iNumErr += EqnTest(_T("va[0]=12.3"), (float_type)12.3, true); + iNumErr += EqnTest(_T("va[1]=12.3"), (float_type)12.3, true); + iNumErr += EqnTest(_T("va[2]=12.3"), (float_type)12.3, true); + + iNumErr += EqnTest(_T("va[0]"), 1.0, true); + iNumErr += EqnTest(_T("va[1]"), 2.0, true); + iNumErr += EqnTest(_T("va[2]"), 3.0, true); + iNumErr += EqnTest(_T("(va[2])"), 3.0, true); + iNumErr += EqnTest(_T("va[a]"), 2.0, true); + iNumErr += EqnTest(_T("(va[a])"), 2.0, true); + iNumErr += EqnTest(_T("va[b]"), 3.0, true); + iNumErr += EqnTest(_T("va[(2)]"), 3.0, true); + iNumErr += EqnTest(_T("va[-(-2)]"), 3.0, true); + iNumErr += EqnTest(_T("(va[(2)])"), 3.0, true); + iNumErr += EqnTest(_T("(va[-(-2)])"), 3.0, true); + iNumErr += EqnTest(_T("va[1+1]"), 3.0, true); + iNumErr += EqnTest(_T("va[(int)sin(8)+1]"), 2.0, true); + + iNumErr += EqnTest(_T("va[2]+4"), 7.0, true); + iNumErr += EqnTest(_T("4+va[2]"), 7.0, true); + iNumErr += EqnTest(_T("va[2]*4"), 12.0, true); + iNumErr += EqnTest(_T("4*va[2]"), 12.0, true); + iNumErr += EqnTest(_T("va[2]+a"), 4.0, true); + iNumErr += EqnTest(_T("a+va[2]"), 4.0, true); + iNumErr += EqnTest(_T("va[2]*b"), 6.0, true); + iNumErr += EqnTest(_T("b*va[2]"), 6.0, true); + + // Issue 68 (and related issues): + iNumErr += EqnTest(_T("(abs(-3)+2)>=min(6,5)"), true, true); + iNumErr += EqnTest(_T("(abs(-3))>abs(2)"), true, true); + iNumErr += EqnTest(_T("min(1,2,-3)>-4"), true, true); + iNumErr += EqnTest(_T("(abs(-3))>-2"), true, true); + iNumErr += EqnTest(_T("abs(-3)>abs(2)"), true, true); + + // Issue 42: + // https://code.google.com/p/muparserx/issues/detail?id=42 + v.At(0) = (float_type)1.0; + v.At(1) = (float_type)0.0; + v.At(2) = (float_type)0.0; + iNumErr += EqnTest(_T("{1,0,0}'"), v, true); + iNumErr += EqnTest(_T("{(1),0,0}'"), v, true); + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestBinOp() +{ + int iNumErr = 0; + *m_stream << _T("testing binary operators..."); + float_type a = 1; + + // standard aperators + iNumErr += EqnTest(_T("1+7"), (float_type)8.0, true); + iNumErr += EqnTest(_T("10-1"), (float_type)9.0, true); + iNumErr += EqnTest(_T("3*4"), (float_type)12.0, true); + iNumErr += EqnTest(_T("10/2"), (float_type)5.0, true); + // operator associativity + iNumErr += EqnTest(_T("2^2^3"), (float_type)256.0, true); + iNumErr += EqnTest(_T("3+4*2/(1-5)^2^3"), (float_type)3.0001220703125, true); + iNumErr += EqnTest(_T("1/2/3"), (float_type)1.0 / (float_type)6.0, true); + + // operator precedencs + iNumErr += EqnTest(_T("1+2-3*4/5^6"), (float_type)2.99923, true); + iNumErr += EqnTest(_T("a+b-c*4/5^6"), (float_type)2.99923, true); + iNumErr += EqnTest(_T("1^2/3*4-5+6"), (float_type)2.3333, true); + iNumErr += EqnTest(_T("a^b/c*4-5+6"), (float_type)2.3333, true); + iNumErr += EqnTest(_T("1+2*3"), (float_type)7.0, true); + iNumErr += EqnTest(_T("a+b*c"), (float_type)7.0, true); + iNumErr += EqnTest(_T("(1+2)*3"), (float_type)9.0, true); + iNumErr += EqnTest(_T("(a+b)*c"), (float_type)9.0, true); + iNumErr += EqnTest(_T("(1+2)*(-3)"), (float_type)-9.0, true); + iNumErr += EqnTest(_T("(a+b)*(-c)"), (float_type)-9.0, true); + iNumErr += EqnTest(_T("2/4"), (float_type)0.5, true); + iNumErr += EqnTest(_T("4&4"), 4.0, true); + iNumErr += EqnTest(_T("2+2&(a+b+c)"), 4.0, true); + iNumErr += EqnTest(_T("3&3"), 3.0, true); + iNumErr += EqnTest(_T("c&3"), 3.0, true); + iNumErr += EqnTest(_T("(c)&3"), 3.0, true); + iNumErr += EqnTest(_T("(a+b)&3"), 3.0, true); + iNumErr += EqnTest(_T("(a+b+c)&6"), 6.0, true); + iNumErr += EqnTest(_T("(1+2+3)&6"), 6.0, true); + iNumErr += EqnTest(_T("3&c"), 3.0, true); + iNumErr += EqnTest(_T("(a<<1)+2"), 4.0, true); + iNumErr += EqnTest(_T("(a<<2)+2"), 6.0, true); + iNumErr += EqnTest(_T("(a<<3)+2"), 10.0, true); + iNumErr += EqnTest(_T("(a<<4)+2"), 18.0, true); + iNumErr += EqnTest(_T("(a<<5)+2"), 34.0, true); + iNumErr += EqnTest(_T("1<<31"), (float_type)2147483648, true); + iNumErr += EqnTest(_T("-1<<31"), (float_type)-2147483648.0, true); + iNumErr += EqnTest(_T("1<<45"), (float_type)35184372088832.0, true); + iNumErr += EqnTest(_T("-1<<45"), (float_type)-35184372088832.0, true); + iNumErr += EqnTest(_T("8<<-2"), 2.0, true); + iNumErr += EqnTest(_T("8<<-4"), 0.0, true); + // Issue 25: http://code.google.com/p/muparserx/issues/detail?id=25 + iNumErr += ThrowTest(_T("55<<2222222"), ecOVERFLOW); + // Issue 16: http://code.google.com/p/muparserx/issues/detail?id=16 + iNumErr += EqnTest(_T("true == true && false"), true == true && false, true); + iNumErr += EqnTest(_T("false == true && false"), false == true && false, true); + iNumErr += EqnTest(_T("a==1.0 && a==1.0"), a == 1.0 && a == 1.0, true); + + // bool operators for comparing values + iNumErr += EqnTest(_T("aa"), true, true); + iNumErr += EqnTest(_T("a>a"), false, true); + iNumErr += EqnTest(_T("aa"), false, true); + iNumErr += EqnTest(_T("a<=a"), true, true); + iNumErr += EqnTest(_T("a<=b"), true, true); + iNumErr += EqnTest(_T("b<=a"), false, true); + iNumErr += EqnTest(_T("a>=a"), true, true); + iNumErr += EqnTest(_T("b>=a"), true, true); + iNumErr += EqnTest(_T("a>=b"), false, true); + // The following equations were raising type conflict errors once + // since the result of sqrt(1) is 1 which is an integer as fas as muParserX + // is concerned: + iNumErr += EqnTest(_T("sqrt(a)sin(8)"), true, true); + iNumErr += EqnTest(_T("sqrt(a)>=sin(8)"), true, true); + iNumErr += EqnTest(_T("sqrt(a)==sin(8)"), false, true); + iNumErr += EqnTest(_T("sqrt(a)!=sin(8)"), true, true); + iNumErr += EqnTest(_T("sqrt(a)+1.01"), (float_type)2.01, true); + iNumErr += EqnTest(_T("sqrt(a)-1.01"), (float_type)-0.01, true); + + // interaction with sign operator + iNumErr += EqnTest(_T("3-(-a)"), 4.0, true); + iNumErr += EqnTest(_T("3--a"), 4.0, true); + + // Problems with small bogus real/imag values introduced due to limited floating point accuracy + iNumErr += EqnTest(_T("(-2)^3"), -8.0, true); // may introduce incorrect imaginary value (When computed with the log/exp formula: -8 + 2.93e-15i) + iNumErr += EqnTest(_T("imag((-2)^3)==0"), true, true); // may introduce incorrect imaginary value (When computed with the log/exp formula: -8 + 2.93e-15i) + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestIfElse() +{ + int iNumErr = 0; + *m_stream << _T("testing if-else conditional..."); + + float_type a = 1; + + // Test error detection + iNumErr += ThrowTest(_T(": 2"), ecMISPLACED_COLON); + iNumErr += ThrowTest(_T("? 1 : 2"), ecUNEXPECTED_CONDITIONAL); + iNumErr += ThrowTest(_T("(ab) ? true : false) ? 1 : 2"), 2.0, true); + iNumErr += EqnTest(_T("((a>b) ? true : false) ? 1 : sum((a>b) ? 1 : 2)"), 2.0, true); + iNumErr += EqnTest(_T("((a>b) ? false : true) ? 1 : sum((a>b) ? 1 : 2)"), 1.0, true); + iNumErr += EqnTest(_T("(true) ? 10 : 11"), 10.0, true); + iNumErr += EqnTest(_T("(true) ? a+b : c+d"), 3.0, true); + iNumErr += EqnTest(_T("(true) ? false : true"), false, true); + iNumErr += EqnTest(_T("(false) ? 10 : 11"), 11.0, true); + iNumErr += EqnTest(_T("(false) ? a+b : c+d"), 1.0, true); + iNumErr += EqnTest(_T("(false) ? false : true"), true, true); + iNumErr += EqnTest(_T("(ab) ? 10 : 11"), 11.0, true); + iNumErr += EqnTest(_T("(ab) ? c : d"), -2.0, true); + iNumErr += EqnTest(_T("(a>b) ? true : false"), false, true); + + // With multiarg functions + iNumErr += EqnTest(_T("sum((a>b) ? 1 : 2)"), 2.0, true); + iNumErr += EqnTest(_T("sum((a>b) ? 1 : 2, 100)"), 102.0, true); + iNumErr += EqnTest(_T("sum((true) ? 1 : 2)"), 1.0, true); + iNumErr += EqnTest(_T("sum((true) ? 1 : 2, 100)"), 101.0, true); + iNumErr += EqnTest(_T("sum(3, (a>b) ? 3 : 10)"), 13.0, true); + iNumErr += EqnTest(_T("sum(3, (ab) ? 3 : 10)*10"), 130.0, true); + iNumErr += EqnTest(_T("sum(3, (ab) ? 3 : 10)"), 130.0, true); + iNumErr += EqnTest(_T("10*sum(3, (ab) ? sum(3, (ab) ? sum(3, (ab) ? sum(3, (ab)&&(a2)&&(1<2) ? 128 : 255"), 255.0, true); + iNumErr += EqnTest(_T("((1<2)&&(1<2)) ? 128 : 255"), 128.0, true); + iNumErr += EqnTest(_T("((1>2)&&(1<2)) ? 128 : 255"), 255.0, true); + iNumErr += EqnTest(_T("((ab)&&(ac) ? 1 : 2) : 3"), 2., true); + iNumErr += EqnTest(_T("(a>b) ? ((bb) ? ((b>c) ? 1 : 2) : 3"), 3., true); + + // nested conditionals without brackets + iNumErr += EqnTest(_T("(ac) ? 1 : 2 : 3"), 2., true); + iNumErr += EqnTest(_T("(a>b) ? (bb) ? (b>c) ? 1 : 2 : 3"), 3., true); + + // Neue Tests + iNumErr += EqnTest(_T("(ab)&&(a2)&&(1<2) ? 128 : 255"), 255., true); + iNumErr += EqnTest(_T("((1<2)&&(1<2)) ? 128 : 255"), 128., true); + iNumErr += EqnTest(_T("((1>2)&&(1<2)) ? 128 : 255"), 255., true); + iNumErr += EqnTest(_T("((ab)&&(a0 ? 1>2 ? 128 : 255 : 1>0 ? 32 : 64"), 255., true); + iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 :(1>0 ? 32 : 64)"), 255., true); + iNumErr += EqnTest(_T("1>0 ? 1>0 ? 128 : 255 : 1>2 ? 32 : 64"), 128., true); + iNumErr += EqnTest(_T("1>0 ? 1>0 ? 128 : 255 :(1>2 ? 32 : 64)"), 128., true); + iNumErr += EqnTest(_T("1>2 ? 1>2 ? 128 : 255 : 1>0 ? 32 : 64"), 32., true); + iNumErr += EqnTest(_T("1>2 ? 1>0 ? 128 : 255 : 1>2 ? 32 : 64"), 64., true); + iNumErr += EqnTest(_T("1>0 ? 50 : 1>0 ? 128 : 255"), 50., true); + iNumErr += EqnTest(_T("1>0 ? 50 : (1>0 ? 128 : 255)"), 50., true); + iNumErr += EqnTest(_T("1>0 ? 1>0 ? 128 : 255 : 50"), 128., true); + iNumErr += EqnTest(_T("1>2 ? 1>2 ? 128 : 255 : 1>0 ? 32 : 1>2 ? 64 : 16"), 32., true); + iNumErr += EqnTest(_T("1>2 ? 1>2 ? 128 : 255 : 1>0 ? 32 :(1>2 ? 64 : 16)"), 32., true); + iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 : 1>0 ? 32 :1>2 ? 64 : 16"), 255., true); + iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 : (1>0 ? 32 :1>2 ? 64 : 16)"), 255., true); + iNumErr += EqnTest(_T("true ? false ? 128 : 255 : true ? 32 : 64"), 255., true); + + // assignment operators + iNumErr += EqnTest(_T("a= false ? 128 : 255"), 255., true); + iNumErr += EqnTest(_T("a=((a>b)&&(a + + // long formula (Reference: Matlab) + iNumErr += EqnTest( + "(atan(sin((((((((((((((((pi/cos((a/((((0.53-b)-pi)*e)/b))))+2.51)+a)-0.54)/0.98)+b)*b)+e)/a)+b)+a)+b)+pi)/e" + ")+a)))*2.77)", -2.16995656, true); + */ + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestScript() +{ + int iNumErr = 0; + *m_stream << _T("testing script features..."); + + // Test error detection + iNumErr += ThrowTest(_T("sin(\n"), ecUNEXPECTED_NEWLINE); + iNumErr += ThrowTest(_T("1+\n"), ecUNEXPECTED_NEWLINE); + iNumErr += ThrowTest(_T("a*\n"), ecUNEXPECTED_NEWLINE); + iNumErr += ThrowTest(_T("va[\n"), ecUNEXPECTED_NEWLINE); + iNumErr += ThrowTest(_T("(true) ? \n"), ecUNEXPECTED_NEWLINE); + iNumErr += ThrowTest(_T("(true) ? 10:\n"), ecUNEXPECTED_NEWLINE); + + // Expressions spanning multiple lines + iNumErr += EqnTest(_T("a=1\n") + _T("b=2\n") + _T("c=3\n") + _T("a+b+c"), 6., true); + + // Ending an expression with a newline + iNumErr += EqnTest(_T("3\n"), 3., true); + iNumErr += EqnTest(_T("1+2\n"), 3., true); + iNumErr += EqnTest(_T("\n1+2\n"), 3., true); + iNumErr += EqnTest(_T("\n1+2\n\na+b"), 3., true); + + // Testing comments + /* 20130107 Not yet... + iNumErr += EqnTest(_T("a=10 % this is a comment\n") + _T("b=23 % this is another comment\n") + _T("a+b"), 33, true); + */ + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +int ParserTester::TestValReader() +{ + int iNumErr = 0; + *m_stream << _T("testing value reader..."); + + // Hex value reader + iNumErr += EqnTest(_T("0x1"), 1., true); + iNumErr += EqnTest(_T("0x1+0x2"), 3., true); + iNumErr += EqnTest(_T("0xff"), 255., true); + + // Reading of binary values + iNumErr += EqnTest(_T("0b1"), 1., true); + iNumErr += EqnTest(_T("0b01"), 1., true); + iNumErr += EqnTest(_T("0b11"), 3., true); + iNumErr += EqnTest(_T("0b011"), 3., true); + iNumErr += EqnTest(_T("0b11111111"), 255., true); + iNumErr += EqnTest(_T("b*0b011"), 6.0, true); + iNumErr += EqnTest(_T("0b1111111111111111111111111111111"), 2147483647., true); + iNumErr += EqnTest(_T("0b10000000000000000000000000000000"), -2147483647. - 1, true); + iNumErr += EqnTest(_T("0b11111111111111111111111111111111"), -1., true); + iNumErr += ThrowTest(_T("0b100000000000000000000000000000000"), ecUNDEFINED); + + // string value reader + iNumErr += EqnTest(_T("\"hallo\""), _T("hallo"), true); + + // boolean value reader + iNumErr += EqnTest(_T("true"), true, true); + iNumErr += EqnTest(_T("false"), false, true); + + // boolean value reader + iNumErr += EqnTest(_T("true"), true, true); + iNumErr += EqnTest(_T("false"), false, true); + + // mixed + iNumErr += EqnTest(_T("0b011+0xef"), 242., true); + + Assessment(iNumErr); + return iNumErr; +} + +//--------------------------------------------------------------------------- +void ParserTester::AddTest(testfun_type a_pFun) +{ + m_vTestFun.push_back(a_pFun); +} + +//--------------------------------------------------------------------------- +void ParserTester::Run() +{ + int iStat = 0; + try + { + for (int i = 0; i < (int)m_vTestFun.size(); ++i) + iStat += (this->*m_vTestFun[i])(); + } + catch (ParserError &e) + { + *m_stream << e.GetMsg() << endl; + *m_stream << e.GetToken() << endl; + Abort(); + } + catch (std::exception &e) + { + *m_stream << e.what() << endl; + Abort(); + } + catch (...) + { + *m_stream << _T("Internal error"); + Abort(); + } + + if (iStat == 0) + { + *m_stream << _T("Test passed (") << ParserTester::c_iCount << _T(" expressions)") << endl; + } + else + { + *m_stream << _T("Test failed with ") << iStat + << _T(" errors (") << ParserTester::c_iCount + << _T(" expressions)") << endl; + } + ParserTester::c_iCount = 0; + +#ifdef MUP_LEAKAGE_REPORT + // All tokens must have been destroyed by now, verify this + IToken::LeakageReport(); +#endif +} + +//--------------------------------------------------------------------------- +int ParserTester::ThrowTest(const string_type &a_sExpr, int a_nErrc, int a_nPos, string_type a_sIdent) +{ + ParserTester::c_iCount++; + + try + { + ParserX p; + + // Add variables + Value vVarVal[] = { 1., 2., 3., -2. }; + p.DefineVar(_T("a"), Variable(&vVarVal[0])); + p.DefineVar(_T("b"), Variable(&vVarVal[1])); + p.DefineVar(_T("c"), Variable(&vVarVal[2])); + p.DefineVar(_T("d"), Variable(&vVarVal[3])); + + // array variables + Value aVal1(3, 0); + aVal1.At(0) = (float_type)1.0; + aVal1.At(1) = (float_type)2.0; + aVal1.At(2) = (float_type)3.0; + + Value aVal2(3, 0); + aVal2.At(0) = (float_type)4.0; + aVal2.At(1) = (float_type)3.0; + aVal2.At(2) = (float_type)2.0; + + Value aVal3(4, 0); + aVal3.At(0) = (float_type)4.0; + aVal3.At(1) = (float_type)3.0; + aVal3.At(2) = (float_type)2.0; + aVal3.At(3) = (float_type)5.0; + + Value aVal4(4, 0); + aVal4.At(0) = (float_type)4.0; + aVal4.At(1) = false; + aVal4.At(2) = _T("hallo"); + + // Matrix variables + Value m1(3, 3, 0); + m1.At(0, 0) = 1.; + m1.At(1, 1) = 1.; + m1.At(2, 2) = 1.; + + Value m2(3, 3, 0); + m2.At(0, 0) = 1.; m2.At(0, 1) = 2.; m2.At(0, 2) = 3.; + m2.At(1, 0) = 4.; m2.At(1, 1) = 5.; m2.At(1, 2) = 6.; + m2.At(2, 0) = 7.; m2.At(2, 1) = 8.; m2.At(2, 2) = 9.; + + p.DefineVar(_T("m1"), Variable(&m1)); + p.DefineVar(_T("m2"), Variable(&m2)); + p.DefineVar(_T("va"), Variable(&aVal1)); + p.DefineVar(_T("vb"), Variable(&aVal2)); + p.DefineVar(_T("vc"), Variable(&aVal3)); + p.DefineVar(_T("vd"), Variable(&aVal4)); + + p.SetExpr(a_sExpr); + Value fRes = p.Eval(); + } + catch (ParserError &e) + { + // output the formula in case of an failed test + if (a_nErrc != e.GetCode()) + { + *m_stream << _T("\n ") + << _T("Expression: \"") << a_sExpr + << _T("\" Code:") << e.GetCode() + << _T(" Expected:") << a_nErrc; + } + + // Check whether the error is reported at the correct expression position + if (a_nPos != -1 && a_nPos != e.GetPos()) + { + *m_stream << _T("\n ") + << _T("Invalid error position: \"") << a_sExpr + << _T("\" Pos:") << e.GetPos() + << _T(" Expected:") << a_nPos; + } + + if (a_sIdent.length() && a_sIdent != e.GetContext().Ident) + { + *m_stream << _T("\n ") + << _T("Invalid identifier: \"") << a_sExpr + << _T("\" Ident:") << e.GetContext().Ident + << _T(" Expected:") << a_sIdent; + } + + return (a_nErrc == e.GetCode() && (a_nPos == -1 || a_nPos == e.GetPos())) ? 0 : 1; + } + + *m_stream << _T("\n ") + << _T("Expression failed: \"") + << a_sExpr + << _T("\" (no exception raised)."); + + return 1; +} + +//--------------------------------------------------------------------------- +int ParserTester::EqnTest(const string_type &a_str, Value a_val, bool a_fPass, int nExprVar) +{ + ParserTester::c_iCount++; + int iRet(1); + Value fVal[5]; + + try + { + // p1 is a pointer since I'm going to delete it in order to test if + // parsers after copy construction still refer to members of the deleted object. + // !! If this is the case this function will crash !! + std::unique_ptr p1(new ParserX()); + + // Add variables + Value vVarVal[] = { 1., 2., 3., -2., -1. }; + + // m1 ist die Einheitsmatrix + Value m1(3, 3, 0); + m1.At(0, 0) = 1.; + m1.At(1, 1) = 1.; + m1.At(2, 2) = 1.; + + // m2 ist die Einheitsmatrix + Value m2(3, 3, 0); + m2.At(0, 0) = 1.; m2.At(0, 1) = 2.; m2.At(0, 2) = 3.; + m2.At(1, 0) = 4.; m2.At(1, 1) = 5.; m2.At(1, 2) = 6.; + m2.At(2, 0) = 7.; m2.At(2, 1) = 8.; m2.At(2, 2) = 9.; + + p1->DefineOprt(new DbgSillyAdd); + p1->DefineFun(new FunTest0); + + p1->DefineVar(_T("a"), Variable(&vVarVal[0])); + p1->DefineVar(_T("b"), Variable(&vVarVal[1])); + p1->DefineVar(_T("c"), Variable(&vVarVal[2])); + p1->DefineVar(_T("d"), Variable(&vVarVal[3])); + p1->DefineVar(_T("f"), Variable(&vVarVal[4])); + p1->DefineVar(_T("m1"), Variable(&m1)); + p1->DefineVar(_T("m2"), Variable(&m2)); + + // Add constants + p1->DefineConst(_T("const"), 1.); + p1->DefineConst(_T("const1"), 2.); + p1->DefineConst(_T("const2"), 3.); + + // some vector variables + Value aVal1(3, 0); + aVal1.At(0) = (float_type)1.0; + aVal1.At(1) = (float_type)2.0; + aVal1.At(2) = (float_type)3.0; + + Value aVal2(3, 0); + aVal2.At(0) = (float_type)4.0; + aVal2.At(1) = (float_type)3.0; + aVal2.At(2) = (float_type)2.0; + p1->DefineVar(_T("va"), Variable(&aVal1)); + p1->DefineVar(_T("vb"), Variable(&aVal2)); + + // complex variables + Value cVal[3]; + cVal[0] = mup::cmplx_type(1, 1); + cVal[1] = mup::cmplx_type(2, 3); + cVal[2] = mup::cmplx_type(3, 4); + p1->DefineVar(_T("ca"), Variable(&cVal[0])); + p1->DefineVar(_T("cb"), Variable(&cVal[1])); + p1->DefineVar(_T("cc"), Variable(&cVal[2])); + + p1->SetExpr(a_str); + + fVal[0] = p1->Eval(); + + // Test copy and assignement operators + std::vector vParser; + vParser.push_back(*p1); // Push p1 into the vector + ParserX p2 = vParser[0]; // take parser from vector + + // destroy the originals from p2 + vParser.clear(); // delete the vector + p1.reset(0); // delete the original + + fVal[1] = p2.Eval(); // If copy constructions does not work + // we may see a crash here + + // Test assignement operator + // additionally disable Optimizer this time + ParserX p3; + p3 = p2; + fVal[2] = p3.Eval(); // If assignment does not work + // we may see a crash here + + // Calculating a second time will parse from rpn rather than from + // string. The result must be the same... + fVal[3] = p3.Eval(); + + // Calculate yet another time. There is the possibility of + // changing variables as a side effect of expression + // evaluation. So there are really bugs that could make this fail... + fVal[4] = p3.Eval(); + + // Check i number of used variables is correct + if (nExprVar != -1) + { + std::size_t n2 = p2.GetExprVar().size(); + std::size_t n3 = p3.GetExprVar().size(); + + if (n2 + n3 != 2 * n2 || int(n2) != nExprVar) + { + *m_stream << _T(" Number of expression variables is incorrect. (expected: ") + << nExprVar << _T("; detected: ") << n2 << _T(")"); + } + } + + // Check the three results + // 1.) computed results must have identic type + char_type cType = fVal[0].GetType(); + bool bStat = cType == fVal[1].GetType() && + cType == fVal[2].GetType() && + cType == fVal[3].GetType() && + cType == fVal[4].GetType(); + if (!bStat) + { + *m_stream << _T("\n ") << a_str << _T(" : inconsistent result type (") + << fVal[0].GetType() << _T(", ") + << fVal[1].GetType() << _T(", ") + << fVal[2].GetType() << _T(", ") + << fVal[3].GetType() << _T(", ") + << fVal[4].GetType() << _T(")"); + return 1; + } + + if ((cType == 'c' || a_val.GetType() == 'c') && cType != a_val.GetType()) + { + *m_stream << _T("\n ") << a_str << _T(" : Complex value sliced!"); + return 1; + } + + // Compare the results + switch (cType) + { + case 'i': + case 'b': + case 's': bStat = (a_val == fVal[0] && + a_val == fVal[1] && + a_val == fVal[2] && + a_val == fVal[3] && + a_val == fVal[4]); + break; + + // We need more attention for comaring float values due to floating point + // inaccuracies. + case 'f': + { + bStat = true; + int num = sizeof(fVal) / sizeof(Value); + for (int i = 0; i < num; ++i) + bStat &= (fabs(a_val.GetFloat() - fVal[i].GetFloat()) <= fabs(fVal[i].GetFloat()*0.0001)); + } + break; + + case 'c': + { + bStat = true; + int num = sizeof(fVal) / sizeof(Value); + for (int i = 0; i < num; ++i) + { + bStat &= (fabs(a_val.GetFloat() - fVal[i].GetFloat()) <= std::max((float_type)1e-15, fabs(fVal[i].GetFloat() * (float_type)0.0000001))); + bStat &= (fabs(a_val.GetImag() - fVal[i].GetImag()) <= std::max((float_type)1e-15, fabs(fVal[i].GetImag() * (float_type)0.0000001))); + } + } + break; + + case 'm': + { + bStat = true; + int num = sizeof(fVal) / sizeof(Value); + + for (int i = 0; i < num; ++i) + { + struct CheckArray + { + CheckArray() + {} + + bool Check(IValue &v1, IValue &v2) + { + if (v1.GetType() != v2.GetType()) + return false; + + if (v1.GetRows() != v2.GetRows()) + return false; + + if (v1.IsMatrix()) + { + for (int i = 0; i < v1.GetRows(); ++i) + { + for (int j = 0; j < v1.GetCols(); ++j) + { + if (!Check(v1.At(i, j), v2.At(i, j))) + return false; + } + } + + return true; + } + else + { + return (fabs(v1.GetFloat() - v2.GetFloat()) <= std::max((float_type)1e-15, fabs(v1.GetFloat() * (float_type)0.0000001))); + } + } + } checker; + + bStat = checker.Check(a_val, fVal[i]); + if (!bStat) + break; + } + } + break; + + default: + throw std::runtime_error("Parser return value has an unexpected typecode."); + } + + iRet = (bStat == a_fPass) ? 0 : 1; + } + catch (ParserError &e) + { + *m_stream << _T("\n ") << a_str << _T(" : ") << e.GetMsg(); + return 1; + } + catch (std::exception &e) + { + *m_stream << _T("\n ") << a_str << _T(" : ") << e.what() << _T("\n"); + return 1; + } + catch (...) + { + *m_stream << _T("\n \"") << a_str << _T("\" : ") << _T("Unexpected Eception"); + return 1; + } + + if (iRet) + { + *m_stream << _T("\n ") << a_str << _T(" : ") << _T("(at least one incorrect result ") + << fVal[0] << _T(", ") + << fVal[1] << _T(", ") + << fVal[2] << _T(", ") + << fVal[3] << _T(", ") + << fVal[4] << _T("; expected=") << a_val << _T(")"); + } + + return iRet; +} + +//--------------------------------------------------------------------------- +/** \brief Internal error in test class Test is going to be aborted. */ +void ParserTester::Abort() const +{ + *m_stream << _T("\nTest failed (internal error in test class)") << endl; + while (!getchar()); + exit(-1); +} + +//--------------------------------------------------------------------------- +void ParserTester::Assessment(int a_iNumErr) const +{ + if (a_iNumErr == 0) + *m_stream << _T("passed") << endl; + else + *m_stream << _T("\n failed with ") << a_iNumErr << _T(" errors") << endl; +} +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpTokenReader.cpp b/src/third-party/headers/muparserx/mpTokenReader.cpp new file mode 100644 index 0000000000..87b698644d --- /dev/null +++ b/src/third-party/headers/muparserx/mpTokenReader.cpp @@ -0,0 +1,1013 @@ +/** \file + \brief Implementation of the token reader used to break the expression string up + into tokens. + +
+				__________                                 ____  ___
+	 _____  __ _\______   \_____ _______  ______ __________\   \/  /
+	/     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
+	|  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
+	|__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+		  \/                     \/           \/     \/           \_/
+	Copyright (C) 2016, Ingo Berg
+	All rights reserved.
+
+	Redistribution and use in source and binary forms, with or without
+	modification, are permitted provided that the following conditions are met:
+
+	* Redistributions of source code must retain the above copyright notice,
+	this list of conditions and the following disclaimer.
+	* Redistributions in binary form must reproduce the above copyright notice,
+	this list of conditions and the following disclaimer in the documentation
+	and/or other materials provided with the distribution.
+
+	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+	IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+	WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+	POSSIBILITY OF SUCH DAMAGE.
+	
+ */ + +#include "mpTokenReader.h" + +#include + +#include "mpParserBase.h" +#include "mpIValReader.h" +#include "mpIfThenElse.h" +#include "mpScriptTokens.h" +#include "mpOprtIndex.h" +#include "mpOprtMatrix.h" + +MUP_NAMESPACE_START + +//--------------------------------------------------------------------------- +/** \brief Copy constructor. + \sa Assign + \throw nothrow + */ + TokenReader::TokenReader(const TokenReader &a_Reader) +{ + Assign(a_Reader); +} + +//--------------------------------------------------------------------------- +/** \brief Assignement operator. + \param a_Reader Object to copy to this token reader. + \throw nothrow + + Self assignement will be suppressed otherwise #Assign is called. + */ +TokenReader& TokenReader::operator=(const TokenReader &a_Reader) +{ + if (&a_Reader != this) + Assign(a_Reader); + + return *this; +} + +//--------------------------------------------------------------------------- +/** \brief Assign state of a token reader to this token reader. + \param a_Reader Object from which the state should be copied. + \throw nothrow + */ +void TokenReader::Assign(const TokenReader &obj) +{ + m_pParser = obj.m_pParser; + m_sExpr = obj.m_sExpr; + m_nPos = obj.m_nPos; + m_nNumBra = obj.m_nNumBra; + m_nNumIndex = obj.m_nNumIndex; + m_nNumCurly = obj.m_nNumCurly; + m_nNumIfElse = obj.m_nNumIfElse; + m_nSynFlags = obj.m_nSynFlags; + m_UsedVar = obj.m_UsedVar; + m_pVarDef = obj.m_pVarDef; + m_pPostOprtDef = obj.m_pPostOprtDef; + m_pInfixOprtDef = obj.m_pInfixOprtDef; + m_pOprtDef = obj.m_pOprtDef; + m_pFunDef = obj.m_pFunDef; + m_pConstDef = obj.m_pConstDef; + m_pDynVarShadowValues = obj.m_pDynVarShadowValues; + m_vTokens = obj.m_vTokens; + + // Reader klassen klonen + DeleteValReader(); + std::size_t i, iSize = obj.m_vValueReader.size(); + for (i = 0; i < iSize; ++i) + { + m_vValueReader.push_back(obj.m_vValueReader[i]->Clone(this)); + } +} + +//--------------------------------------------------------------------------- +/** \brief Constructor. + + Create a Token reader and bind it to a parser object. + + \pre [assert] a_pParser may not be nullptr + \post #m_pParser==a_pParser + \param a_pParent Parent parser object of the token reader. + */ +TokenReader::TokenReader(ParserXBase *a_pParent) + :m_pParser(a_pParent) + , m_sExpr() + , m_nPos(0) + , m_nNumBra(0) + , m_nNumIndex(0) + , m_nNumCurly(0) + , m_nNumIfElse(0) + , m_nSynFlags(0) + , m_vTokens() + , m_eLastTokCode(cmUNKNOWN) + , m_pFunDef(nullptr) + , m_pOprtDef(nullptr) + , m_pInfixOprtDef(nullptr) + , m_pPostOprtDef(nullptr) + , m_pConstDef(nullptr) + , m_pDynVarShadowValues(nullptr) + , m_pVarDef(nullptr) + , m_vValueReader() + , m_UsedVar() + , m_fZero(0) +{ + assert(m_pParser); + SetParent(m_pParser); +} + +//--------------------------------------------------------------------------- +/** \brief Destructor (trivial). + + \throw nothrow + */ +TokenReader::~TokenReader() +{ + DeleteValReader(); +} + +//--------------------------------------------------------------------------- +void TokenReader::DeleteValReader() +{ + int iSize = (int)m_vValueReader.size(); + for (int i = 0; i < iSize; ++i) + delete m_vValueReader[i]; + + m_vValueReader.clear(); +} + +//--------------------------------------------------------------------------- +/** \brief Create instance of a ParserTokenReader identical with this + and return its pointer. + + This is a factory method the calling function must take care of the object destruction. + + \return A new ParserTokenReader object. + \throw nothrow + */ +TokenReader* TokenReader::Clone(ParserXBase *a_pParent) const +{ + std::unique_ptr ptr(new TokenReader(*this)); + ptr->SetParent(a_pParent); + return ptr.release(); +} + +//--------------------------------------------------------------------------- +void TokenReader::AddValueReader(IValueReader *a_pReader) +{ + a_pReader->SetParent(this); + m_vValueReader.push_back(a_pReader); +} + +//--------------------------------------------------------------------------- +void TokenReader::AddSynFlags(int flag) +{ + m_nSynFlags |= flag; +} + +//--------------------------------------------------------------------------- +const TokenReader::token_buf_type& TokenReader::GetTokens() const +{ + return m_vTokens; +} + +//--------------------------------------------------------------------------- +/** \brief Return the current position of the token reader in the formula string. + + \return #m_nPos + \throw nothrow + */ +int TokenReader::GetPos() const +{ + return m_nPos; +} + +//--------------------------------------------------------------------------- +/** \brief Return a reference to the formula. + + \return #m_sExpr + \throw nothrow + */ +const string_type& TokenReader::GetExpr() const +{ + return m_sExpr; +} + +//--------------------------------------------------------------------------- +/** \brief Return a map containing the used variables only. */ +const var_maptype& TokenReader::GetUsedVar() const +{ + return m_UsedVar; +} + +//--------------------------------------------------------------------------- +/** \brief Initialize the token Reader. + + Sets the expression position index to zero and set Syntax flags to + default for initial parsing. + */ +void TokenReader::SetExpr(const string_type &a_sExpr) +{ + m_sExpr = a_sExpr; // + string_type(_T(" ")); + ReInit(); +} + +//--------------------------------------------------------------------------- +/** \brief Reset the token reader to the start of the formula. + \post #m_nPos==0, #m_nSynFlags = noOPT | noBC | noPOSTOP | noSTR + \throw nothrow + \sa ESynCodes + + The syntax flags will be reset to a value appropriate for the + start of a formula. + */ +void TokenReader::ReInit() +{ + m_nPos = 0; + m_nNumBra = 0; + m_nNumIndex = 0; + m_nNumCurly = 0; + m_nNumIfElse = 0; + m_nSynFlags = noOPT | noBC | noCBC | noPFX | noCOMMA | noIO | noIC | noIF | noELSE; + m_UsedVar.clear(); + m_eLastTokCode = cmUNKNOWN; + m_vTokens.clear(); +} + +//--------------------------------------------------------------------------- +const ptr_tok_type& TokenReader::Store(const ptr_tok_type &t, int token_pos) +{ + m_eLastTokCode = t->GetCode(); + t->SetExprPos(token_pos); + m_vTokens.push_back(t); + return t; +} + +//--------------------------------------------------------------------------- +void TokenReader::SkipCommentsAndWhitespaces() +{ + bool bSkip = true; + while (m_nPos < static_cast(m_sExpr.length()) && bSkip) + { + switch (m_sExpr[m_nPos]) + { + // skip comments + case '#': + { + std::size_t i = m_sExpr.find_first_of('\n', m_nPos + 1); + m_nPos = static_cast((i != string_type::npos) ? i : m_sExpr.length()); + } + break; + + // skip whitespaces + case ' ': + ++m_nPos; + break; + + default: + bSkip = false; + } // switch + } // while comment or whitespace +} + +//--------------------------------------------------------------------------- +/** \brief Read the next token from the string. */ +ptr_tok_type TokenReader::ReadNextToken() +{ + assert(m_pParser); + + SkipCommentsAndWhitespaces(); + + int token_pos = m_nPos; + ptr_tok_type pTok; + + // Check for end of expression + if (IsEOF(pTok)) + return Store(pTok, token_pos); + + if (IsNewline(pTok)) + return Store(pTok, token_pos); + + if (!(m_nSynFlags & noOPT) && IsOprt(pTok)) + return Store(pTok, token_pos); // Check for user defined binary operator + + if (!(m_nSynFlags & noIFX) && IsInfixOpTok(pTok)) + return Store(pTok, token_pos); // Check for unary operators + + if (IsValTok(pTok)) + return Store(pTok, token_pos); // Check for values / constant tokens + + if (IsBuiltIn(pTok)) + return Store(pTok, token_pos); // Check built in operators / tokens + + if (IsVarOrConstTok(pTok)) + return Store(pTok, token_pos); // Check for variable tokens + + if (IsFunTok(pTok)) + return Store(pTok, token_pos); + + if (!(m_nSynFlags & noPFX) && IsPostOpTok(pTok)) + return Store(pTok, token_pos); // Check for unary operators + + // 2.) We have found no token, maybe there is a token that we don't expect here. + // Again call the Identifier functions but this time only those we don't expect + // to find. + if ((m_nSynFlags & noOPT) && IsOprt(pTok)) + return Store(pTok, token_pos); // Check for user defined binary operator + + if ((m_nSynFlags & noIFX) && IsInfixOpTok(pTok)) + return Store(pTok, token_pos); // Check for unary operators + + if ((m_nSynFlags & noPFX) && IsPostOpTok(pTok)) + return Store(pTok, token_pos); // Check for unary operators + // + + // Now we are in trouble because there is something completely unknown.... + + // Check the string for an undefined variable token. This is done + // only if a flag is set indicating to ignore undefined variables. + // This is a way to conditionally avoid an error if undefined variables + // occur. The GetExprVar function must supress the error for undefined + // variables in order to collect all variable names including the + // undefined ones. + if ((m_pParser->m_bIsQueryingExprVar || m_pParser->m_bAutoCreateVar) && IsUndefVarTok(pTok)) + return Store(pTok, token_pos); + + // Check for unknown token + // + // !!! From this point on there is no exit without an exception possible... + // + string_type sTok; + int iEnd = ExtractToken(m_pParser->ValidNameChars(), sTok, m_nPos); + + ErrorContext err; + err.Errc = ecUNASSIGNABLE_TOKEN; + err.Expr = m_sExpr; + err.Pos = m_nPos; + + if (iEnd != m_nPos) + err.Ident = sTok; + else + err.Ident = m_sExpr.substr(m_nPos); + + throw ParserError(err); +} + +//--------------------------------------------------------------------------- +void TokenReader::SetParent(ParserXBase *a_pParent) +{ + m_pParser = a_pParent; + m_pFunDef = &a_pParent->m_FunDef; + m_pOprtDef = &a_pParent->m_OprtDef; + m_pInfixOprtDef = &a_pParent->m_InfixOprtDef; + m_pPostOprtDef = &a_pParent->m_PostOprtDef; + m_pVarDef = &a_pParent->m_varDef; + m_pConstDef = &a_pParent->m_valDef; + m_pDynVarShadowValues = &a_pParent->m_valDynVarShadow; +} + +//--------------------------------------------------------------------------- +/** \brief Extract all characters that belong to a certain charset. + \param a_szCharSet [in] Const char array of the characters allowed in the token. + \param a_strTok [out] The string that consists entirely of characters listed in a_szCharSet. + \param a_iPos [in] Position in the string from where to start reading. + \return The Position of the first character not listed in a_szCharSet. + \throw nothrow + */ +int TokenReader::ExtractToken(const char_type *a_szCharSet, + string_type &a_sTok, + int a_iPos) const +{ + int iEnd = (int)m_sExpr.find_first_not_of(a_szCharSet, a_iPos); + + if (iEnd == (int)string_type::npos) + iEnd = (int)m_sExpr.length(); + + if (iEnd != a_iPos) + a_sTok.assign(m_sExpr.begin() + a_iPos, m_sExpr.begin() + iEnd); + + return iEnd; +} + +//--------------------------------------------------------------------------- +/** \brief Check if a built in operator or other token can be found. +*/ +bool TokenReader::IsBuiltIn(ptr_tok_type &a_Tok) +{ + const char_type **pOprtDef = m_pParser->GetOprtDef(), + *szFormula = m_sExpr.c_str(); + int i; + + try + { + // Compare token with function and operator strings + // check string for operator/function + for (i = 0; pOprtDef[i]; i++) + { + std::size_t len(std::char_traits::length(pOprtDef[i])); + if (string_type(pOprtDef[i]) == string_type(szFormula + m_nPos, szFormula + m_nPos + len)) + { + switch (i) + { + case cmARG_SEP: + if (m_nSynFlags & noCOMMA) + throw ecUNEXPECTED_COMMA; + + m_nSynFlags = noBC | noCBC | noOPT | noEND | noNEWLINE | noCOMMA | noPFX | noIC | noIO | noIF | noELSE; + a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); + break; + + case cmELSE: + if (m_nSynFlags & noELSE) + throw ecMISPLACED_COLON; + + m_nNumIfElse--; + if (m_nNumIfElse < 0) + throw ecMISPLACED_COLON; + + m_nSynFlags = noBC | noCBC | noIO | noIC | noPFX | noEND | noNEWLINE | noCOMMA | noOPT | noIF | noELSE; + a_Tok = ptr_tok_type(new TokenIfThenElse(cmELSE)); + break; + + case cmIF: + if (m_nSynFlags & noIF) + throw ecUNEXPECTED_CONDITIONAL; + + m_nNumIfElse++; + m_nSynFlags = noBC | noCBC | noIO | noPFX | noIC | noEND | noNEWLINE | noCOMMA | noOPT | noIF | noELSE; + a_Tok = ptr_tok_type(new TokenIfThenElse(cmIF)); + break; + + case cmBO: + if (m_nSynFlags & noBO) + throw ecUNEXPECTED_PARENS; + + if (m_eLastTokCode == cmFUNC) + { + m_nSynFlags = noOPT | noEND | noNEWLINE | noCOMMA | noPFX | noIC | noIO | noIF | noELSE | noCBC; + } + else + { + m_nSynFlags = noBC | noOPT | noEND | noNEWLINE | noCOMMA | noPFX | noIC | noIO | noIF | noELSE | noCBC; + } + + m_nNumBra++; + a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); + break; + + case cmBC: + if (m_nSynFlags & noBC) + throw ecUNEXPECTED_PARENS; + + m_nSynFlags = noBO | noVAR | noVAL | noFUN | noIFX | noCBO; + m_nNumBra--; + + if (m_nNumBra < 0) + throw ecUNEXPECTED_PARENS; + + a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); + break; + + case cmIO: + if (m_nSynFlags & noIO) + throw ecUNEXPECTED_SQR_BRACKET; + + m_nSynFlags = noIC | noIO | noOPT | noPFX | noBC | noNEWLINE | noCBC | noCOMMA; + m_nNumIndex++; + a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); + break; + + case cmIC: + if (m_nSynFlags & noIC) + throw ecUNEXPECTED_SQR_BRACKET; + + m_nSynFlags = noBO | noIFX | noCBO; + m_nNumIndex--; + + if (m_nNumIndex < 0) + throw ecUNEXPECTED_SQR_BRACKET; + + a_Tok = ptr_tok_type(new OprtIndex()); + break; + + case cmCBO: + if (m_nSynFlags & noVAL) + throw ecUNEXPECTED_CURLY_BRACKET; + + m_nSynFlags = noCBC | noIC | noIO | noOPT | noPFX | noBC | noNEWLINE | noCOMMA | noIF; + m_nNumCurly++; + a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); + break; + + case cmCBC: + if (m_nSynFlags & noIC) + throw ecUNEXPECTED_CURLY_BRACKET; + + m_nSynFlags = noBO | noCBO | noIFX; + m_nNumCurly--; + + if (m_nNumCurly < 0) + throw ecUNEXPECTED_CURLY_BRACKET; + + a_Tok = ptr_tok_type(new OprtCreateArray()); + break; + + default: // The operator is listed in c_DefaultOprt, but not here. This is a bad thing... + throw ecINTERNAL_ERROR; + } // switch operator id + + m_nPos += (int)len; + return true; + } // if operator string found + } // end of for all operator strings + } + catch (EErrorCodes e) + { + ErrorContext err; + err.Errc = e; + err.Expr = m_sExpr; + err.Ident = pOprtDef[i]; + err.Pos = m_nPos; + throw ParserError(err); + } + + return false; +} + +//--------------------------------------------------------------------------- +/** \brief Check for End of expression +*/ +bool TokenReader::IsNewline(ptr_tok_type &a_Tok) +{ + // nicht nach: bionop, infixop, argumentseparator, + // erlaubt nach: Werten, variablen, schließenden klammern, schliessendem index + bool bRet(false); + try + { + if (m_sExpr[m_nPos] == '\n') + { + // Check if all brackets were closed + if (m_nSynFlags & noNEWLINE) + throw ecUNEXPECTED_NEWLINE; + + if (m_nNumBra > 0) + throw ecMISSING_PARENS; + + if (m_nNumIndex > 0) + throw ecMISSING_SQR_BRACKET; + + if (m_nNumCurly > 0) + throw ecMISSING_CURLY_BRACKET; + + if (m_nNumIfElse > 0) + throw(ecMISSING_ELSE_CLAUSE); + + m_nPos++; + m_nSynFlags = sfSTART_OF_LINE; + a_Tok = ptr_tok_type(new TokenNewline()); + bRet = true; + } + } + catch (EErrorCodes e) + { + ErrorContext err; + err.Errc = e; + err.Ident = _T(""); + err.Expr = m_sExpr; + err.Pos = m_nPos; + throw ParserError(err); + } + + return bRet; +} + +//--------------------------------------------------------------------------- +/** \brief Check for End of expression +*/ +bool TokenReader::IsEOF(ptr_tok_type &a_Tok) +{ + bool bRet(false); + try + { + if (m_sExpr.length() && m_nPos >= (int)m_sExpr.length()) + { + if (m_nSynFlags & noEND) + throw ecUNEXPECTED_EOF; + + if (m_nNumBra > 0) + throw ecMISSING_PARENS; + + if (m_nNumCurly > 0) + throw ecMISSING_CURLY_BRACKET; + + if (m_nNumIndex > 0) + throw ecMISSING_SQR_BRACKET; + + if (m_nNumIfElse > 0) + throw ecMISSING_ELSE_CLAUSE; + + m_nSynFlags = 0; + a_Tok = ptr_tok_type(new GenericToken(cmEOE)); + bRet = true; + } + } + catch (EErrorCodes e) + { + ErrorContext err; + err.Errc = e; + err.Ident = _T(""); + err.Expr = m_sExpr; + err.Pos = m_nPos; + throw ParserError(err); + } + + return bRet; +} + +//--------------------------------------------------------------------------- +/** \brief Check if a string position contains a unary infix operator. + \return true if a function token has been found false otherwise. + */ +bool TokenReader::IsInfixOpTok(ptr_tok_type &a_Tok) +{ + string_type sTok; + int iEnd = ExtractToken(m_pParser->ValidInfixOprtChars(), sTok, m_nPos); + + if (iEnd == m_nPos) + return false; + + try + { + // iteraterate over all infix operator strings + oprt_ifx_maptype::const_iterator item = m_pInfixOprtDef->begin(); + for (item = m_pInfixOprtDef->begin(); item != m_pInfixOprtDef->end(); ++item) + { + if (sTok.find(item->first) != 0) + continue; + + a_Tok = ptr_tok_type(item->second->Clone()); + m_nPos += (int)item->first.length(); + + if (m_nSynFlags & noIFX) + throw ecUNEXPECTED_OPERATOR; + + m_nSynFlags = noPFX | noIFX | noOPT | noBC | noIC | noIO | noEND | noCOMMA | noNEWLINE | noIF | noELSE; + return true; + } + + return false; + } + catch (EErrorCodes e) + { + ErrorContext err; + err.Errc = e; + err.Pos = m_nPos; + err.Ident = a_Tok->GetIdent(); + err.Expr = m_sExpr; + throw ParserError(err); + } +} + +//--------------------------------------------------------------------------- +/** \brief Check expression for function tokens. */ +bool TokenReader::IsFunTok(ptr_tok_type &a_Tok) +{ + if (m_pFunDef->size() == 0) + return false; + + string_type sTok; + int iEnd = ExtractToken(m_pParser->ValidNameChars(), sTok, m_nPos); + if (iEnd == m_nPos) + return false; + + try + { + fun_maptype::iterator item = m_pFunDef->find(sTok); + if (item == m_pFunDef->end()) + return false; + + m_nPos = (int)iEnd; + a_Tok = ptr_tok_type(item->second->Clone()); + a_Tok->Compile(_T("xxx")); + + if (m_nSynFlags & noFUN) + throw ecUNEXPECTED_FUN; + + m_nSynFlags = sfALLOW_NONE ^ noBO; + return true; + } + catch (EErrorCodes e) + { + ErrorContext err; + err.Errc = e; + err.Pos = m_nPos - (int)a_Tok->GetIdent().length(); + err.Ident = a_Tok->GetIdent(); + err.Expr = m_sExpr; + throw ParserError(err); + } +} + +//--------------------------------------------------------------------------- +/** \brief Check if a string position contains a unary post value operator. */ +bool TokenReader::IsPostOpTok(ptr_tok_type &a_Tok) +{ + if (m_nSynFlags & noPFX) + { + // Only look for postfix operators if they are allowed at the given position. + // This will prevent conflicts with variable names such as: + // "sin(n)" where n is the postfix for "nano" + return false; + // + } + + // Tricky problem with equations like "3m+5": + // m is a postfix operator, + is a valid sign for postfix operators and + // for binary operators parser detects "m+" as operator string and + // finds no matching postfix operator. + // + // This is a special case so this routine slightly differs from the other + // token readers. + + // Test if there could be a postfix operator + string_type sTok; + int iEnd = ExtractToken(m_pParser->ValidOprtChars(), sTok, m_nPos); + if (iEnd == m_nPos) + return false; + + try + { + // iteraterate over all postfix operator strings + oprt_pfx_maptype::const_iterator item; + for (item = m_pPostOprtDef->begin(); item != m_pPostOprtDef->end(); ++item) + { + if (sTok.find(item->first) != 0) + continue; + + a_Tok = ptr_tok_type(item->second->Clone()); + m_nPos += (int)item->first.length(); + + if (m_nSynFlags & noPFX) + throw ecUNEXPECTED_OPERATOR; + + m_nSynFlags = noVAL | noVAR | noFUN | noBO | noPFX /*| noIO*/ | noIF; + return true; + } + + return false; + } + catch (EErrorCodes e) + { + ErrorContext err; + err.Errc = e; + err.Pos = m_nPos - (int)a_Tok->GetIdent().length(); + err.Ident = a_Tok->GetIdent(); + err.Expr = m_sExpr; + throw ParserError(err); + } +} + +//--------------------------------------------------------------------------- +/** \brief Check if a string position contains a binary operator. */ +bool TokenReader::IsOprt(ptr_tok_type &a_Tok) +{ + string_type sTok; + int iEnd = ExtractToken(m_pParser->ValidOprtChars(), sTok, m_nPos); + if (iEnd == m_nPos) + return false; + + oprt_bin_maptype::reverse_iterator item; + try + { + // Note: + // All tokens in oprt_bin_maptype are have been sorted by their length + // Long operators must come first! Otherwise short names (like: "add") that + // are part of long token names (like: "add123") will be found instead + // of the long ones. + // Length sorting is done with ascending length so we use a reverse iterator here. + for (item = m_pOprtDef->rbegin(); item != m_pOprtDef->rend(); ++item) + { + if (sTok.find(item->first) != 0) + continue; + + // operator found, check if we expect one... + if (m_nSynFlags & noOPT) + { + // An operator was found but is not expected to occur at + // this position of the formula, maybe it is an infix + // operator, not a binary operator. Both operator types + // can use the same characters in their identifiers. + if (IsInfixOpTok(a_Tok)) + return true; + + // nope, it's no infix operator and we dont expect + // an operator + throw ecUNEXPECTED_OPERATOR; + } + else + { + a_Tok = ptr_tok_type(item->second->Clone()); + + m_nPos += (int)a_Tok->GetIdent().length(); + m_nSynFlags = noBC | noIO | noIC | noOPT | noCOMMA | noEND | noNEWLINE | noPFX | noIF | noELSE; + return true; + } + } + + return false; + } + catch (EErrorCodes e) + { + ErrorContext err; + err.Errc = e; + err.Pos = m_nPos; // - (int)item->first.length(); + err.Ident = item->first; + err.Expr = m_sExpr; + throw ParserError(err); + } +} + +//--------------------------------------------------------------------------- +/** \brief Check whether the token at a given position is a value token. + + Value tokens are either values or constants. + + \param a_Tok [out] If a value token is found it will be placed here. + \return true if a value token has been found. + */ +bool TokenReader::IsValTok(ptr_tok_type &a_Tok) +{ + if (m_vValueReader.size() == 0) + return false; + + stringstream_type stream(m_sExpr.c_str() + m_nPos); + string_type sTok; + + try + { + // call the value recognition functions provided by the user + // Call user defined value recognition functions + int iSize = (int)m_vValueReader.size(); + Value val; + for (int i = 0; i < iSize; ++i) + { + int iStart = m_nPos; + if (m_vValueReader[i]->IsValue(m_sExpr.c_str(), m_nPos, val)) + { + sTok.assign(m_sExpr.c_str(), iStart, m_nPos); + if (m_nSynFlags & noVAL) + throw ecUNEXPECTED_VAL; + + m_nSynFlags = noVAL | noVAR | noFUN | noBO | noIFX | noIO; + a_Tok = ptr_tok_type(val.Clone()); + a_Tok->SetIdent(string_type(sTok.begin(), sTok.begin() + (m_nPos - iStart))); + return true; + } + } + } + catch (EErrorCodes e) + { + ErrorContext err; + err.Errc = e; + err.Pos = m_nPos; + err.Ident = sTok; + err.Expr = m_sExpr; + err.Pos = m_nPos - (int)sTok.length(); + throw ParserError(err); + } + + return false; +} + +//--------------------------------------------------------------------------- +/** \brief Check wheter a token at a given position is a variable token. + \param a_Tok [out] If a variable token has been found it will be placed here. + \return true if a variable token has been found. + */ +bool TokenReader::IsVarOrConstTok(ptr_tok_type &a_Tok) +{ + if (!m_pVarDef->size() && !m_pConstDef->size() && !m_pFunDef->size()) + return false; + + string_type sTok; + int iEnd; + try + { + iEnd = ExtractToken(m_pParser->ValidNameChars(), sTok, m_nPos); + if (iEnd == m_nPos || (sTok.size() > 0 && sTok[0] >= _T('0') && sTok[0] <= _T('9'))) + return false; + + // Check for variables + var_maptype::const_iterator item = m_pVarDef->find(sTok); + if (item != m_pVarDef->end()) + { + if (m_nSynFlags & noVAR) + throw ecUNEXPECTED_VAR; + + m_nPos = iEnd; + m_nSynFlags = noVAL | noVAR | noFUN | noBO | noIFX; + a_Tok = ptr_tok_type(item->second->Clone()); + a_Tok->SetIdent(sTok); + m_UsedVar[item->first] = item->second; // Add variable to used-var-list + return true; + } + + // Check for constants + item = m_pConstDef->find(sTok); + if (item != m_pConstDef->end()) + { + if (m_nSynFlags & noVAL) + throw ecUNEXPECTED_VAL; + + m_nPos = iEnd; + m_nSynFlags = noVAL | noVAR | noFUN | noBO | noIFX | noIO; + a_Tok = ptr_tok_type(item->second->Clone()); + a_Tok->SetIdent(sTok); + return true; + } + } + catch (EErrorCodes e) + { + ErrorContext err; + err.Errc = e; + err.Pos = m_nPos; + err.Ident = sTok; + err.Expr = m_sExpr; + throw ParserError(err); + } + + return false; +} + +//--------------------------------------------------------------------------- +bool TokenReader::IsComment() +{ + return false; +} + +//--------------------------------------------------------------------------- +/** \brief Check wheter a token at a given position is an undefined variable. + \param a_Tok [out] If a variable tom_pParser->m_vStringBufken has been found it will be placed here. + \return true if a variable token has been found. + \throw nothrow + */ +bool TokenReader::IsUndefVarTok(ptr_tok_type &a_Tok) +{ + string_type sTok; + int iEnd = ExtractToken(m_pParser->ValidNameChars(), sTok, m_nPos); + if (iEnd == m_nPos || (sTok.size() > 0 && sTok[0] >= _T('0') && sTok[0] <= _T('9'))) + return false; + + if (m_nSynFlags & noVAR) + { + ErrorContext err; + err.Errc = ecUNEXPECTED_VAR; + err.Ident = sTok; + err.Expr = m_sExpr; + err.Pos = m_nPos; + throw ParserError(err); + } + + // Create a variable token + if (m_pParser->m_bAutoCreateVar) + { + ptr_val_type val(new Value); // Create new value token + m_pDynVarShadowValues->push_back(val); // push to the vector of shadow values + a_Tok = ptr_tok_type(new Variable(val.Get())); // bind variable to the new value item + (*m_pVarDef)[sTok] = a_Tok; // add new variable to the variable list + } + else + a_Tok = ptr_tok_type(new Variable(nullptr)); // bind variable to empty variable + + a_Tok->SetIdent(sTok); + m_UsedVar[sTok] = a_Tok; // add new variable to used-var-list + + m_nPos = iEnd; + m_nSynFlags = noVAL | noVAR | noFUN | noBO | noIFX; + return true; +} +} // namespace mu diff --git a/src/third-party/headers/muparserx/mpValReader.cpp b/src/third-party/headers/muparserx/mpValReader.cpp new file mode 100644 index 0000000000..8add7b0095 --- /dev/null +++ b/src/third-party/headers/muparserx/mpValReader.cpp @@ -0,0 +1,347 @@ +/** \file + \brief Implementation of classes that interpret values in a string. + +
+                 __________                                 ____  ___
+      _____  __ _\______   \_____ _______  ______ __________\   \/  /
+     /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
+    |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
+    |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+          \/                     \/           \/     \/           \_/
+    Copyright (C) 2016, Ingo Berg
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions are met:
+
+    * Redistributions of source code must retain the above copyright notice,
+    this list of conditions and the following disclaimer.
+    * Redistributions in binary form must reproduce the above copyright notice,
+    this list of conditions and the following disclaimer in the documentation
+    and/or other materials provided with the distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+    IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+    
+ */ +#include "mpValReader.h" +#include "mpError.h" + + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------ +// +// Reader for floating point values +// +//------------------------------------------------------------------------------ + +DblValReader::DblValReader() +:IValueReader() +{} + +//------------------------------------------------------------------------------ +DblValReader::~DblValReader() +{} + +//------------------------------------------------------------------------------ +bool DblValReader::IsValue(const char_type *a_szExpr, int &a_iPos, Value &a_Val) +{ + stringstream_type stream(a_szExpr + a_iPos); + float_type fVal(0); + std::streamoff iEnd(0); + + stream >> fVal; + + if (stream.fail()) + return false; + + if (stream.eof()) + { + // This part sucks but tellg will return -1 if eof is set, + // so i need a special treatment for the case that the number + // just read here is the last part of the string + for (; a_szExpr[a_iPos] != 0; ++a_iPos); + } + else + { + iEnd = stream.tellg(); // Position after reading + assert(iEnd > 0); + a_iPos += (int)iEnd; + } + + // Finally i have to check if the next sign is the "i" for a imaginary unit + // if so this is an imaginary value + if (a_szExpr[a_iPos] == 'i') + { + a_Val = cmplx_type(0.0, fVal); + a_iPos++; + } + else + { + a_Val = cmplx_type(fVal, 0.0); + } + + return true; +} + +//------------------------------------------------------------------------------ +IValueReader* DblValReader::Clone(TokenReader *pTokenReader) const +{ + IValueReader *pReader = new DblValReader(*this); + pReader->SetParent(pTokenReader); + + return pReader; +} + +//------------------------------------------------------------------------------ +// +// Reader for boolean values +// +//------------------------------------------------------------------------------ + +BoolValReader::BoolValReader() + :IValueReader() +{} + +//------------------------------------------------------------------------------ +BoolValReader::~BoolValReader() +{} + +//------------------------------------------------------------------------------ +bool BoolValReader::IsValue(const char_type *a_szExpr, int &a_iPos, Value &a_Val) +{ + string_type sExpr(a_szExpr + a_iPos); + + if (sExpr.find(_T("true")) == 0) + { + a_Val = true; + a_iPos += 4; + return true; + } + else if (sExpr.find(_T("false")) == 0) + { + a_Val = false; + a_iPos += 5; + return true; + } + + return false; +} + +//------------------------------------------------------------------------------ +IValueReader* BoolValReader::Clone(TokenReader *pTokenReader) const +{ + IValueReader *pReader = new BoolValReader(*this); + pReader->SetParent(pTokenReader); + + return pReader; +} + +//------------------------------------------------------------------------------ +// +// Reader for hex values +// +//------------------------------------------------------------------------------ + +HexValReader::HexValReader() + :IValueReader() +{} + +//------------------------------------------------------------------------------ +/** \brief Try to read a hex value from a given position in the expression. + \param a_szExpr The Expression + \param [in/out] a_iPos The current position in the expression + \param [out] a_val The value that was read + + Hex values must start with a "0x" characters. The position a_iPos is advanded in case + a hex value was found. + */ +bool HexValReader::IsValue(const char_type *a_szExpr, int &a_iPos, Value &a_val) +{ + std::size_t len = std::char_traits::length(a_szExpr); + if (a_iPos >= (int)len || a_szExpr[a_iPos + 1] != 'x' || a_szExpr[a_iPos + 1] == 0 || a_szExpr[a_iPos] != '0') + return 0; + + unsigned iVal(0); + + stringstream_type::pos_type nPos(0); + stringstream_type ss(a_szExpr + a_iPos + 2); + ss >> std::hex >> iVal; + + if (ss.fail()) + return false; + + if (ss.eof()) + { + // This part sucks but tellg will return -1 if eof is set, + // so i need a special treatment for those cases. + for (; a_szExpr[a_iPos] != 0; ++a_iPos); + } + else + { + nPos = ss.tellg(); + assert(nPos > 0); + a_iPos += (int)(2 + nPos); + } + + a_val = (float_type)iVal; + return true; +} + +//------------------------------------------------------------------------------ +IValueReader* HexValReader::Clone(TokenReader *pTokenReader) const +{ + IValueReader *pReader = new HexValReader(*this); + pReader->SetParent(pTokenReader); + return pReader; +} + +//------------------------------------------------------------------------------ +// +// Reader for binary values +// +//------------------------------------------------------------------------------ + +BinValReader::BinValReader() + :IValueReader() +{} + +//------------------------------------------------------------------------------ +BinValReader::~BinValReader() +{} + +//------------------------------------------------------------------------------ +bool BinValReader::IsValue(const char_type *a_szExpr, int &a_iPos, Value &a_Val) +{ + const char_type *szExpr = a_szExpr + a_iPos; + + if (szExpr[0] != '0' || (szExpr[1] != 'b' && szExpr[1] != 'B')) + return false; + + // Number of bits hardcoded to 32, i can't + // store 64 bit integers in double values without + // loss. There is no point in accepting them. + unsigned iVal = 0, iBits = 32 /*sizeof(iVal)*8*/, i; + for (i = 0; (szExpr[i + 2] == '0' || szExpr[i + 2] == '1') && i <= iBits; ++i) + { + iVal |= (unsigned)(szExpr[i + 2] == '1') << ((iBits - 1) - i); + } + + if (i == 0) + return false; + + if (i > iBits) + { + throw ParserError(_T("Binary to integer conversion error (overflow).")); + } + + a_Val = (float_type)((int)(iVal >> (iBits - i))); + a_iPos += i + 2; + + return true; +} + +//------------------------------------------------------------------------------ +IValueReader* BinValReader::Clone(TokenReader *pTokenReader) const +{ + IValueReader *pReader = new BinValReader(*this); + pReader->SetParent(pTokenReader); + + return pReader; +} + +//------------------------------------------------------------------------------ +// +// Reader for string values +// +//------------------------------------------------------------------------------ + +StrValReader::StrValReader() + :IValueReader() +{} + +//------------------------------------------------------------------------------ +StrValReader::~StrValReader() +{} + +//------------------------------------------------------------------------------ +string_type StrValReader::Unescape(const char_type *szExpr, int &nPos) +{ + string_type out; + bool bEscape = false; + + for (char_type c = szExpr[nPos]; c != 0; c = szExpr[++nPos]) + { + switch (c) + { + case '\\': + if (!bEscape) + { + bEscape = true; + break; + } + [[gnu::fallthrough]]; + + case '"': + if (!bEscape) + { + ++nPos; + return out; + } + [[gnu::fallthrough]]; + + default: + if (bEscape) + { + switch (c) + { + case 'n': out += '\n'; break; + case 'r': out += '\r'; break; + case 't': out += '\t'; break; + case '"': out += '\"'; break; + case '\\': out += '\\'; break; + default: + throw ParserError(ErrorContext(ecUNKNOWN_ESCAPE_SEQUENCE, nPos)); + } + + bEscape = false; + } + else + { + out += c; + } + } + } + + throw ParserError(ErrorContext(ecUNTERMINATED_STRING, nPos)); +} + +//------------------------------------------------------------------------------ +bool StrValReader::IsValue(const char_type *a_pszExpr, int &a_iPos, Value &a_Val) +{ + const char_type *szExpr = a_pszExpr + a_iPos; + if (szExpr[0] != '"') + return false; + + a_Val = Unescape(a_pszExpr, ++a_iPos); + return true; +} + +//------------------------------------------------------------------------------ +IValueReader* StrValReader::Clone(TokenReader *pTokenReader) const +{ + IValueReader *pReader = new StrValReader(*this); + pReader->SetParent(pTokenReader); + + return pReader; +} +} // namespace mu diff --git a/src/third-party/headers/muparserx/mpValue.cpp b/src/third-party/headers/muparserx/mpValue.cpp new file mode 100644 index 0000000000..69b39227cb --- /dev/null +++ b/src/third-party/headers/muparserx/mpValue.cpp @@ -0,0 +1,804 @@ +/* +
+             __________                                 ____  ___
+  _____  __ _\______   \_____ _______  ______ __________\   \/  /
+ /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
+|  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
+|__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+      \/                     \/           \/     \/           \_/
+Copyright (C) 2016, Ingo Berg
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice,
+this list of conditions and the following disclaimer.
+* Redistributions in binary form must reproduce the above copyright notice,
+this list of conditions and the following disclaimer in the documentation
+and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
+INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+POSSIBILITY OF SUCH DAMAGE.
+
+*/ +#include "mpValue.h" +#include "mpError.h" +#include "mpValueCache.h" + + +MUP_NAMESPACE_START + +//------------------------------------------------------------------------------ +/** \brief Construct an empty value object of a given type. + \param cType The type of the value to construct (default='v'). + */ + Value::Value(char_type cType) + :IValue(cmVAL) + , m_val(0, 0) + , m_psVal(nullptr) + , m_pvVal(nullptr) + , m_cType(cType) + , m_iFlags(flNONE) + , m_pCache(nullptr) +{ + // strings and arrays must allocate their memory + switch (cType) + { + case 's': m_psVal = new string_type(); break; + case 'm': m_pvVal = new matrix_type(0, Value(0.0)); break; + } +} + +//--------------------------------------------------------------------------- +Value::Value(int_type a_iVal) + :IValue(cmVAL) + ,m_val((float_type)a_iVal, 0) + ,m_psVal(nullptr) + ,m_pvVal(nullptr) + ,m_cType('i') + ,m_iFlags(flNONE) + ,m_pCache(nullptr) +{} + +//--------------------------------------------------------------------------- +Value::Value(bool_type a_bVal) + :IValue(cmVAL) + , m_val((float_type)a_bVal, 0) + , m_psVal(nullptr) + , m_pvVal(nullptr) + , m_cType('b') + , m_iFlags(flNONE) + , m_pCache(nullptr) +{} + +//--------------------------------------------------------------------------- +Value::Value(string_type a_sVal) + :IValue(cmVAL) + , m_val() + , m_psVal(new string_type(a_sVal)) + , m_pvVal(nullptr) + , m_cType('s') + , m_iFlags(flNONE) + , m_pCache(nullptr) +{} + +//--------------------------------------------------------------------------- +Value::Value(int_type array_size, float_type v) + :IValue(cmVAL) + , m_val() + , m_psVal(nullptr) + , m_pvVal(new matrix_type(array_size, Value(v))) + , m_cType('m') + , m_iFlags(flNONE) + , m_pCache(nullptr) +{} + +//--------------------------------------------------------------------------- +/** \brief Create a m x n matrix +*/ +Value::Value(int_type m, int_type n, float_type v) + :IValue(cmVAL) + , m_val() + , m_psVal(nullptr) + , m_pvVal(new matrix_type(m, n, Value(v))) + , m_cType('m') + , m_iFlags(flNONE) + , m_pCache(nullptr) +{} + +//--------------------------------------------------------------------------- +Value::Value(const char_type *a_szVal) + :IValue(cmVAL) + , m_val() + , m_psVal(new string_type(a_szVal)) + , m_pvVal(nullptr) + , m_cType('s') + , m_iFlags(flNONE) + , m_pCache(nullptr) +{} + +//--------------------------------------------------------------------------- +Value::Value(const cmplx_type &v) + :IValue(cmVAL) + , m_val(v) + , m_psVal(nullptr) + , m_pvVal(nullptr) + , m_cType('c') + , m_iFlags(flNONE) + , m_pCache(nullptr) +{ + if ((m_val.real() == (int_type)m_val.real()) && (m_val.imag() == 0)) + m_cType = 'i'; + else + m_cType = (m_val.imag() == 0) ? 'f' : 'c'; +} + +//--------------------------------------------------------------------------- +Value::Value(float_type val) + :IValue(cmVAL) + , m_val(val, 0) + , m_psVal(nullptr) + , m_pvVal(nullptr) + , m_cType((val == (int_type)val) ? 'i' : 'f') + , m_iFlags(flNONE) + , m_pCache(nullptr) +{} + +//--------------------------------------------------------------------------- +Value::Value(const matrix_type &val) + :IValue(cmVAL) + , m_val() + , m_psVal(nullptr) + , m_pvVal(new matrix_type(val)) + , m_cType('m') + , m_iFlags(flNONE) + , m_pCache(nullptr) +{} + +//--------------------------------------------------------------------------- +Value::Value(const Value &a_Val) + :IValue(cmVAL) + , m_psVal(nullptr) + , m_pvVal(nullptr) + , m_pCache(nullptr) +{ + Assign(a_Val); +} + +//--------------------------------------------------------------------------- +Value::Value(const IValue &a_Val) + :IValue(cmVAL) + , m_psVal(nullptr) + , m_pvVal(nullptr) + , m_pCache(nullptr) +{ + Reset(); + + switch (a_Val.GetType()) + { + case 'i': + case 'f': + case 'b': m_val = cmplx_type(a_Val.GetFloat(), 0); + break; + + + case 'c': m_val = cmplx_type(a_Val.GetFloat(), a_Val.GetImag()); + break; + + case 's': if (!m_psVal) + m_psVal = new string_type(a_Val.GetString()); + else + *m_psVal = a_Val.GetString(); + break; + + case 'm': if (!m_pvVal) + m_pvVal = new matrix_type(a_Val.GetArray()); + else + *m_pvVal = a_Val.GetArray(); + break; + + case 'v': break; + default: MUP_FAIL(INVALID_TYPE_CODE); + } + + m_cType = a_Val.GetType(); +} + +//--------------------------------------------------------------------------- +Value& Value::operator=(const Value &a_Val) +{ + Assign(a_Val); + return *this; +} + +//--------------------------------------------------------------------------- +/** \brief Return the matrix element at row col. + + Row and col are the indices of the matrix. If this element does not + represent a matrix row and col must be 0 otherwise an index out of bound error + is thrown. + */ +IValue& Value::At(const IValue &row, const IValue &col) +{ + if (!row.IsInteger() || !col.IsInteger()) + { + ErrorContext errc(ecTYPE_CONFLICT_IDX, GetExprPos()); + errc.Type1 = (!row.IsInteger()) ? row.GetType() : col.GetType(); + errc.Type2 = 'i'; + throw ParserError(errc); + } + + int_type nRow = row.GetInteger(), + nCol = col.GetInteger(); + return At(nRow, nCol); +} + +//--------------------------------------------------------------------------- +IValue& Value::At(int nRow, int nCol) +{ + if (IsMatrix()) + { + if (nRow >= m_pvVal->GetRows() || nCol >= m_pvVal->GetCols() || nRow < 0 || nCol < 0) + throw ParserError(ErrorContext(ecINDEX_OUT_OF_BOUNDS, -1, GetIdent())); + + return m_pvVal->At(nRow, nCol); + } + else if (nRow == 0 && nCol == 0) + { + return *this; + } + else + throw ParserError(ErrorContext(ecINDEX_OUT_OF_BOUNDS)); +} + +//--------------------------------------------------------------------------- +Value::~Value() +{ + delete m_psVal; + delete m_pvVal; +} + +//--------------------------------------------------------------------------- +IToken* Value::Clone() const +{ + return new Value(*this); +} + +//--------------------------------------------------------------------------- +Value* Value::AsValue() +{ + return this; +} + +//--------------------------------------------------------------------------- +/** \brief Copy constructor. */ +void Value::Assign(const Value &ref) +{ + if (this == &ref) + return; + + m_val = ref.m_val; + m_cType = ref.m_cType; + m_iFlags = ref.m_iFlags; + + // allocate room for a string + if (ref.m_psVal) + { + if (!m_psVal) + m_psVal = new string_type(*ref.m_psVal); + else + *m_psVal = *ref.m_psVal; + } + else + { + delete m_psVal; + m_psVal = nullptr; + } + + // allocate room for a vector + if (ref.m_pvVal) + { + if (m_pvVal == nullptr) + m_pvVal = new matrix_type(*ref.m_pvVal); + else + *m_pvVal = *ref.m_pvVal; + } + else + { + delete m_pvVal; + m_pvVal = nullptr; + } + + // Do NOT access ref beyound this point! If you do, "unboxing" of + // a 1 x 1 matrix using: + // + // this->Assign(m_pvVal->At(0,0)); + // + // will blow up in your face since ref will become invalid at them very + // moment you delete m_pvVal! +} + +//--------------------------------------------------------------------------- +void Value::Reset() +{ + m_val = cmplx_type(0, 0); + + delete m_psVal; + m_psVal = nullptr; + + delete m_pvVal; + m_pvVal = nullptr; + + m_cType = 'f'; + m_iFlags = flNONE; +} + +//--------------------------------------------------------------------------- +IValue& Value::operator=(bool val) +{ + m_val = cmplx_type((float_type)val, 0); + + delete m_psVal; + m_psVal = nullptr; + + delete m_pvVal; + m_pvVal = nullptr; + + m_cType = 'b'; + m_iFlags = flNONE; + return *this; +} + +//--------------------------------------------------------------------------- +IValue& Value::operator=(int_type a_iVal) +{ + m_val = cmplx_type(a_iVal,0); + + delete m_psVal; + m_psVal = nullptr; + + delete m_pvVal; + m_pvVal = nullptr; + + m_cType = 'i'; + m_iFlags = flNONE; + return *this; +} + +//--------------------------------------------------------------------------- +IValue& Value::operator=(float_type val) +{ + m_val = cmplx_type(val, 0); + + delete m_psVal; + m_psVal = nullptr; + + delete m_pvVal; + m_pvVal = nullptr; + + m_cType = (val == (int_type)val) ? 'i' : 'f'; + m_iFlags = flNONE; + return *this; +} + +//--------------------------------------------------------------------------- +IValue& Value::operator=(string_type a_sVal) +{ + m_val = cmplx_type(); + + if (!m_psVal) + m_psVal = new string_type(a_sVal); + else + *m_psVal = a_sVal; + + delete m_pvVal; + m_pvVal = nullptr; + + m_cType = 's'; + m_iFlags = flNONE; + return *this; +} + +//--------------------------------------------------------------------------- +IValue& Value::operator=(const char_type *a_szVal) +{ + m_val = cmplx_type(); + + if (!m_psVal) + m_psVal = new string_type(a_szVal); + else + *m_psVal = a_szVal; + + delete m_pvVal; + m_pvVal = nullptr; + + m_cType = 's'; + m_iFlags = flNONE; + return *this; +} + +//--------------------------------------------------------------------------- +IValue& Value::operator=(const matrix_type &a_vVal) +{ + m_val = cmplx_type(0, 0); + + delete m_psVal; + m_psVal = nullptr; + + if (m_pvVal == nullptr) + m_pvVal = new matrix_type(a_vVal); + else + *m_pvVal = a_vVal; + + m_cType = 'm'; + m_iFlags = flNONE; + + return *this; +} + +//--------------------------------------------------------------------------- +IValue& Value::operator=(const cmplx_type &val) +{ + m_val = val; + + delete m_psVal; + m_psVal = nullptr; + + delete m_pvVal; + m_pvVal = nullptr; + + m_cType = (m_val.imag() == 0) ? ((m_val.real() == (int)m_val.real()) ? 'i' : 'f') : 'c'; + m_iFlags = flNONE; + + return *this; +} + +//--------------------------------------------------------------------------- +IValue& Value::operator+=(const IValue &val) +{ + if (IsScalar() && val.IsScalar()) + { + // Scalar/Scalar addition + m_val += val.GetComplex(); + m_cType = (m_val.imag() == 0) ? ((m_val.real() == (int)m_val.real()) ? 'i' : 'f') : 'c'; + } + else if (IsMatrix() && val.IsMatrix()) + { + // Matrix/Matrix addition + assert(m_pvVal); + *m_pvVal += val.GetArray(); + } + else if (IsString() && val.IsString()) + { + // string/string addition + assert(m_psVal); + *m_psVal += val.GetString(); + } + else + { + // Type conflict + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, _T("+"), GetType(), val.GetType(), 2)); + } + + return *this; +} + +//--------------------------------------------------------------------------- +IValue& Value::operator-=(const IValue &val) +{ + if (IsScalar() && val.IsScalar()) + { + // Scalar/Scalar addition + m_val -= val.GetComplex(); + m_cType = (m_val.imag() == 0) ? ((m_val.real() == (int)m_val.real()) ? 'i' : 'f') : 'c'; + } + else if (IsMatrix() && val.IsMatrix()) + { + // Matrix/Matrix addition + assert(m_pvVal); + *m_pvVal -= val.GetArray(); + } + else + { + // There is a typeconflict: + throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, _T("-"), GetType(), val.GetType(), 2)); + } + + return *this; +} + +//--------------------------------------------------------------------------- +/** \brief Assign a value with multiplication + \param val The value to multiply to this + + When multiplying to values with each value representing a matrix type + the result is checked whether it is a 1 x 1 matrix. If so the value is + "unboxed" and stored directly in this value object. It is no longer + treated as a matrix internally. + */ +IValue& Value::operator*=(const IValue &val) +{ + if (IsScalar() && val.IsScalar()) + { + // Scalar/Scalar multiplication + m_val *= val.GetComplex(); + m_cType = (m_val.imag() == 0) ? ((m_val.real() == (int)m_val.real()) ? 'i' : 'f') : 'c'; + } + else if (IsMatrix() && val.IsMatrix()) + { + // Matrix/Matrix addition + assert(m_pvVal); + *m_pvVal *= val.GetArray(); + + // The result may actually be a scalar value, i.e. the scalar product of + // two vectors. + if (m_pvVal->GetCols() == 1 && m_pvVal->GetRows() == 1) + { + Assign(m_pvVal->At(0, 0)); + } + } + else if (IsMatrix() && val.IsScalar()) + { + *m_pvVal *= val; + } + else if (IsScalar() && val.IsMatrix()) + { + // transform this into a matrix and multiply with rhs + Value prod = val * (*this); + Assign(prod); + } + else + { + // Type conflict + ErrorContext errc(ecTYPE_CONFLICT_FUN, -1, _T("*")); + errc.Type1 = GetType(); + errc.Type2 = 'm'; //val.GetType(); + errc.Arg = 2; + throw ParserError(errc); + } + + return *this; +} + +//--------------------------------------------------------------------------- +/** \brief Returns a character representing the type of this value instance. + \return m_cType Either one of 'c' for comlex, 'i' for integer, + 'f' for floating point, 'b' for boolean, 's' for string or + 'm' for matrix values. + */ +char_type Value::GetType() const +{ + return m_cType; +} + +//--------------------------------------------------------------------------- +/** \brief Return the value as an integer. + + This function should only be called if you really need an integer value and + want to make sure your either get one or throw an exception if the value + can not be implicitely converted into an integer. + */ +int_type Value::GetInteger() const +{ + float_type v = m_val.real(); + + if (m_cType != 'i') + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT; + err.Type1 = m_cType; + err.Type2 = 'i'; + + if (GetIdent().length()) + { + err.Ident = GetIdent(); + } + else + { + stringstream_type ss; + ss << *this; + err.Ident = ss.str(); + } + + throw ParserError(err); + } + + return (int_type)v; +} + +//--------------------------------------------------------------------------- +float_type Value::GetFloat() const +{ + return m_val.real(); +} + +//--------------------------------------------------------------------------- +/** \brief Get the imaginary part of the value. + \throw ParserError in case this value represents a string or a matrix + */ +float_type Value::GetImag() const +{ + if (!IsScalar()) + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT; + err.Type1 = m_cType; + err.Type2 = 'c'; + + if (GetIdent().length()) + { + err.Ident = GetIdent(); + } + else + { + stringstream_type ss; + ss << *this; + err.Ident = ss.str(); + } + + throw ParserError(err); + } + + return m_val.imag(); +} + +//--------------------------------------------------------------------------- +/** \brief Returns this value as a complex number. + \throw nothrow + + If the value instance does not represent a complex value the returned value + is undefined. No exception is triggered. If you are unsure about the type + use IsComplex() or GetType() to verify the type. + */ +const cmplx_type& Value::GetComplex() const +{ + return m_val; +} + +//--------------------------------------------------------------------------- +const string_type& Value::GetString() const +{ + CheckType('s'); + assert(m_psVal != nullptr); + return *m_psVal; +} + +//--------------------------------------------------------------------------- +bool Value::GetBool() const +{ + CheckType('b'); + return m_val.real() == 1; +} + +//--------------------------------------------------------------------------- +const matrix_type& Value::GetArray() const +{ + CheckType('m'); + assert(m_pvVal != nullptr); + return *m_pvVal; +} + +//--------------------------------------------------------------------------- +int Value::GetRows() const +{ + return (GetType() != 'm') ? 1 : GetArray().GetRows(); +} + +//--------------------------------------------------------------------------- +int Value::GetCols() const +{ + return (GetType() != 'm') ? 1 : GetArray().GetCols(); +} + +//--------------------------------------------------------------------------- +void Value::CheckType(char_type a_cType) const +{ + if (m_cType != a_cType) + { + ErrorContext err; + err.Errc = ecTYPE_CONFLICT; + err.Type1 = m_cType; + err.Type2 = a_cType; + + if (GetIdent().length()) + { + err.Ident = GetIdent(); + } + else + { + stringstream_type ss; + ss << *this; + err.Ident = ss.str(); + } + + throw ParserError(err); + } +} + +//--------------------------------------------------------------------------- +bool Value::IsVariable() const +{ + return false; +} + +//--------------------------------------------------------------------------- +string_type Value::AsciiDump() const +{ + stringstream_type ss; + + ss << g_sCmdCode[GetCode()]; + ss << _T(" [addr=0x") << std::hex << this << std::dec; + ss << _T("; pos=") << GetExprPos(); + ss << _T("; type=\"") << GetType() << _T("\""); + ss << _T("; val="); + + switch (m_cType) + { + case 'i': ss << (int_type)m_val.real(); break; + case 'f': ss << m_val.real(); break; + case 'm': ss << _T("(matrix)"); break; + case 's': + assert(m_psVal != nullptr); + ss << _T("\"") << m_psVal << _T("\""); break; + } + + ss << ((IsFlagSet(IToken::flVOLATILE)) ? _T("; ") : _T("; not ")) << _T("vol"); + ss << _T("]"); + + return ss.str(); +} + +//----------------------------------------------------------------------------------------------- +void Value::Release() +{ + if (m_pCache) + m_pCache->ReleaseToCache(this); + else + delete this; +} + +//----------------------------------------------------------------------------------------------- +void Value::BindToCache(ValueCache *pCache) +{ + m_pCache = pCache; +} + +//----------------------------------------------------------------------------------------------- +Value::operator cmplx_type () +{ + return GetComplex(); +} + +//----------------------------------------------------------------------------------------------- +Value::operator int_type() +{ + return GetInteger(); +} + +//----------------------------------------------------------------------------------------------- +Value::operator string_type() +{ + return GetString(); +} + +//----------------------------------------------------------------------------------------------- +Value::operator float_type() +{ + return GetFloat(); +} + +//----------------------------------------------------------------------------------------------- +Value::operator bool() +{ + return GetBool(); +} +} // namespace mu diff --git a/src/third-party/headers/muparserx/mpValueCache.cpp b/src/third-party/headers/muparserx/mpValueCache.cpp new file mode 100644 index 0000000000..b8cfd63aca --- /dev/null +++ b/src/third-party/headers/muparserx/mpValueCache.cpp @@ -0,0 +1,105 @@ +/** \file + \brief Definition of a class for caching unused value items and recycling them. + +
+               __________                                 ____  ___
+    _____  __ _\______   \_____ _______  ______ __________\   \/  /
+   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
+  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
+  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+        \/                     \/           \/     \/           \_/
+                                       Copyright (C) 2016, Ingo Berg
+                                       All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright notice, 
+     this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright notice, 
+     this list of conditions and the following disclaimer in the documentation 
+     and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+  POSSIBILITY OF SUCH DAMAGE.
+
+*/ +#include "mpValueCache.h" + +#include "mpValue.h" + + +MUP_NAMESPACE_START + + //------------------------------------------------------------------------------ + ValueCache::ValueCache(int size) + :m_nIdx(-1) + ,m_vCache(size, (mup::Value*)0) // hint to myself: don't use nullptr gcc will go postal... + {} + + //------------------------------------------------------------------------------ + ValueCache::~ValueCache() + { + ReleaseAll(); + } + + //------------------------------------------------------------------------------ + void ValueCache::ReleaseAll() + { + for (std::size_t i=0; iGetRef()==0); + + // Add the value to the cache if the cache has room for it + // otherwise release the value item instantly + if ( m_nIdx < ((int)m_vCache.size()-1) ) + { + m_nIdx++; + m_vCache[m_nIdx] = pValue; + } + else + delete pValue; + } + + //------------------------------------------------------------------------------ + Value* ValueCache::CreateFromCache() + { + Value *pValue = nullptr; + if (m_nIdx>=0) + { + pValue = m_vCache[m_nIdx]; + m_vCache[m_nIdx] = nullptr; + m_nIdx--; + } + else + { + pValue = new Value(); + pValue->BindToCache(this); + } + + return pValue; + } + +MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpVariable.cpp b/src/third-party/headers/muparserx/mpVariable.cpp new file mode 100644 index 0000000000..a0c56c0b3d --- /dev/null +++ b/src/third-party/headers/muparserx/mpVariable.cpp @@ -0,0 +1,395 @@ +/** \file + \brief Implementation of the muParserX variable class. + +
+               __________                                 ____  ___
+    _____  __ _\______   \_____ _______  ______ __________\   \/  /
+   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
+  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
+  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
+        \/                     \/           \/     \/           \_/
+                                       Copyright (C) 2016, Ingo Berg
+                                       All rights reserved.
+
+  Redistribution and use in source and binary forms, with or without 
+  modification, are permitted provided that the following conditions are met:
+
+   * Redistributions of source code must retain the above copyright notice, 
+     this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above copyright notice, 
+     this list of conditions and the following disclaimer in the documentation 
+     and/or other materials provided with the distribution.
+
+  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
+  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
+  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
+  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
+  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
+  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
+  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
+  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
+  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
+  POSSIBILITY OF SUCH DAMAGE.
+
+*/ +#include "mpVariable.h" +#include "mpError.h" + +#include "mpValue.h" + + +MUP_NAMESPACE_START + + //----------------------------------------------------------------------------------------------- + /** \brief Create a variable and bind a value to it. + \param pVal Pointer of the value to bind to this variable. + + It is possible to create an empty variable object by setting pVal to nullptr. + Such variable objects must be bound later in order to be of any use. The parser + does NOT assume ownership over the pointer! + */ + Variable::Variable(IValue *pVal) + :IValue(cmVAL) + ,m_pVal(pVal) + { + AddFlags(IToken::flVOLATILE); + } + + //----------------------------------------------------------------------------------------------- + Variable::Variable(const Variable &obj) + :IValue(cmVAL) + { + Assign(obj); + AddFlags(IToken::flVOLATILE); + } + + //----------------------------------------------------------------------------------------------- + Variable& Variable::operator=(const Variable &obj) + { + Assign(obj); + return *this; + } + + //----------------------------------------------------------------------------------------------- + /** \brief Assign a value to the variable. + \param ref Reference to the value to be assigned + */ + IValue& Variable::operator=(const Value &ref) + { + assert(m_pVal); + *m_pVal = ref; + return *this; + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::operator=(int_type val) + { + assert(m_pVal); + return m_pVal->operator=(val); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::operator=(float_type val) + { + assert(m_pVal); + return m_pVal->operator=(val); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::operator=(string_type val) + { + assert(m_pVal); + return m_pVal->operator=(val); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::operator=(bool_type val) + { + assert(m_pVal); + return m_pVal->operator=(val); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::operator=(const matrix_type &val) + { + assert(m_pVal); + return m_pVal->operator=(val); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::operator=(const cmplx_type &val) + { + assert(m_pVal); + return m_pVal->operator=(val); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::operator+=(const IValue &val) + { + assert(m_pVal); + return m_pVal->operator+=(val); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::operator-=(const IValue &val) + { + assert(m_pVal); + return m_pVal->operator-=(val); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::operator*=(const IValue &val) + { + assert(m_pVal); + return m_pVal->operator*=(val); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::At(int nRow, int nCol) + { + return m_pVal->At(nRow, nCol); + } + + //----------------------------------------------------------------------------------------------- + IValue& Variable::At(const IValue &row, const IValue &col) + { + try + { + return m_pVal->At(row, col); + } + catch(ParserError &exc) + { + // add the identifier to the error context + exc.GetContext().Ident = GetIdent(); + throw exc; + } + } + + //----------------------------------------------------------------------------------------------- + Variable::~Variable() + {} + + //----------------------------------------------------------------------------------------------- + void Variable::Assign(const Variable &ref) + { + if (this==&ref) + return; + + m_pVal = ref.m_pVal; + } + + //----------------------------------------------------------------------------------------------- + /** \brief Returns a character representing the type of the variable. + \throw nothrow + */ + char_type Variable::GetType() const + { + return (m_pVal) ? m_pVal->GetType() : 'v'; + } + + //----------------------------------------------------------------------------------------------- + /** \brief Returns the Value pointer bound to this variable. + \throw nothrow + */ + IValue* Variable::GetPtr() const + { + return m_pVal; + } + + //----------------------------------------------------------------------------------------------- + int_type Variable::GetInteger() const + { + try + { + return m_pVal->GetInteger(); + } + catch (ParserError &exc) + { + exc.GetContext().Ident = GetIdent(); + throw; + } + } + + //----------------------------------------------------------------------------------------------- + float_type Variable::GetFloat() const + { + try + { + return m_pVal->GetFloat(); + } + catch (ParserError &exc) + { + exc.GetContext().Ident = GetIdent(); + throw; + } + } + + //----------------------------------------------------------------------------------------------- + float_type Variable::GetImag() const + { + try + { + return m_pVal->GetImag(); + } + catch (ParserError &exc) + { + exc.GetContext().Ident = GetIdent(); + throw; + } + } + + //----------------------------------------------------------------------------------------------- + const cmplx_type& Variable::GetComplex() const + { + try + { + return m_pVal->GetComplex(); + } + catch (ParserError &exc) + { + exc.GetContext().Ident = GetIdent(); + throw; + } + } + + //----------------------------------------------------------------------------------------------- + const string_type& Variable::GetString() const + { + try + { + return m_pVal->GetString(); + } + catch (ParserError &exc) + { + exc.GetContext().Ident = GetIdent(); + throw; + } + } + + //----------------------------------------------------------------------------------------------- + bool Variable::GetBool() const + { + try + { + return m_pVal->GetBool(); + } + catch (ParserError &exc) + { + exc.GetContext().Ident = GetIdent(); + throw; + } + } + + //----------------------------------------------------------------------------------------------- + const matrix_type& Variable::GetArray() const + { + try + { + return m_pVal->GetArray(); + } + catch (ParserError &exc) + { + exc.GetContext().Ident = GetIdent(); + throw; + } + } + + //----------------------------------------------------------------------------------------------- + int Variable::GetRows() const + { + try + { + return m_pVal->GetRows(); + } + catch (ParserError &exc) + { + exc.GetContext().Ident = GetIdent(); + throw; + } + } + + //----------------------------------------------------------------------------------------------- + int Variable::GetCols() const + { + try + { + return m_pVal->GetCols(); + } + catch (ParserError &exc) + { + exc.GetContext().Ident = GetIdent(); + throw; + } + } + + //----------------------------------------------------------------------------------------------- + void Variable::SetFloat(float_type a_fVal) + { + assert(m_pVal); + *m_pVal = a_fVal; + } + + //----------------------------------------------------------------------------------------------- + void Variable::SetString(const string_type &a_sVal) + { + assert(m_pVal); + *m_pVal = a_sVal; + } + + //----------------------------------------------------------------------------------------------- + void Variable::SetBool(bool a_bVal) + { + assert(m_pVal); + *m_pVal = a_bVal; + } + + //----------------------------------------------------------------------------------------------- + void Variable::Bind(IValue *pValue) + { + m_pVal = pValue; + } + + //--------------------------------------------------------------------------- + bool Variable::IsVariable() const + { + return true; + } + + //----------------------------------------------------------------------------------------------- + IToken* Variable::Clone() const + { + return new Variable(*this); + } + + //----------------------------------------------------------------------------------------------- + Value* Variable::AsValue() + { + return nullptr; + } + + //----------------------------------------------------------------------------------------------- + string_type Variable::AsciiDump() const + { + stringstream_type ss; + + ss << g_sCmdCode[ GetCode() ]; + ss << _T(" [addr=0x") << std::hex << this << std::dec; + ss << _T("; pos=") << GetExprPos(); + ss << _T("; id=\"") << GetIdent() << _T("\""); + ss << _T("; type=\"") << GetType() << _T("\""); + ss << _T("; val="); + + switch(GetType()) + { + case 'i': ss << (int_type)GetFloat(); break; + case 'f': ss << GetFloat(); break; + case 'm': ss << _T("(array)"); break; + case 's': ss << _T("\"") << GetString() << _T("\""); break; + } + + ss << ((IsFlagSet(IToken::flVOLATILE)) ? _T("; ") : _T("; not ")) << _T("vol"); + ss << _T("]"); + + return ss.str(); + } +MUP_NAMESPACE_END diff --git a/src/third-party/linux/lib/libmuparserx.a b/src/third-party/linux/lib/libmuparserx.a new file mode 100644 index 0000000000000000000000000000000000000000..ae4dada2094f056c15af27ff1ed69e1ebc07b607 GIT binary patch literal 3239354 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

bacMl?*$Zze%|H#}(#i(!u)1g}CqPurQnfCfQC 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

`Z+!KQI zU*oFv;Pb`KFtMX?-6D9q;2PIg2rmtO9og5ozUPsDLhvs{1LHpt7!g&@RG<% ze&Jb>uc7wjqH%2|d|2?^5TySa*LDwn;85xRVn^dD6Z}5GHLl5omj*wL>}y;XdE}b~ z=YGdU<623$E3Ugm{zhsyE*jSpgbxeu4MF-pL6%H`aEd`mb?)fN;)(Ek9cD8DdA{Y9!nh*F2H`i^ywSiwPeVtc`dl z$kGZAzEj?0!mOz@k;j>dHf;jXwEME+3X z;i7TfNcgbe{t%@98rMn>{)pHq6FVB$ZwYtt{*Ca`AV1z%(h&?g)GdFk2e0^{#1mkKlgg%*BSfy@z`qrWh4JgWJmpc!{E z|7T=J?U!UZZ~uyLwLi?@artqCm%?~>wSSh8|4(E`?O$T>?Gdi_TRrmE6J8qR$Iq+% z&l&mr^HXYnwZV6b`m@@9*dzZ7!b@Siz1rVwH`$PbC^sQnKbeBTIH|7$(+orIUdcz(6N*vKCc*-`snGWh!=T3C{6PG`j@KShQK_Mw8~gd^9n}87;hdk!$d1}S$lzy1xY{4-kw2aA(jfo* zh1x&g$e$hAQTwwEeolm|{VP54HyQi+=Rwr|?MD9m$d20ow!x=GxY~cjBmV;7uJfpO z2`>#UitNbGt>FDfy5&a_UJB2n4GF?>y210$ohjEegXfmS2G2kLrT(ljcxxoD_@f5TKhL$d`2W1YyJGTxGI;*^EcO522LEUzuYT@L z4N(fuTd91h!LN(t6(4W#{PRB!Sl~6sr-)&o_{V$<9){9`R9)mf5qVW=ZqA8gK&*eQg3E^98GwCM8f3*8IQw3 znFkMQFP_#}HTtBsriS{4E9txHwdRB1?OpYqVbz4%+9vv%d6TS;9$VMk+*;3H53j9j zpBu`Y&@{KDwY`B>&ONENc5X{oZGCrl)tJ$>wX+-M)O9s?){@EZN$lct z&*tv{Owg~APd#^9?Fr#W$15vmH&o8A98HF*FQ}}k`B3ed)6bn;GxfZ4Yimh!92xEC zq_3>k*RoShb3*Vf!!R^QgfF0&^mO`S|}&8n-vV)FRP3(lTa&RnKO-udo==@suTnBM4a!{&wc zKHOnOUvTfTLuPU=oXj|JenG!2Z$2R4GGr=TmZDD%*rqr?^vwbrW_k0;1G_@MnPB7L zHy3P_rTL2uE}XykVB_o!eKEoX(+4M9FnzDWhS_)XxeHf?`EG_?!EW*gIBb0M7^;Xq z zaIZVn_(wTXSYpkqMB(Nkide-95|Ou30E0C8Iev0;YYQENf+-i3wKvQuqa#{(cWqlk zdq-;v9d0@o)Xp!b@LR5&NB?IxS5qraZ@IFG4nG$(bac%#he7?y4fTewow2P5jGX7( zu#nYO1Qpv>Vkw?wrEp{+WR7wcWr6T03(%>kyT_v;upk;1vZ5jAy+lK5?r5085lzS( zkA`qN8r~U93eE6NS2~xXQ9KG@K#HY}sIH@_CE8k4IUbkR*nvg3-CMQ785%dN*}oKo zMrdJZVfz;xc6is9I<)%Mj>6DL*%KO5S#4$_VB8rRRX9VVy{RKKLJLD0%VzeMCBW6X#*n5eJ_1sYz z7DrUV9*>GE?5NCXn6x_V6C*f^D?)Jliompy@oup(+Id9k@c^SLdmGDF*c(|?lg)vH}h<1<0EQ6_ItZ(hGVq|qsjE2r?#fUPtBZ+F9F-niHV`R86M(HAjF*2As z#?Css9a-HIqoH%fXeylT$TfD1d`iPVItvbQ0!Hzv5Nv(|rH!q*l`n9Fr^2Edk4tH+ zs1&wi65Ni6o74PQDvT+Dqo^Xp-ujGo5s{7NlUO;;SMqptc{(e;e1#ohRAa};M+x$B zOks$MMiDB20V-BRd}E^UR5>1<*4Vq22)AR?3Oh8pdQs3H^(&Hc0xcrY8$%>*NZMGT zRy-E5Z#7fIT6ho$VLJ+r&RlINh(pnW1~Ot0iwdQUrh_gi6f_VUj0dG=T@55I6b7aW zuF%W{qgZI+heM^2Slx(Op)r;=w0e>)2#uB9p&2Tx#lVGlXslp|#(NaL=2Z}xfKi*N z5X2==+OQhB&DGNAHzHBSgHjqRCWYEsDJ$HFq>j z;fN+=E^HvNES`0^EY4~%MDF^1QAV=>C7lcnX@LMRAr z7lCPGtm~vJy9F^Co9-AxI;#yMO3HO%D@HYTjJ&Hcm#qszR5WTu1+WnnOB>%Dx;h?( zr^@l@w8n102)AR?3Oh9G%6mb8g>_Mwg)jzNSd%v7cKv{N6nCMWc=Uz!b`GpsI}?S~ z`FzyYb#yeech=6SYicG>YNncNpoP*V2jQMQyzokwho^P6H?_UO#@IlG~y zK3;#~!)>&9$nv9*IwJ%Uf0yw zF}1#OS{?nX^tAgF*oq62G^IS|;fWVCG&j_BfNPdY*zZin^Ld*hy)kSF?ZJ^h3ZN$u z20lbsfw^d7kL*PV8q9-WF%QN}n%#YY$?&!lWQ(;!&@vf<1t#SH6&aLu^iUx%rclfj z9gPc2(YkGlApvXX4qH$K^GZP08K?07>lq1bKHTu63PFs4v}DQ4h%g^mj-Xf6`NE|Lf1Ci${Y6|zjlf@C>t0a>@bA`y&GrNpZX&mCQEP6+B|HO(JAhL$^;YU`Wn zT&T8lL0bb29-7n2S*)4nIUSPor2J7Eq`Ce1ycr;~Id;-HyoE)_O(9}8=@%79F(St= zkdecXAWW!76M*!HAW(j<4l=rb7Kr_f_OXJo2eOj{sc2t^7&VsJvmi!22r>4R+Qx<~ zO_p*f>ZT|5SxPq_grw67Bu#JSln5;Hf8_NN(Gz!UzXRld4R-ix2etD$;GKYP1Dr>H zs{CQJ%td+Salq)!DRv&lh&<u za~^oKuJX2nJmz5u;FyOy0q4=ZYUg3W)t@Qi&#yrq^YAyoc{H%v*$z17VNXr~6*~{* zf-CQNp;&M#$YUO+2+n!;PYSO7)QCUf`@usyn1{cE z9UjfBc6Q^=M1`v{4<&$Oe>g#K<*hT?K`|>&Hd?nG>!Ce+GHX!@mLNx7w+ly#|Jgb{_aWfLs{IJWLc^dF3z?Oa*z&L$%L8c7Ucm1MJFf_? z{(Q|?4T67zJmz8VJwgHI{V~}20N|L15rAWVI9G7xT`RnofIQ}b-|NSP^Uw>tp9Oi$ z!?yv)JUjvTqhRL`f~!9d8aDd2Bd8iRwd7l^FI*`Xa zGzxw!$vp+Uw}U+9;roDN9@YcC9_+j(xcc*w__MpbFUrmXzekb_d?IObs^;J*Po{}f#PIY9h* zpF9|5=ix}ee+zcT1CDv9037o$M{wmmT6jA^9`kUO;GBn7f%hJe$2>d^KcyCe*rtE0FHS$6L8E!v*60BPlED${kSkM=3$}WoQKzem*3yV zh2=31{Qf>JjAI^N1$-;m$;bn5>dzFa<8rv*b{<9p{ubDo1UTlQ3UJIryWq+@U3mGu zeq8K4+$cEb;UB+hwZi*3kjFgSAvovZ zAmIHO$YUN}103_P$Nt>v`F6ilt{3oo{SbdZ{Fy4aorg;RKMef20&vX3e84dew+pU$ zcu{!20rHp!eh(lQ&O<5iz6$b~hko(^Jo}G%81BI<0OxCE+TUsgS3mif&E=yYkLTMr z1Aa8v`4ZrmpH+Zkex4Ovd3hV=@+*+X{QORE&d;&Hd!StKj`<1X{b$O1mhkQ^ILC|m*=103^nzX$&X;HQKAzYDH@UM+s^dk{H7h2zEi90B+lU}r4gn4i-C z$NbC|TzS7KydMF1%ul!AoS#bIT@CV>pQixF{A}^ygXBg4$D0HDM+>fgJ|KQh26@cS zbimIBI}Lzie%b)X{Cr7premLUe|RUzzX0~X0rI~9d=21e=LdpwKKYuz+J6Y_Zv>oP zZ)FPG;J1XR{856loq2$x{1t$s{A|F}$n&|I@}`l;`zC4R@%};@`A-+=4_>cMV;`^U zrjf_%pK0XrI$;`lyq=au9hhEel8ol3UE0r8~i-Lv#dmg?NkFk!k{4@ zexo`B$^pLsC4EWC6E|-9x*e;g>o~B(+19@zh z3c#^laJx&>F6?J9?Q%KrV!MRjXb&59XKt5T@E_Y{Cg5q>Wjx4ZyPOC(whQh*)3giw zSxmdk0$ywv9n-=svop6#J@}99G8^zT?J^SNv0cgl$9BQvV48MeKZ|LXIlznUG6L|O zxn1UhpV%&qfTwAfBS0S8UGRJ+O}nt4#k9+Zffw85aKLxwcDVxl#CFj!X}rCs zX_rI54z|mofMdJhd1;zTnT<+yL1DdW_vL|{Gxdp}LPu%E@W%T>UO?eY%)Sd_9e zx64Pte{7el0Z-E|+aO+Smwy3{?Sj{B(zFZvSxmcp4E)D-c^mxMncL-B@E_Y{A>e7+ zw>0g-eiqX%9|!-jU0wr!cII}u9{k64Sp;~RcKIX3i|w)*aBLU6 zj+&-j*w13xAgPlNy1F1G=mrd=L^ zc(Gj`1036>mvGHku!t%QpbWcERx*Y1)PTET&!V1pl#Jz6$>A z%^UE*v0ZRHRho8TKZ|LXyTN~KmrsG8JM;GPP4FMvWi{Yw+GQ!ki|vyC zDqdl`;JCOn?ZSQ*(=PXb|JW{z!Oxw!UA_(eW4o*YJWab?5AkBV+yFRkFF3w2O}nt4 z#k9+J!GCNQedh*mzdLigd=LD`cDWbuH0^Q~voWxr*@E?pX?wzPwyZ*>vxcyXLgXCXLpdD=XQ{t4LiurPj`@=pY0$!Ki@%i zo-fi4i$5XH5#e!dJ{*^`Qo*udKB%zp(`0?Ng|C$LMS#nzI1HloY+GJUVescbz8(B| z6>!$MPu5=tTwd*9kinwMvOEox^^q1nMb@h={BBuq16*FEVC*jgob5j#>z@al{n7IP zeU4fE8O#e*HiA4u9~4~2gs8m!R?#tdjO)1*+nFeODzC>#9+S_7XY5awCN4ULR^|7T z=OgsqwBpr*>$L^N?-N}2?Tl-zY=1KYR8)SQ$iD$N`%`YDNLT7re&~R(qTIqS6uid5 z9}v6~aCyYv7`hE`=6F`*zXUk@Q(>g3JppI=!{j|;FI)Jff|~~#NKXBKMDVQeFfNbU z8-@zNx$b$9p9(npQ*ET_{26eTA3iXwSZv|51Yd38>jYm9xI7AP3~d3N?Y|`Q`W`vP z*q@m+aoJz|Wt^vD<$YV@EWAW~AvlfaFi(ow#RMF~P#G68usN-z50efXk!U#?bA6 zGsl}E|24qbpA|+r2p$8R<bm)Q1C&LZ}tC=f{y@Pe^WCBzMqYCwu$`tAkY4+ zVPPt5fU|r~4ododHs!rh@Ov%!ErM%5VtIL#nau}pTk`LU{C@yve|lM%%AwMp%6l$X zQkiJsO9h{4;cp7Q5O6%?uK=7m2FStf8-TNk4NOX99pEfqBl4Rq{8qsSOZ%(;+XNp8 zxIWXz_NxGAojv8?HXU&GXA@0aIss?-i$(r63tukyS_^+y@Qr{UYAlEUwgJxeOG-k# zpY$Wf*q^N-9Ap9Kx|t$hVc~ZOKHI_v$iZq6;2#j%JX;Ak+doj`zXiByayg$^4>-%u z5&10^zEbcK>5nYS)1Gp$DhK>9!nITb&hm$f{D%N%e@eukZopZ-S>%^n_}zj(VBsZl zuzDGAeTI~MdIxZ}KTPCzGf4?!;>E1^GaPW1Zx{I~7QROCMhhP%2dl+^XUUG1Re-bo zaU%a6z;QPz=#Iiiq$iZqH;H89X(d|{`=ZO4eAkS14;?LE9 zv(9}Yf4hahEqJem-zW#GO@I$mXLv5#pZc?0GKN0!w1J3@;6n~xvoaGOegU{O*K11-KvfXREe-V5F;KRiip3MN9 zb>0#AI>6bVHt}a6;4EJy2cH!dev{yjS@@xHaCjB)Bgu{y-9M@SWg@?~>^~T1e-?^A zBLP23jnKRb@DYGF1AZ*vO94L)@YR4H5BPe(%K+a3csbyMWq-r|j|O}s;9~)=0(>0c zx<6w(Cjh<_(C0p9}nM8F5j{)u@{1$-pnrvqLEcm?3ifS&>QQottz zz8dgKz}EwQCg58D&jCJI_Gj$>RKQ09em3A$fL8(D4EVW#F9rNOz*hr)KH%#CzX0$p zfY$&%SoVMH|8&4d0)7$TRe;X`yczI|0bdIEC4jF6{4&7T1AaN+TL7O4_+Z(Ovj25} zj|99P@G8J(1Ktey9Ke?XJ{R!SfHwiY9`FwXz6J1Rzz55In*E;#_(;H80j~nQ4e(~b z+W}t+cn9FC0cY-OWPiBc!lUbKWgQFVb=J)a%IN!M;k;3o+8dhd%IMn^ok7`b`kr7= zHmjo}C~I#GSEAZ7`N~@U(hPKXHqNi_VxOM338+je4 zRr(r79}?!vA1Oro<}p_2V4Qia6I%yoIZ@O1bsy(K>|O0 z8fW3`oA34XVa2piCw=Fq4;hYGKC9{LQiY!h^w=_=Tcj^BUeVA}-Pu0%+-bEZ$d?i; zXY(fq&9=^4b030joh)cJK;8}T673O4spdlGhmYb}DRk9*Kq^s)Kk?KDsV1n>vGdS6 z4^dQ|KoPZ*izBM^kmT!Au*esl;yGa}`A;AARiD7ZecOC9DsDrnJaK4k3j5{@RBrqF znM8kW3j5}JR&ERW?L>cVf_?52;n%U^CbZ6zp{P0qMfkNXH%0V`#XhPNDD>-HaSQP2 zMQ>$-agLLB<*uzk>-tC$tD29kh5XJv33qpML~(IMl^&9OeL^7IrHRGGAypm*txd4c zj>wnK;<=70JskP^G%S2d;fljp;mW>POnn*_KI8DRaAjXCrapm%yAPj^xJb0l!x2@d zpzvjjZS;|>s5%9OFI8-#k4#0?DJa74+r@hp+u*uB5@o8>P*65}ZDGDL$zMqHctEO2 zo4N6nvf-tmy1t^|>VznGQ}r-Nm4`rUQ`q+;i7jvv+&R+P6!xhtT^V8v{$|!%uYLEo zyX7YypVYa(X6f8(+h3oKS>curzjE1!zS&uIn(to53>4JyZ&T~I5qiK<(K(d)t(p&{ zpw4T7(T}yh=L?pBf;z7S&b^!qSo%=o)n<<9NN?#E)b(wF_7>*Q z=dz%6eOsVio!5fac`b0NX@}x6fK`3!tD9B`tglsl>Z_9ueXZ(KUk{27eXZ(SpSwSiZg+QWTSI$CYfD{oQ|E%(`Q<@bee1k=4J~v{v8A=Mq3o=4ryt+Z zSyz9BSZZjjozq@7uOTR#+uquRS3=<;XAz5^r|aW#i={xTLe}K=Y_N*%53MFlh8sn5 zpT1t>NBwUVp|982QU9JI^z|Ay>VLZkea$TDuPH+RYLexG`ro1TwE0_Xvo{K2|8WueLmmA5O~|zQAMVh9s0e)>-+})37NI}U!T)d( z`ZNc0DVX3X)cu?YR8 z4t^e!otA&O=+oiV6h3}FK}%`%S3CH5taw`ewGRF#i{M}H;2&EA|3(M@x+3_uIQWk( zf`6NX|EVJQb(}x;KYovK+WZeCSuWWAKcV%s`Xfaj`T2dlY4s;K_@6FzuGetyqr+Waqf@IPAw|7r(6zfUtQ|5^wCb4Bp4ckuIj zBh&J4bnx>zRa*Tm4*pk*;NRxp|7j8YgEJ&d1-Czb4`5pVhl)OK|34#pY4t}s`1yTz zY4s;K_R z4i2~fmx|yY>EP%0#iZq*AcDyMt0MTT9Q^!Vl(hUa9Q^#7IIVuOgTK27{%!~VuZ!Sc z>foPU1pjge|8I)mU+v&OmyT%yM|0oxx3waOzkm3B8EN%<9sCy;p}*e2&+pkt%m2KC zpTAd>R)3R&pWn}sR)4dDe^wFtZ#($;y&h@#-*NEs_h-`T589178x?H--Xio%L?8Em zA1*@wPzOK1M@ZVB|{sssCPm0jr=-}t~PN((% zRR=%6cP6d=76(7SUpcM*HU~fdrcbLM3=EGSxc}$(2&dH_Ec&?r;rHC6)!*O2e@7Ae zSqDGAA15vU2nYY2Md*)n@bi0h((+Gq@ZVL0e$K(q@8e0!U+v((y9oVD9sK+rpS1k5 z9sK-$zO?#n4t{?BPg?zM2mg1A&|l=>=l2Gs<=6L3;P!V<5&Fv={QSP5wEQa^@$-9q zZ2c_lCJ5HuMYz+T|Eop+SMq$7R*(w?h2JH>HY*CyAjqx@feoV1_fI}fknT^0iu_SD zXMXv)FK7^aqBL48SYTN!BWZ^1s5t{{;vCw>YsU*X`t-@*TT5C7G|UqL!pXmcwlzwz*I5dN7W&F2X`{?(3u zFl{`}{g3e5W9x1HlSMycRcsLbwgPYS{0fgJeb@F|zB!bbz|K)&|9SkY?SF&E{|b3I zlgx|_{%5%v%=GX#{y9{^?dM^FZ2p@({4GL!RA?spZ}Z>a;a~3Hf7HSMZQ-}`zg+l} z@_)C7f1U7S{vUVn^L(m^9Q-`~&*twIemnmoMzQz#_w=no=RN%8e+@mv{PXxXoBu%%{}aNW)c=3z;h*W?=kaGY|8Iof&i~ew`G3*FzfAZs z|2+Q7=I=ky-T!7v;*#?J9}oY!zs2*<K z@&6TqZ2pBF{tJcwsL)LG-#-3+)Wg5b!T(za{~f|_=YOH_C*}Y19{yh8$Nc}^!T*Tx z+t=T>3V%}mf9&Dk_GXwe%>N%8{F^-dhm8sKj|ykee>?xb^6-y%D^x*#KBcwW|6Sp? z^Pdy`r2O-H%U#>w4B^N8^C^+df5h(Y{=ZiElk$HU>AU!sy&aFAPYG=PGd%o%Oqu^v zJ^Z~6{?{G+b;57wzhrFae^UPWeebULw+cVzpLdCN{5N{yUnu-Z`M=J?KjI&u|JeU{ zleGEyJ@c;p-#x;g)c;p__-8oyxl7vo{62f;xAVU-W&R)X@GlmA%>UmV{D1PqpBqQQ zRFd-lI}d;FKSO=YKSOr>0|;>Cf4=Z1<$t?}f2)I^@AcUHrNVFLe}(WT_5VXj-_`%K z+rs!U|NnOIpXrIeWPGTfl>bQ{{uvxB70myCXr07O(c^!EhyOI;Ps;yH5C38Z|8@ue zBH_35-zfY^`M=h~zgGA$|NW?=k$6G;cMHFL{N0!`|6lX)Z~dQ;2lJnC@c+caKk$T5 zKPmr@d-${5*{C4@ZVvvx2)~{Ga^X+P{~tX3)xwYY-`&B#&mQjWe}(WT_5VFc-?jZM zekUIP9uEGI9{y)j=Kp99|5^wCUJm{b3csEIZ7K6#>EYij{Fwi}9sF&c_#00Q^OuzW zD?I#JzA;Y)``-`;|1uB%XN5nh|1a_IS3CIkb?~ndemnoY!k^UtzvI`}`};J;e+dnD)FM0TL!jJhs(!oDqFL(c6Ec{9N-|pdG zI3OPX(GLD2JpA_we^UQHjPzaG{~8DXF%EwIei(ad=YLbm{GaOK-z5B)|Kl9|b3O4_ zpAxozQvPRo_=n1eD{=pGyo3Kn5C6x6KPms$dH8b<{!tG8uL-}M|5d`D)c;p__`8K4 z^FP|b{}WIALno%o|KlG1HGHy51@k}F!T)Cu|Cz#{l>b*f{F@y7;~o5i2D|%zoA4*) zKSTPi?XP4|7(eF!LJ$~2oHabPxh_+pXA`L^6>9-s!>lo{+{LG?{@H? z;^4nR`0f5bLHLvMKgYwrO87DVr#kqTdE#Fs{7L(tB_94wd&cw6V@>JjqA5dV{%sHc zFH+|JZV!J6|Jb5}+utMy|Fgnx=RY_tbTBFZPkHz&gdg)i*}?y&C;m3!Ps;!69{%pZ z@%Sqp{3Uz4kN2l+_%Z)e9sCz~;-7GO z*#5_dv*^El|Kl7Ff5|@a{GaXMZ}afa5&oq7U*X}eaPXhw;J-!q?ffqj{-plj@Px`L?N43NM84mw1_V~X-_=hNw%x(UwJpQi{{UrapJpM0t z_HiNr{%>;lf4Rf|UwixyCWQ&N{k7NM_4r>R`bqi! zm&gARe6f!T_WwGE{~w?Z!jg9XA0hl?zM$CsXQJra{eOb!C;5LO>AU)Wo5TOv4*xIl z_+OpU|EoOy&rIomm&gCL4*%ym{Qtbi|L&Cjul4x9IHmvJ^Y|a^N6u2g{_|mn{~JC2 zuMmE!E+}^Y+2-+oO-ldY^7x-~_&?9#KYw4A;8_1(m(qX!4lV23{ePqAC-wiar0?qg z%N+i<5s~Ik?Oy2df2;7*;jy5ozJi?||AR9^3FT3FTff!g|3-)Z9S;9*^Y}kh_>=n2 zy&nHZr1byW9{;m^vw})a0_XFG`40bI@c3UL{8U{~?Dc<$zTJPSQ~Lh~>AU(*qr?9N z4*w6>*WLdcg+FQkKTh;*|GQKAKZ^8S{;zTPf3?H^=^p==rOf|)kN+!D`u`D+|Jxk? zU+eJya~}VDQ~JNwr7P~lJ7|C}uPcK;ud(*N9R4qM_T>l{GV_jIcxR*&pG`6yvP4RQ;d3$bo^cG@qei3>wYe@mf!#B`u9BkFLe0-1&9B? z^!Q(%(*J*W{I5vq{~I3v*E#(ElEeQ4_ILOH87ciANBZ1G8BM6n8%1A_H(IUhIv+*) z1E{h>1!P{rgGH!l`|_KKUg99o8PaJ;au~s=uH~G0y3|V_^YXZapC;m z<%pmCvAJ1(@umDf2(%x4g9KgIUugJHtnaYirWO1@2u?XVoa=w)!$PM&PW@%ahLS5N zJ}kEWyf*r%R{gZj_Okl6wzAey<=K1*m&5-jj2mYv#!NV2T!_rv^V-U)GyC_;TkJe7H9V5%f()>7C9!c}#Ww}h|qiD|k zkM%~=G)9)k(tMmO^Ke$K=V66B=izNUpFk52b>U?m^1!#<`PM7neq)Sp!|<&DUap{N z5>02&#D@pQxSLhV@|iS0i>4e+Qw94V&CizQDw>}|)44RACs;Mj&zI#3WIm1NHL^Ti z=A6QdWO;_nKScA3W%&}BUrzH{nx^M^{*b$VOG&Qhnr*oymD_&E&gO15m$M(FduBnd z=gG}93vx?#GqankOIR+~Q?l%-M_GGP%``GlO$OHHdb-x+dZw@HIcMeU+>!xDa^vKB zDmRbrC6!fqOC`DM9@%JY?nmJEpXGWU$=zJpo9p>SUZ#>P33Jb*xh0w0^}REzmSjUY zskouHd-peULyqlz?Ep6M)4yE5sb6l7M;LnK%^@?$;4721KaVQQ$dS#nb7Mo_I!j+W zI7ikEw~}pC-Z1RzAFIA((xsO@y3AyXvvjjbgdkz`oW9KualS((_PBC$uICBzK#+~E z9XPe;FmMrth8@rrZRE{zYKvvm7K?k%Srl)J#S!@ucU!E$wz#>HR>Smg z2(TI^FRCRe?It}BSM~fZ*Yle&`X!a*izZlFv(dEX^c7+D^DS>0gA->p9r9YuIOetE ztY&;I6LT%ru5FO@UG2K7UH=!hSKf0r($>0)wpQATrZ4X~=Qe9=z5bfp`gIH)9kns<7-wq1YCJN>%G zTzAd3?c0N(>zKlvnuDNbTMmDcC^_~$$Z8MqA#?M}?c29s_9*AdS@_(qqqDuap+)B- zI*!R6pS_@=v#Y(OBiq^7kfqAGosHSnIcANdn_A{(JIaDi`hX~XeN^Y6;^fwr`3>!z zp{B}aJ6p3xw!W^TAzR;A*IrlON#8AH8_lg(k_|4hoM6Yu$LtW(nAx+Mjh#{Lt*xD- z=5@8zwRbeMcaI9^qY6$HgSy(LN$qp%Pd#;XaAflwqbD}{;O}g0Za? zJEys|u9NdIrswnoIzajjK?aqFg zNBadE`_UN(L4)_F`BA%-2b03}16bs<{YHPXfAG_O8T#tg%KrbQ;GUhAZ|xV{;4)Kq zrr6W9)tm(`nZ6ZwC9!iv5+cFsoDuFZ^Q}v&t9iA@%xJA9T&t07DmoiY%kh7ko}6jt zmISoF(A|;Q=ka;Ku$nXu^8YEf_JnIRPJ?T6eK40&(^Wq(7@FSlG?pQiH zjUEjLt;#-oV<DkG;yNmP9WIio%JZyb zoXTwer#AZ68UfaSjBzRx_@CByg!;n?TFp2WzFstd7gQ$nW3u`o!+o9cvYoeCm&%Eh zpSYdOas9{;`%}Xwy;OYhbV|L?-%F)F$=?S=&ecBb?@Fmp@^^q-eD(P|T-w5F1^Y;O%PxANBOlZf)Gg0a*SWNrW zN5g)XCFoMAzYgmumi||UGTc`dip)eyrd|5d3aQUx{Uv$*Ua9x_xJl~wLH((D{V>t; zjt-5XF<+lG4IyKgwZ1N2Um^8;Jvqt&=+8{hUzni3B0;}5L4Q+%ey|%m9$ssX{O>=- z1ehf}EA{60uEt*-#?N}bQepb=8}t)6UNXU9agdNqkoDlD9(-5~CtA9up2vBe3-`5t zLEety;XQ$2R2LSVR~Y$W(R~@k`Pw_%m$XK6*3JY+@GMp`(UG9ADia$SAJ%8gor^+Q zUdsf07o)Ir(klD&|FQQjaB>x8+W5(ICJ8qaE^1Veo)BWV7-n*v1klcAsQ7F6*VfW@wTFZMidw^e~EsmQ4v{}^^1zT$%b8{f7WGP zl<$42-uImMRG*sZ2|;w1`b|&OdFs8@_0&04r)obNi1+{EQo*?rjQOcRo{nQM$v-a+ z(A5Ljqf!Br9Ns{{iAq)Mh-(Q_X7jY-0FYNGg5kclo-C}n1C6u`lhnZZfIF`HBAQsIiIcw8#LOi!gt1x!5VcH1yccLnJQf>z>HJeVJfhO z`iI|*vpD9!;2IcTFy3C9{>TQ&o+~&M_fqC$lQ@Q}R8Xh{4ZgMlUt#LK`4@}ZV4#{9 zh6}83g9g`q+~Cq{M6p8#=T0_)gMTu(xoasj2>xL3Nihr;CmK^us=&`RxQue+(W#&{ z4)9fqT6~gAg}q@sHkFWGP^4nLW5kn^n@$9oP^#htB1@18xX>%;F%qwIsQ@$Ll`a(= zTL}`93Xb#O$9r(|!o4CcRk6~>lB9x(6|?|SL1j5w+>B-_cv3-S`C9suD`+k5D|g*` zBGy#!qUb_}Qh~Dog5y%*$`VCP!Bp^)I1tjm)PujwgX6AU=~BUI72qPO=O?Lgh4k!e z2v5pooI{#~-%NO&>W6z+(`P*LaULx6iatE+!Qt%sx|%oG3;HiL^%UwFrl|X`l=M8p zlkDj?^wE7e!xC{ec@jO&>`uZ@qOKVlK-;|PbGn^=yN z^EATi)P29liVrd#`pX&r9?QWqDIE4bPSX1`4}LP;7nA6*hwc)L%Hs&zDfw47{Cj$)DMT*M+Sj+Jkz9hrY!4Cs>Z; z&!-7bO79n${^wMlaFVVc5k5tYlOY=}e@oQNQFDVS}B0MQw-}c~t^5Eywtu9Hs662$-#$zD6!p9y`SySZ ze~jgPg5^lQ)zB?=iW>i$=X%o9ZE&odvQG4V-{8@6L7L;wrd#q9HU5{8&>-P;YJ5AH z=|4$$Qa)gBktF<(2S1)}`API=dGIC={sF?LsOJ&$et>Mf!{CxD(YMjq10hN8uRL=8 z+e3dM4NdCQcwX}79Kxpr8P2U}Ptv6ZUliigI8^Y^UuWb;O=zd!dkr2v?@0Z}x4%jD{0DHl2fMCjVlw?pJ$R76tfjoXVSZ1k z*jBu{)K|=#3G3eewz7?C%;!rqZC>KbhFOJn+XP()uo%b*GCJ^Yi)j zUH$pCO`Dd_Y{=)^i|Y#g9pyZ+T$S(X?kKfglO?jtDyI!*W2!s5az#tNQRdQ{=why& zD$i!K&C6P5- zTv}UbyK3>A?8;>=^)S%JgfkOvOhY&)V&*vf(Pqk|B3jSD3>&#*PIjYM6X`TUlcS6| zIx3o7Nk$jXga*#0OP4Nf$*#(;TDWL=Hp+!4e`aP;;@QQW?Tfpql$w{dQ5Ije>a|X8 zq0%_e;)W<8kx5lnqhQJFX7m=<&7j)4X;Yr&l=`~6sNBof4Ml;`D9 z&l?&VX09#tQSG6MLaR)gXr*&Q1J=*v%e{qCxv!}$+ftx^S+bZa!)%ic!ze&yH8zZ1 z!(6)z=tvD*VzP8~*VQGe_$!Nj{hidN(Ke{@wr#j7zphZ~2y-XO^LZB)%S(!VZK^zU z0mmA^T)VD@>WIKn)*(w&)*)nbF0mO!f-38WsIbKu89ZlkM|YRa<*utcDMjra%?XXd zHbhgKrA9_AhG!zVS~|F{n@&`<6_f;zzWnE`Ev_$h9cl5;Dt5IKuPhnEonbyz;jX@Q z-MyVns%vkcnok{mCoM-R(GoG-44RtTj=)~()?4Q1o0pbK+3c$N{HlD*l6=eJ{Hlhi zjX2p?S=Sr_RkKWmaHCBdv^B}JK_^~S4Ts(KyPn#>^Vk)&!7{0yDpF^ns;v#O1W&pq zN6c`!B6f$3!OYl)cN?)VjCOLx#8>1>>~<5+6CD*c<=6^=SnJT_)#gS%U+AM%gXOS8 z8huL<8%EDrXi>fR=-KC(`vjV3zSP&Vt*dy%4SDU#Wppb~>Kf?wU!SLzzQnfbNLv!|5%wc;(|lHh_w?8ifZnqXNLA-R~rvlz|8UU7I$~{lsbykRF34ffW`o6v9@4G zCrJ_Y752?rS?nlEwkC+OU6zT62J1_>BjZwtcac$77RO^&IZ?_kr^EKC8g^8Xtjdnh z6II!$SgN8yP?(?y(h3x+WGgi6^&9HVIJmI3w6S3(h5JhRwhro`%~EB0q*~VvRjXPm zi^1SFx1&qsk<+aCN{f?p6+bFpKtH$&TpW{yN+TKkbI({8!zAMBtIIgjt`zcz=4|gs=a%a;IZ}|o921pL{Yw0KW z`v8&y-bO#cKL(H-@OJtMz8fGp;6?fgeh45r;OpooxUAiB@fY)ZX5i};{izDypzt}2 zOFqzRCgWbC=zA4?o5Fh(-lyH41N1xTbGm9QItR=nIPe%?j^Sc)P;4D_q<8DTV8D|FQ@F zi3i77)o^Y-`K`irxjdn8T~AKn_wh#E|&)tuItHf z7?<+8$yh;aig-Q*(Yl_TtnhbGoaE0L3fJ{yhQhTys~8u(ds%Nm(d&A$fpL_}JC)wg zI&vQ6{^hF<{t(N*$HD)L@%tG^dbcb2KT!C)6#jFC>-za;g}+|Yd z`QK3Z=@f>8j1KyV-e~~IK~5+A1lROeDO}U*@kurG`hHpsz3x}5q1Wx}Wn?p)l>2R5 zKVM!LhvBW^Fz`=u7+x!ffy=!D&<2ISm&5RA+RHe!3tg|I{-a#} zj((E=rxEYc7{hD?4?$>{56&<+4T5>vGwqa9u7p z5H9&#O}W5Mp-;0+l%ua)KFc)lbh*4$;eXBL@;POvE|kTG8urxlZA_Ty#HQ zO}W6%(Ui;IE4{j0-lXuq=5qO>vQwAK9SX0eTv`>qE|)hdT$hW!UsqEuuydqx5mo3{ zzf3X%2%H zKXJ=A0IVP&`K=rl`d9I_$OL{IWAJX|u+YnT%UudTp2P6=D*Ob6A5b`CU4Vp;`&c}3g4sfsS1Bg;b$rw>x|)~T;w~KsSY0Y zKQsES=`0u41~X{&iS;)~sJGZrm_hHa%fXEHLb(vkSlibZ%;@d57wg;F^2JSU#h!AW z_~=DAEr?I_q>$5TkYGznN70=E*t1ZW{dOR!Xkhxr2 zN@!>ZQJbTjm=3idF?#|9)7u~SBy355G7p++R zO0)WqB^5X1*Yy@?QR0mCy|k~Hy;DB3|9==4edC}dW%xqI(Cu_Rn|^%T4t*cLj2|`s zoKf)0bED>;I|_c-3#a+#(RH=LgJB0}_f*kBwOTTLMZv_)MtsgR~<=


SD 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
    Ntl%z-5DgY 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 t%^zsvfwLOz>(`}q!K^8b^onGL!)j$h z|0ESY<{0x9Wo2{IhzZ9ZbBwrtSjnMD^U03nxfj_;POEYl-0YT%>=MOG-Y-&0W+hxFhjJ^L6LX zlkDnVkfq5{NcNpxkfro%xldEqj?s=1YfK56&Vx$)&6J?@Yq@wg&r@Pa9&9{sN<5qg z8NvjpP2aN590O=|I&v=VoO@uZ-TWN%$fFof{6%{Gt$Hh}zhf>M)o$%m zOD?CQHA1!yWb}Y6Z}DSCBK?#4FMYmy()u4q+fz>Ml{5>#lC5{2oZR+y%C2pnYO%82G0bfzbQX1{MP$q z&d2i{VLpFDALTFS{2HB~J0&c?g!7AZzM2c*QO;ki^K%!3<=^CdJkt=`&$W{}?9X}G z%vpfvA$n;Y&Rhcc-Y^25*9h&*OSe-E=O3=~r`vq|Vtq9@g~4<#o?+({%vq2)D3?Ux z?>($1uDzj0P805q*Rw?QY+^mW?b3(JBgC~E?BMxogznl!zFXq+cM~Ahhk0X5V7{S-BFLM4U2ub-b z+VX{jHgG;ahHbwPo(ExmS6j;PyeBA=c|qjWK0%hwePf+>Wv1`um{}uj z5#cz-Kwj1*E@#fWgfJha6K2Lqq|)IuN3Fv;vh%m?s_;;AFx){TRoO zib5iv{G1%+9=j)c_-GHWi1212XwOd0!E>Av66R}7vX+h$;TL?;45@^9b0L#iJ~j%C zyxDU{@)G82H4#ku@x*5|BzSfk^Ph@

    AKG~OJ%?K8;8{WbF?%*{R-859y`h8vsK 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

    n z>N{_yMS<*2gZ1Jw(LS##J9MHgo{EB5O;FT?q4 zzdj2aIxnY3=QVVy)1x~ZIHmhXf!w)2N_Xzxr?R25xo)()q4Qqd=!%9;yj~Q@Gxee% zeYswAD;!1Nzo-}8+0gm8{$^MlLAhQ|=>@rXFcN*Fz4L4&dRu$v%}6xf9!i<_RXe95 zC0daUWtkU&A77?M|Ca5%mKKHYJJb3sYVB-}Mz3t`ycdmrmhHsrM1icSvnmC|U#0hX zskQUw{?T=O`?0+IBzzI zZfoPrYZ?Wzyy+;AE^gN6xwg*kX3@vmI#(SY{Zm`#k;9`vUOoI}%-*V4^qscO8?nCd z{r(nxmb7!O$%>Y=bCzXAKX2=7%8CN{R~BaPiX)@NOO9+Fpf3lU6O@6}yK(^Y{}6(!-JH)2Yr&kz!npg3oXLE)uDU z;42cBM4~?&2wrdUz(GztC3@>Y&fO_d`2JMN)1Z4zw9n3ioPR{4TMu%+i$*ICa_+4Y z1@f0VkAU>L{rf!F$obd)(c2n1SJaKh8#$}$MuFT@Z=&PeRlmE~_uSp$4@tH9=dVj<@CwgC?yKlsXoi?H;m!28D~fT6LBU-cSM}!kvS?WXGTAbzPU2F#Q8L$ddsjJ5Q8IcJuGs-(Qw$H=$Vn3b>}*zm@(*E z;q&9IhesMsgrBqfe-nu;PKiQ?d@p8JiIdC2%btE*w6`+^%#d#&jf305kMnPgJe(4F zKBev}DbC;BL@*Bt<^D8oZ3RQeAK>M>k=bvjMm|Z&#&-#~fYxbg71KS(N^?re5flu! z5^+I*(@*sW&m`b`8;UlhTf5n?tnifG%7?xB;QYdoW=GQN3F|nsQVE&o(xq#dCv$Gi zP9@=yRtkHQn|)6)QEozIp^G;5E^H>lYZ>8A0_{Ou{!uyLT0>Yrw(!dEdSwth_89{t zDv8k4Yf&@W7o~X+3T)rpTua0?;)x21DmZ|}Xr~OG!D*e&z=xSaG2ku@ubTHEr;u@v zUCIPUsfmb0rBlb3V|=USHNDS6eZ})Qu!*mpgcmrE15calnY%ipcn2IxJMM7SWd`K7 z+$|LB>|0OEg9@r7MRj=*lx%n<$SbVa1rz@Jx0`!R1`h!%<={Iw8Dh#yM|jWktu~p0 zYpwC|V1=zccJX{ITx4H5aJ9m2CB{>gbm;*MW7_XhMg0d5-nTo_WGhUkb@Sq1_@9evx;(gJA}1Z2CE0b~Jq^u8 zXGhANw+zrU?3{Jat;)EGu0UU>jQb2)KcUZ@#RtFbriu?JwMrVto)rp6Js|vb{3Y5a zHbijPTKWL;9UOO6tONIKL-S-^cIo0zAJ^IjF zr%bo$A4?Kz;hBGr23{0^V^QKh4jz(9Lxf2cMg@#9d(^0gz8L=Z^y$SFvpRd!Ja_Uy z3_{OMPdqhl4r!x9@=DK!?i=#pe>f@xSQ*~W~jP>dPap(hH)z8tgPP${( z?R?<;v-E6yNO3dukYe*lR2%@j^EVMgNJ zp*Q6B7)uyqweX<1zQ_}YCj9lek;Fa5zG-0)aX?u$Zt{T!}sflTq#JHM`iwdXDAdg{=3* zK3Uu$u)9tx4nli%TbIB4qbXTBLA%M0pysgeIotP04n{G=j2g(oqWEbogkkw<7djCO%_U>cmvS1E>{+UV)xvg}~%WT0{@0?u;X+lrIT|*pq-u~tttSl+KEf%E^GqAAWhb9o= z!#!&`Tt0&J#&!Z~1!^qj$9KSLFhBl@odGgZkiHO(gZGE%H@x<&>7p)}h4gi1x42(D zE7_2%WwUAR=Zj&iI%5o1?$9LmcJI=%VQK_o5te^u&SbvZ?;|OiTkRB{3Tak*v#{Ok zd`pVC3%tpLG9AyYu6f8#T@@uKlgn%8=hwhPk=yQ&|3GRW(z!B70#@`L(9s2 zmWj%kuP=wb03+1Q93dMtGYdP83U4=W^=2)=x@|hJxquekkfNRjG%}%C!`P}7vHt<3 zOl*PpMlF8FvVNnM9@Q|n>~c8oP@0pT*A@lgIbybr2#3bDZV|L8JOR&3Xz4bP<9WWy9Q;M_oC6ddN6 zP3zG_=fv*qeRTl&(*re*g>JaPzQ}QuVF}vSP-KppgDYH)_`-VAvlm-dOv+mZ9=> zW&UPrIoLB`wv-l!J_#b<3(_A6{yI>Iz@-9RjqaCq5*p6EZMN)Esa9Qg&diX$=~5o(iUf{MYSdR72NgrOFDFbuXNz%a;vK zgY;pB5my`GCV$kcfk?+YKAj7)19Jj6L-LBsU(rVYTj>IM!pemHzP6RgqY9SKjbL0B zVc+DsoWmAt=w~j0n`#_iJ%`m8Sb6&QB2~W#BNYy4CSv_sR08EqYsO=ag&_(f+{uGI z(Z#$c>dpbJ83&wt7Uq0#FjtqGw%?N&sbRU){`RcZV2)1}!i_rdFN#gIi#ZyquNjG<>xRU{ftH$U&uGkLAWSuq_b6aH^F$VQ37lx;g_3EyzU}@TO(hD;d*J z)USL<%izJ?xe6LV1?y9 zHw`DgkK#=$w;9E8T?t)}IsXD1=6J)DNwp>oet~&=uiBi9Hmd^O8LK>bqIovlraX#a(K+M{)*0q-VCS zOz$C>-YHZokp)vcY)X*5ec1&~l#5#U`6t(<_njudsjm22}kIG8Rxim z_o~Kz8@0UQ~(kI=e46_pv$8&!93gwr#RXMHMb$d zZ@hxavjqz?#u4sDb_~1=ebKCH+p~J$qD@s}4UHx0sl1Dqkex6qZZl1v=Id9&=FX5R zEGFDy!B1E*db&{c0()!mW}U?0DKf8k-IT+2PL!*mRi;A%du->@Pc;#@%Fz+Z5jq0k z5)lWOz1S+yJ+o|cANNucG297W%0ro;dVP`H}wr-?{Xygl* zwF|;qm?zA`-D<^eAZIX}vOEmO`>PYK%M7bdPo=ADxz(6oTy#Scd%VX^Rs^QSa>M!-Lkg67g zxuUsMPDXJl_3ct7ptr#zq2a1?Ch)t~8Ny?I8A3CdA^022(2hUiL--)qp1lop16VQ5 zK-$}Yjt!R|rsct5cwRv_w~+Wq8j(7-f3IcS#S+5qf4-LeBS84>tL|qoCR9h@MjCZ2 zxJt{Upo6o$Iu3Qzp$451fsHK)OYfF#O_a{DnsCHf2qjXx0ZA(--$PZ~q&Z+7`V=@# z5FcJ{Pjq}!NZ<7(YI_t8R6U6AegWF>fq9AVT6gNfLbnQXge}NqW1Q+r-CJ;=Co!iH zOlPCA4!xi5?QmWSnxR=&H#3-lt0TC_7=0o4#|YHc7U*KJ9|CTAXjNUC(Yb*y@rqn4^UDs+;1^0~LWCSXUO$Ja5a`a?)TdBKF68uciK1I~YT zdvm3y9FD#LC)=Z!-NS=_tP7x2B~Z@#I)Wd76bhSp4s3)^V-nAOl~k*CPGnGf)AHN^IK|H zH8wx%sfSSc<*+>m|Kk#h?eqS4M)3-@B6B6sLH7jpl^%7Rck_|77F$YdF$iIGy&0?y z{WnD(?>RocA#YP|B_!qKmBE<{S`wND0Gco*8NNlmVXG7#uSq#I1N9DgE{VfgDtGgN z^AgC1wZWKCjPIWU3|e%a!&_!3ggz|*kB7IM;Xhx4SJXj#`R<5Pc~mbU0{75~6-N@Wjv?{wl+p_cb>MGfAwuNs6` zDi^2J(t-O@y)RLyC2(D^Mhi!)+GIa#zqPjfhCY!Zs^)B1DxzbtK|qZLoL18d0?!|B zHAh?K!L;ad>~~-vpo{NLs)@dR0K0AKZrHRYyteb-)~s}4g1vx{VHalpt8M$(_KW6L zIJ5eJ<0?(SbCt?BJx^ms~4EzE?(KNI({h?V62HabcJ1Rviqo|FxK=-4(Szl;~WAzX!(?2!$h{C)oncrOIvnxJZR&XD?FKlbPT`NYtY~ z)Y8wbs(H+70mvQHch-6#;@$gKJFs(>}xi5cNsFN*@bVsCORu=$taG^vbq#biMNH5e!t*-V^-QK z`xxCk?1#!it}94U3qEL_>Co!oaC?6zXf4SOZeY(EvS9~oh<6|Zcy90~-&H5}BEMMt zru?k&3msvS7_>VvGY!OILp9BUj*c$--L3NRlR0@sJ0H?4#tmxt|r;>#oZt}HQ1swxz||lwhrdf*D{wX) zjxeu|29>hNVQG5bka^qbQbX4NRT@JEbR!XVltKX=?zS=D7PF#-^#r2NbIj5 zV|b#)Ju#y4Y8?dg)`3;ZzTJedu<-wo%)GX+`oQPH;ln*H#OkWMUN~UAw+-kS0Z7HXuPk(N0MF6936aUp#iIJ9Vq8;y!ic{yc9l9du#5_$M z5cJxCQ|^0vU1Rvv3aS{cIj2ji@B*Q9dst8+>=sc3gQIbgHHvvlL4B8QYM$#1)HW5A z6Ba_|?nQib0^Xx!O;Prkv2^b*KEy_?6NhCNjmI!9!|s;4S<=jfpe#ISn@gxo*|50& zYvIFvr{`8+EA$$daNGPWWb&$gkG*>dpYFF4<`Vo!otUZ~_vAWJn&R{GbyyEth+C?d zDL+nHlHHxG@?$*ayS9hxuA?2zNv{;C-DJx@CcprwtJfD>=82*DVH_bo^hHPRuBTu( z)v?0Eit5IuG>Ibm=S&rAL|;&;XQEWWs>Hs~^+>#BwM3@IE!$X)pkmsb6=dL`p1HdU z)gzaTr`h90xqH%U-qj%=nnRrrPbffQR<&U;LLcBZHuW^|Y8AgU1v3}3QY3H6Y0RS> zG)j8{j@N&3A-G6DGEK353wiLiGVD#+seUg~_o8McPf=;zd7i0vPl0ORzRIkqH`nj# z+7pESq;UQnHUgQvWt#3pZB0WrY-$)bwcEf#!0MTG6Xw5`tY*FTj6X{EE=$;Nbb~xW zr18~RwCtcOvbI2sS3#CMXWlt1VW9XMPoQ(Rq{G5wdwR`g)bw0~3uClrgIt=5+t=U* za|BmA+nY1$nup)w4x$bgt6%X|ye080R(ZT}pAwF>=++5%0Pac0^-dLZ!t3)O@|7#; z)RKyh&__pC>UN|q{(z%(Na3ge38A<<_7`CHMcY+OV7x&^9diUa?e@bfAe=Qa43}DRKYjlVu>?6g~ zh`O#bbzRX8j?R}omvd)nwbA9-m#fNU)mE@0rQs!aml_-YZ}mj~fAlxMw`kphe?u)g zNz1E!JHyB2L)U>lirpVTw`E_JA)hUL(t9kNExZ>xqe|$bs;%A=l&WDD0XHt|`>yrG zvxWB5+TA&fQE!F)2d)#X8LT;J0grRT6{tHn#Z_Nc3Icb0N^rWYw4gEM6cR8qMoK62 zws&?p=4yL<);4?oq)%DWzW6T65q`BD3VFn=f-vlsdfPVinBXfsD@Ge59yij0grcnefM^ly0m7p|RDv!oZnoDKNB_2?&>e#4X=-UgE&|CD~!9ELja_w?`lIJ7Ko z)3|epuU+BZ3R_to6dbGvFUe9jbD4yFcW>pjehzPxz{@n?!C#B;IRW@Q%W{*Hm1qB< z>Q*nD5JC~H?!d{50KhKSEpJ};-0B&4S)Q8_AQyVC)Jg-n)KTZ@j#}zZp_AU5z7&1d z7&}wbG_`Ysr|i*3Tj*rEaN0ik9er*LdDbe~CI{|5ICQyO&2(Q2WKjRy1Y=tj_z1iU zcaGs^GDV8Lk*uSi`g-j0_dw6DqmtT2g7mEgq;|p!>(g|2#v9vP*1yMG1=PkbA9E?v zr6RwXn8Qf$#xYI;a7k!)3UvM(V%hW)wLgdB?b9iwb&J47?H+Yi4uL3LddBnz`M=qhTn3EI)qx6oEJ_=+xeX-?Hcb2Tf$DSIMn-w(%w?Y>ns^daG8 zz?_GjRYq+Ljc$+)2nBlx#MvcnaR4{z!^qQJ4JEn?rSlvfE!wDDjT!drZ$YN^W}}jd z=8up}>MzwCXzx!Ch|`I^cO!UF<;9A9c^{G`P#U++0*AYC6%d73w%&T{TF0j6?yF!A zpsLv#MPL?yr`WbTh5bMq7J4}_BtgKqwXX089I2|jjTf}c8W5!0YanRRgkRTHvYz>< z`=sAaj-U>)$Jyg){JNXzp1Vsuqlq7&hod*V-%mS4`TT#TF@?-^sN^PIz!x2XnBEL3 zwi>Qi-0rzv@v@fOE83j|^-u5*o}qy5s^(3M3D-T1ja3L3?LGCj466gD+lZIoGeYqi zOiylcDA890Ko9TcnEM8hn||=;FM`)gdJTbv0v|vJYPAuyegM3W>xahn`oWv7>20V7 zOLS_^y<5_)O1PE-&TLddUMqD4BtBI^+bL?#!F&Hd&NlJfgK>DEr?S?4vdq&D`kG*( zv5TAnE=bUc>H=DQq8=@1KClbJsr!bRb-)|DYH)QEdhR)qivv~TEkP}=6A5@GB-fC! zypZQcrubZ+G$6Q>3!WSTNAJzzEYMljx}227z#<+!|7%`*BF%-M{n7vl=RQNu%0dIO z&dN@y;@R0NP@3Rm2TYl%lv)+WYx5NMJ=S=%OGgGz4sgI}3<0Pb_b=U}{#Uv?o_ht_ zL}*W9&3Y(+c(e}asy1(XPmL+T5#QEHFy+K(<;1va37r7yR05?j{SnTB;s2a;IHx(Q zf&Q_h2A1^t2SgyWeb!Qa0Ms|_{puq#iXX5KfQwIHH)l^qNs&$6i&fNNIMss_sh3-} zaXj_fMpK}4h^5q6E7iR1Qf2E{7Zeyfl_Xz9R#T6N`?NS7-%qik<;}|T;BI*xo`Z{Qp4@eF5O%K2Ws&>l=NVXi3 zT@70~E5qJTu?62EXkCBqd-W|{fnkj2mrbbx?WLxpDm@zvzqdYHZ`{`YyaFty%*`Ez z=3(w5{A&e!KiPb*#b}ps6x)ls2wNS)T&1Jkwby2cER(9=GunDqgPxwbmT^LPgZs)< z?`=k6bu`5!Mh0%la}3r#*WU4-A`NU&_DwKwr0IfjDxSvalLhMy#x6bf;8?>+m@9tF z{0FU;U;9xv{10Ar%H;`hs;@`!XNt<@>#felLChNTbcW1skG|O1YRNRL2X=G$=7F-| zkTJIm=r(_-+dG~ieQ7sv+!k7gn{#5Ri|1JqNj#!&{0K?Uj(Xn?IG*i*2(<4avCsYKVp&%e>z1tgq42p7 zSk&I%=q;)zdGCZ5(zWKU+`qWHV~IPQ+IM+ek)8u6k8L3qpWOrfER6E{lm>h)Ys5D< z!CTG9SEj|oPfHALj8s88__aQRj-4`Vde@4V!lUgsBCEGX}tq;|9<#u;LmXdh94L4gU(p$zG>U1!HE+oG>GI#*Aq* z5@*4qKjOqOGbhwaf8dzH8Ixw$!oDg0$^H8Eh-D8SJ8Np;tXQ`W$9Cx0{I0vq_>Y#K?#g>5k&jFwpOZwsEQx$=68Y97^6!$!vDlGI3i2s3_PZ5-Hr4Ub5`N(S z_{o4P9q?iY0^C1V;?T{ z*V8FfpKh-Us-sD>9;nQ&OGZy~$#0SMu3bjo1?;D)|IjF4bDCHt50Lpi>T=H+D zC?4oI$KyZx_!+MMyRiHYTb{Da*dNC7ezyEFbv*iIB>VqNzyC0f2CFziy<*ne>DNC*YB&6$Tze6IQ#eu+~ap9IllgWc%b7*$G1x&&u95uG@|pLGMh4h<(r&DzJTSk zJ;%>9$FE9q{N^Ob?@S=adf&})dp~@qD$`|vxJ+5@`mqa60N_J&2dy*Ml@CiIFJ!qi zFIdd-Y)nMkAE)eNK9_MlUIpI+`JChCV=LR~2kpn$Nj-rY7~0v!c24oPFKmZ7Zab{c zetQl6deT$v=DGbKNvz-e{ox<@w7`FKzDK(G9>#XQKP1%7XNQ0)=4%e?z3TpS$Qp4D6~y)G!irw{(4^L~k&_e}O>6^K1Pz}R>}>7fq_ z*iP8kf%54rm-^m?NseEg%%^FcB@k)b;ahj-k>1y26+|9eZ9?U*&8^8l$$bJZ$b7gQTlD9qem8^=b9D&FX^? zK4EFZfVX5{CbBV_ZG`0m<6&L`Ii@k6(>Mygd-6HP_31{oaR%rZpQa2Ug&3gCYy-AIn@+n1AcW5d{72Va%1~1$`7Cc`%dPduWR^Fv<-=Y33s_E7r|qBQ z%2y?jw*;GOxXy?8`wfhpJhwmFS_?g_n`Y3j;77_&uLN?;&q$UZg7XPoo>Q+)ElXPv zEvl1RCl!i@=@hdb*0IsE>UTvF`9_w9`85V6x3TGF1oMzii`ekF2inMF z-;advo)}6w!>xa|u>f>TIw@Bh`DB($^Zo@1!04onG+WltV3ns2qD(-pQ6v zcKzI#CTDP{Ew|=Y-B>QQ*%2(4?9WbOe`yl?$6>uEp6 z4nhYwP8ygqyN%`293+h7o-(MQ`6Nr5(C|CtlJ;Hd+NiQM-(PV z56iQd<L@J57v2xw8QXV`8-9-1o9Xh*PrDp(1qx#>%<{0f!8%{V@~-gR_*-qSQ_Q@< zaw%qZvs@bQ8d1mKI74mwDJpO={VpsY=8>xnu$I7jaXs7w-#syhF;V8m#2mJh=dshz z#O^Yd=i73$aiVLZB1|XcWKzJqReYdM>((?MQy!%yP-kJ6Z1WGy5?H`KV8mRL8jpz8gPbyiHNQ#Jo0U zUna}z2)6ZS+g8e>CN5_ukjLPdr7VBVJ|6Q@>DKF7*73wH$3EKFS_>NvP27F)Z?&Ho z%cZ^|hvnn!e5R<$GrDRt%fseMn8%4+Cq3Z1r>~f$%85D)SO>$zqhpq(~`!sH0lr>Cu}@JU$kVoRM!41m&S+j zEDsxl(0(z?rS--NmP_l2jY;I&Sl%7dGWBikbEi?`mghVzlgRtCT(Uo&8i(UI^7;x~B^4F5((q2!0mQ(kk^KXs6<5^ByS6Xge zCsfRGseV@^k#9^ON6}`k|4ETxTS^_}w)y(hsmXEBj^$E4 zuIFUs+?~JzI_Af?d7PajjioFf5ln-2i!qJ0 ztP@tw7|6G>+%rGI@xxj_IJm(DACHbb|6zGuRMO?hb<2^%a++#sIiF9B!6A9$r^NwZ)2PeA_A!sy zEWbMyerP$)8E(b1SZbY-&pHKm8Y!oe9BoWy`6sqqmGd24&V{TK*7nfGYL;qJi2sf3oTWb-J-mB7clz9myYaST6Yk(^<|s^w@RV@2lN@dn4;e zMk{v3}6~*ZQ&pIBuXQjb)+=%SRR%Jw$+IVj*o$SKFgnk?X63yw$*@o2LZDBcuzVL|IB82Sova*<~**WKJeXN zm$)^AIxAS`IKK{G^NKo^wXm}@i5>Juc4znpK9axlST2n%6O+j2vs_w(u1u1CCCjBY zww>itJf_oPLSFM^vwSoSuVwM9?PZnFfoaIeiHjDSw0Lisq>$r&beTGRQ3o%ZY)kBXtOllV}b!jCG{8P{?vxp6Rmi`EOjN%;CCv&7T)@?Oe(Rylf7#qF<_6-rts6>mGHnyS&zoVdny$o9($Xj-S`L^Y8wwLsJS}o^#!K>-Z${VwOw( zTEX(LwiScCZDe_(I@!)TlFxT>d?fQZrq|_o_y<0Td@_P{!panbV`sDcF*KxohGXn~ zuHTlijug{tS$>LbBSkIFvF^9BJl`XC&kcUZ@{u07y4VemZ$_OZ+_&YCtBaXqzMd|FnDe&FXFY>id zDWg=p#z3CWwsyjIV+&*YLpP?Uvre9^!xKx)??RU6*mAIeXMa$>n&s3*>ik-Je^o3G zYcnx8eizF<;|S)_+K+D36BC!u2X|q4SQ?neVJ!E=1f+qd9AY3ZWO*V#EoB|aPvtDn z0eiNuwV$@IT=LT%mWP!g1|}Q#Lc_juLYAL!%xuZNJO{peVgvQ~92NRwJlm4WQq1zO zyx{RGSUwBBo3dK>Q*LBA6-md0I$cO>jcqKK<}PWy(J<^);y?O$D<)gAJgkji{`#}L zgMB>jccY*3+1C%k_kf@7a@)oNwj=pr70anf>U>&js?98y`huMa@`>fBPXQ~>f!igK z=d)Z|BTQy_Q`=A0Inf14?5|?^5%%%cy*ry(9_GIo9J7<3)W7kX^5^0G1q zl;9)zsxpVfq1S20K(w9ZlTl5VMeS+R&IsnWeqR)Z@BN{?T@rad%fCG&c^0$-a(w_9 zZ(`fGt{tpMBCk#&cXH7%%zq>BkIsK;U0U3>1eDIcz8$`&!T&}_^&N|_*0FEMV>?o8 zPE3-{^jfB~I!QWJEN^7zRc(_{K6kNPioMK}@IYAi;6K_QR_t|Td06bB9|~9=R-YJ~ zBe*_l6PwG}mM5>)Ip4J`m)4eBS$>pVmNBZGVqUg!UY>*Rp1RfJ&*N^J&ORB9B-sB< zBA>`|sU6H`xfJIsSx#M;t{0wjpx-N5F7yvTv7Rx$hRkvr_-Pie*Y)h&t|#QuJTwemY?NPyP3~&seCJ0-V5?#+NCv@ zt7N(7oQ-uq%668A<-aAE+{N*6J$(1H1#5nce&~1#`~#mbJ18$;d3#jSacVugW;)Bm z<~W#-*<4R!;d>w-d`($4$dWvR{)0&gDR=&y*=Bt;9n_G23BBRlYJq6xd;C%$%SK$2wo-6Q^1wKIFrwV+azy}NbG=UEl_;7)rA@DN=ewM(` z7WgQEj}iD-fsYgT1c9F?@QDJ)D?fstROftwPZ9Vufln9s41pI4{6c}x7Wl;izeM13 z1U^^bmkE5Hz^@c|vB0kq_|*cB3%pd|3j|&!@aqJAy}%ah=C-z@N#1pbP^_0vd|FZ92u z&Z~m{>jHm6;BN_hi@@Iz_*Q|xC-7>4e<<*e1pcwWKN0wLf&W9`I|cqvfqy3Oe+m3^ zfqyCRuLS;Yf$tIcHv<1w;NJ=Sdx8Hb@JOnTVf$~YlPd5ufky?tpTN@vzQ4fh3A};8 z8wy-M4cIO%_E!fA`i%sBh`<{Qyotb@3H%6w#{`}w@RkB^CGevK-df;o1>R2J?FHUJ z;KvBOlfaJ^cvpcRFYxXH?eU6|%THs>^K3?GG3j92QPZId~0-qxAX#&4M;4=kYDDVpfK3m`y z3;Ys+Un=mq0>4b)mkay~ffor}KbhMfKUWF*^96p5z!wPoT7fSV`1Jx`B=8#qzF6Ql z3j8L4-z@N31-?w+w+Z}qfiD;M9Rj~g;B>d6x6w{B?o9 zDe$)hzD3~g2z;x+-xGMXz&{Z9M*{y?;GYP5yTEq{yhh+V1^$`9|0VEU0{=qby9NHW z!1oCJ8-af-@b3lwqrfBfX&}=t!g^5PQGxF#@N|LK6?lDtHxziLzz-1kK?2urOffE? zFR9KUf_`IxHxYOo7l9uq@NNR{ zF7TcL?=A2?0`DvEege-G_(=lK6Zk0t*Kcg`$MZlze~`cn1U^LI!vv0RjtYKKozn$A zLf~f#{0{;jDe!XyK3d>o1wLNj=L&qHz$Xd(e1T69_%wlEAn=(2pC#~%1b(r=FA?}0 zfnO%@c>=#u;6(y25%|>tj|;q1;AH~8PT&g#zDVGU1%9KzmkRtAfiDyI?E+se@H+*5 zm%vvD{2qa?6!`rDUnTH|1io6}j|luxfv*wx69O+6_)`L3EAVv!UoY?qfj=wo=LG(| zz&8o}F9QFoz&8v0Wr0@-{565UF7P)6{x^ZYE%0{*zE$Aw3A|e19|-&-fqyLUPX)e1 z;57o@De%t(zDwX=2>eTdeRWTO$6Rl;D-ymxxixr&k}e`fgdIC zY=O5Ccsqf25O_y{cM^DKf$KMJ`s?vHLBE^8dkDOjz50~^8|jSz>5T4BJisOK40M1 z2z-ISuNC-0fiDvHVu9Z%@S6m_RNyxY{8oYACh$KA{0@QNCGfiieviOc3j98SKOpc` z0)I&04-5Q}0DlOE$`rUSW+mOE<2ZZ^lk*<)&zaLbI6SPTI*$hIpeWT@Bk(5#UM}#b z1->@Gf1o_o;hedD4x<}V_ICk)dy#nE09RM$*9-7%bcI{}0G~i-IvNDH+VQ44sywn+ zX=YA$vw6505i>e|$wHJt)94sHk*Tokx~U+^!`ho<{r-k1qa*(RH_n2KX(+8wdEY z>4**s@UMu|9dRDnpUCy}1P>4Y2XVZc$@}Ro9}(bB6K@{iUl5N4cx$R! zyqn4UnM1st7s9XCiMJ2%wiF7-1b6{)epsX>ok85bx>*Sq6Ypbbs;_H^=LYyY#7_$F z!zl#$rc6sZnmFJ5Xz{Cv>sIax)H`EOa{+&QmGp-M_?N`b4)6{X`sW1r1mfJ8Skm{2 zkG6>VdIB|-F#-Mx@$muPhnmoN0UjrQet^G8d~$#vL^n%L3Gma1UmW0#=wWl01o#`o zuL$s~s7YTL;9aRn-xA>j2+I{NDi{ zqptAV0AEeK0gW=Y@MP*D@y(FlPYLnH0sa_qHHz6syiUAHK>thPZ3A4rgRE14kEX7< zbAT@=er$m6B7R(e52miXcYxnWJSV`PA>KE@e<1#c0AE2v!o&bSo`!@A0(=Sa!T|q( z_^bfWpdsYK0B=V8;sE~x@hb!TX5ys*zLof*0FTA6R&NdP(Zp8=_beS!TGbYLxWFU1Wt`IAWLNaC)j|K$hxs2`~hy>M8aCS*m{cvrm%h9PcCQXR6ap;N1n@L*P9H-b>)U z1%86S`v^Qo;C%&tqQLtJyuZMM>poOWb%N_Y#ZMOO1lN5^Ke+Bw{1m~?sRGXz_&|XV z68K<&7YO_`fe#V*P=OB<_;7)rF7Pu1K0@GU3j7ZOKTF^v1%9@`&k^`2fsYpW7=e!! z_&9-&7x)B$pDXb51U^yVlLY=pfuAq%$pR1V8=zvUGgZ)^Ch+M3zd+zK1U^&Xg#w=? z@CyZgk-%pQ{9=J$BJfKEK1bkl1%8>pFBkYcfnOo;D+OL8@M3|N2>dF6UoG(Y0*?#) z8iAJze1X8r1b(f+uM_w}fnP81MFPJ;;EM&mMBq0H{3d}f75L2pzeV7;3VfNsZxi_K z0{@f1mkaz3f!`_cy9B;M;CBoB9)aI0@Rb6;PvG|p`~iWl68M7xe@NgD3w*V}9})PY z0)I^4YXttdz@HHKp9Nkn@FxZSl)#@B_*#Ll6ZkU%UoY?qfj=wo4FZ2o;2Q=0yue=& z_$Gl@3j8kue^KCn75HX>za;RN1^$Y_s|5b4z+V&i>jHm6;BN~2ErI_{;9CU#w!q&J z_`3q%D)7Gx{5^rcFYs!Ce<1J=1^$u1w+Z}Xfqx?KPX)eR;5!8V4}sSRe5b(wDe%t( z{x5;=68Pr=|3ctj3VgS~zY_S@0{^$b_XzwOf&WL~-wOOYfqyUX9|ZoRz~RwkA)izy zB5?C~RL@bc|1apL2|OzBIs)HM;OPS2U*L5GUQgil1s*)_i4IA18VdUKG<}cHlzyh5 ze}KRb6!<{`ZzS-81s*(atMYlMpdUP+tMr5Ca}^Js&sDssV85Bb4;T0m0&gzxn7~^I zJWJq53cRJjTM7IqfgdgKY=O5HcpHHS&!?+;X(#Bn7kCGOA0zON0uP?YSNRE^$5%Xf z9$)b;g8i-n51#i|c8(YHy9vCzz~%I67!ejkAcuUk-dg4Zo5exhKf zpTPSIJXhc+3H)S%=Lvj(z)unQsRGXz_&|XV68K<&7YO_`fe#V*P=OB<_;7)rF7Pu1 zK0@GU3Osn-i;AnW1pSc$KU?7E2z->lM+4b)mkWHJz^@Sal>#pkc(K4s1b&skuNL@xfyV`YjlfF4(^*9m-~z^@nh zB7xr^@WldOBJdjpev`nL3jAh)-y-l^1-?w+w+Z}qf&WS1%LRUi!0#0JT>@Vr@Vf%&E zO5jfme67IO3H%v>uNQcQz@HWP27x~(@Qnh0Uf?eXe3QT{1^yR-zbNp(3VgG`UlRDs z0)Iu|RRVui;I9e%b%DPj@HYkimcaie@GSy=Tj1{q{9S=>75Lu;{+__!7kIV6KM?qb z0{=+h+XVixz&{cArvl$D@ErpGhrnwDzEj};6!>QX|Chjb3H)<`e+ z#9JBt2CTnRu>Upi1FZM==`)x0jzaFfKT$WdW0>pT`tNDPk4|wI6mYs10?%?-;<+@Z;N}{xJdla^eFF z@6PF-)-GKCHR7F&zD{>>d(;o|(>owPHlXhugZxy(b$K@s59&|ui27ZPzE1ZCfiLWY z`tJJ>wSHD-o^Bm@9WG+Qx3Wac#9PGxdG|yw;PZ)3zF1b&;q9|w-*y7B;JWh@)}yP*FS z@GQrDk70k-Z`U7wo4V z7jC~j@GQrDKjR3_=Y_yA-7of6K(ADn3U>a)`u_Z^WqvLPPEYP{-UOcIxbJ_2ZjC;f z&_Kfc&>1-9$8YCU=67;FbzF^SUdbG~7y4WQJj>~6>P7QIyCGLkr9j0YoX_Wp_YUZv z0u3t5nP9lq{}edpa~sFo9F?q7rw8i0@3m~gd;svU^3EpxNyh#msp^2o1pUu}W4bHr zDZN>2zhO_skEpKzXUpl#yd!hy*61@5cvyaxvi>b=nedw;~bArIn0FLE-iqq9QfR_Ug%l|roH|QO%pDXae0-q@G2LwK9B=(=~b7^#* zzY+AKCxqv-zrfEF_{{>pA2|ARNJHg!?a$Yk|AQx1n*S)+IlNDJK05(N`=faxrsHi4 z^J|$y^Q6x$f}Ph{{{_~+gZ10zgr_@2;LiyB8{nAFN4X=^Gt{nq6`y#JL!W-?j}r&3 z>y8oq`8(^cV*N8CN_ygn;rfFGzEI$|0mppSIat}%E98S9V_A;-epo&3cO&k;Pxf%m z&syT{`(YPwAwDGTzE2jyl|E@OAY!_MvefUn%ttZb?Bi>hpK_#9oXz@&<|;cIm}@&T zndh|h>c7Rj+{ceUDcqm41pbD=os(65zBojstLtk5^Zdq&w@XofR{+m)X7ewcd#lfj zz{BEUr@))SJPG|dyNNo!16w=`c$VY7hgaL5N8Ei6udc^~2PixDG*fnTKF0vha^?i` zS<3pa9pTk~o%H7h^uJ~OA7V;h$JJ@4p#95?z8=Tl29D+G*21gb`BcScFo$UXedaS? z>C>+Up5@F7*uOYm+4<0CXAASjS<0@q-*q6`DK>W4-OiK5uQXiezwaQ_ci$t-=A0LZ z$Bn+WbJk$gzuItZXE$*4Lq`Vpb9tK=pnj>**Zp2!;HclflT!Si<8d7Du(-OG>?|;L zxcZ%k*bc5Q@zY5Cao%A5nU8i{c@upWBX4Mf70-an12YI;ugjS{9MQL&GbKn+ix!L zf@|!A?2puQU0~VLR^%`dx~^fkLnFP%x~ia zK1<+B1YR!i7X-dj;H@D5!t&W2c#9PGIg{z^pAp2}=S*sT5pb;EO7IhYV7gA9n}BCo z?-Oszycx6;)K7<;-=z@fh>BeD>c39_G*guznh(Z|DEWQ7YZe%nw##XDIM2r=Q7Z z4)a@pw{YC&tj3scCH?1({vq729y&VQ&N;xt^0`6a-wV9q7_=YU*IiHiFD5_Q&)vtO z{$CBR=cvz8;+q4!^*GcI?myo}e1OsK&USi@NBvg}KalxW;x8FKf%zi%61Gn}>|EsT z`{H#zHxeIc?C5l-o`?Fc8?MuBJ`wq=hU;`cAwJk}?VnDQP~UyO{L!4xONj^dUm$*3 zz)pidqMaZgMm)G5yNq~n-|{`;?tATCU3EJXc10p1cEmF0Y6_zJd@aUt@r3~$Z+72@9- zuFE?YCI(r~cLCmRHuCQc*X8;P@gEJ>`M>mH)K5*-#nkz4dI@s(efOF_MLcTsb^aG$ ziuw`5b^iO!L4KY|SJ&@7#3u&$_r&)zc650M&qX`whU=(uK+x}UCEA&0^qa8# z1;m4PJ`(hM7NMP($!9CJ^CIyq!?pc^#i-xX@GREfOuSWq4=+LeqYXct^{a@tHeAQ& z;a8!4Tf?<}Iq_o*?-5ak-n|<2gZqTe{P6j}VZgJT;C^6FL4O$OcQWZ}|Li7ytl`=} z^W$j0tKr%|S=S&x-f+E+xQuvr!*#hHEk*sFhX0xUHe>Ga|+yNL()2adlU(;Z~&=y7=}@!L!~)U_RPJh;BzMf`N5uk+d92F%Ye!*xE7 zB7SEepZUZ`82xdapNYi(V7T`GeBvVwhv9}ke_(0}25D&)Zi^MN9 z`g;7@e<|9TZMdEf+(JCK-f46*>Ic_5Gl>V+J88F|{>8@rft=5$h+h)m({4rmOAXiY z&}JF(;QHkj;&Y9@wm;@J)W0mikG>uG<%VnfUlPB-t@FAL`#6;1}MH zJUGwKegOHcMqk^1iFk0{K4%r`-xkns@*whM0sb`c+YQ&{TJ;d>FE?DLTktUQI}F$5 z+J80jy8?Uz@w*N0!1Z|0BdC9`;kteciLW$V$HVKy?=$>Zw$toUwDW-By5GB>_=ARP zJL!+1{zHcAIJ}7X!-hk5N}tFY)PKZq9na?zf6Q=g=Pu%F3?IREYKT8!xXx$i$I*Vd z;d&f-oA^@!Uibv+uQj|b+dmj4ep${s!;fHo1M&5SXET3~cyRuFaXH#)XY_TsHW6oX!*zWvYHc74>%+uG1a78Tl86 zYx@VkgnYN*y50v7|Jv{goX`7+?=k!U=4mgZoo@{9#e5p^Zw=S|Kn3wZhU;2qZ@BjJeBuoa*M5GExV}o#y>8?O;s+Rg?axlHVm=!g-ksCEp7COT3fO*Yox} ziBB@|qvPr`f%kX|?RPeI25^3^A>PICGnv0lJh%>O_BXV1oYC*f`sWi5u2b$K-p%Nn zaeNEf>2A38+ttK-8m{B&Y2v~4Oa9wvr?=7X!}+QE4)Q*RAIE$n@xF#@{Ttpz{eFgP z{d2Y=&ox~8|8C+}1pHq^Jh+Z%{&%!wGREKE&|R?9bwA)E{Q}fz0ziK(4Ry#&d=0bI^y# zPdECbneQe(!f>tsz(=TmW`K{`hWrnPAIWweCLWxBHvAa%M;d+Ie~uu2j^R2E|3*AG z|Lpn++8Jx~bv)lgd~|>}{uK4c8?Nn-A%3pmy5IYd_(a2X|KDUg+L>gyu|xcP!>?yQ zJWG6v;ZHKZc?a5=X1K23=Kly^pNI&k7hgRHOOZg4&5w$(sm+$&a{hO%yWo8 zZ@4a3si41!_zOnAKii4^6YU3iKjM`}U#EMyz@H{Q%jEx5wm;xAw10`=H}gF0d*X8p zZ_D}@{R{Ok3-Hg0&of;6dF3wDztV6W=dsVj{XZ5s?1z|gX**vKFEVy?{l5DJ>X#U< z>ucec$gehB*Vk>kk;e_!0Wfx^2EjUS{}X?1z+pBVTCvDa@A;Uu1Yb^Uixv zf3e{snLkSWM#G0QzwjH>Uuw8cchrB7-(tA7-{4#1%M90cJ|up-;ksNme~0?P`EAGV zkuMME?;(Dt;kq9<{Rh;)%Wxg%j}u>EcylgS>W`>@kKrdUA51(r|12XOG5Wgyf13FH z0bVKSe@%R)(bws=gd6POyrkjUet+Vt4A~q?Z@4b+ zeo;(!li|9&VZMZTmEk&{ z9}$1u@L8Z1Lv#!d&$=lR5g^W+zazi0FxWc{)A(9Q>j>-pP*#6L1zmuql+ z)c@FUo$lwva}C$?#%>Kz|5L+tKUqqAM}U7$yvA^Cr&B|;6P&M}Njx}Ty_xtxV@Jo^ z|KsjV;Nz;Q$6xlc2xTv8ODVLJQZh-}rmWqjG+kp;pt4P;$+R8FMl$IFsO%I(Hh~`~ zC@3HxvZJV=fGD7{xfTROMA?;17D4=2qgio8fQzd{^tYHw=Hr=NDT3=pfbe?*e|smdfAv`D82q55qt7 zxht11ZKd)b`P|w6tl=LQ@cp+|`TzRdwNtkm{y(3){>+ZssQkJcSTp={9NmVmqM@bTph!o6h3Ug`33ry?Wnx4f3opT(fap`;md^&8&KHp z|H1IWc6_&;RsM6ne_Y(w8(!G{E;oFO0{PPo-_qxPVY`2q;amCgW32yQHhdeO zyF9kN9LyOups-y&)bMS6`C(Si#li>KfAg=~jr{h$yz3`FZ1`ZGyZG5^SH13zK6mlZ zWcW@#clrD$h8MP{|1o?QU*6fd(-74^#OJ$PW9tkb>T_q$V#9~|+_e|qGkmzuojvav zzNgRKyvnqpdfkye|AM{lC59KagR2eyZ9&|Q*iH3}^7Wi&^_*vTVSDsj!$?{gOqiwtk{xhwbY7~bIXq4v6;7`}neU3twN zqxui^xw~$+;fMR&jpGLGtMW(s{O4BxYla`~bC(bIu2T8JeA{UFF$MC=4UfpThDYRE z!&AN<7oV#QPy5`(;jo0-)8up4e`qm0<8zl!?lL^KPbEp5mh8M=$?&DN`nJ@3^%RPpF!RPLNHy*F@C;HsQZQAfc z`I`;@qAx$&+BvsQ^%TbK`Gyz9=N*QB+1KOj{K)W=eSV?UfAj>^f2z-&{Mm*V#>4f7 zpXST&WA*&c@H2ew`Uz8HtmZ-!sw%e($e)g+a_*yjtZJx3XSsn4B1zi9aX`P}*Qa>Fkx z;CC5*xzAmGc;4`D_&jB=J8p7x`*M)*-3ENemv?PYli}AD@M{gfses=bqyKM4{#svt zH*3$pDSF-OeSVPTGYtQp&t1J(WcbYmeBx2MZ}S$P54L(v5P5em7MZ`kWAxnS%RBu) ziIIOYhQFeGU269J{a%dx=2N5X8IU@nF*hqQp(C4V$}G=zWl~M;ZC$y}?xvjgQC%vP zZO^u4?XQWNbW2NnQ##k)nM!vq@nptjm$bEaX5^PS6H=)qZQZG+6)R>{CsL{A%;I!+ zOD-i}IWE=F-jZ!vnG~@j=FF^V?e3_X-+o-Cts&Q0Kc_J@uKuueOLr!jY|bQ?B@?2k zVP10n{4b=Y9Xe;q{Q9|bQYranttjovrE}S)lp2*yw`5O{-`d+!>9%IMoM*cJUX{%b zNF6e3?&L|c1`zviRwk^F1fy3D%-ZCzDYDBnwF+JMMXNB>#A=`Hm2o|WU?_= z+mX(8*3WDlo0=28-#WQrbNeDFl8LHRW2Pn3luLBw>Kmt|^vf-ouC99duIf{iOw>4g zQrXsymiop+QnMB%lF6x+YH;Amn$~njSxzi)+&DNc>?An6ae_E3+3yBaMA6Kt?&_}X z=*%=HsvFxobCXxj%Cs%XEj6(fA6)en6kJ8!L0=bkuSR_8;a9pvE*>=l+WdD)X!)zag#`xx;D>rRkY_&>pEG@(t*fHXePWWSKnBjYOM8=xa-hJUnkYw zmOVbzk?ZvO5GCjge3z(FCEXcSQ(uw>O$f`9zBy&;34G(SO+l5a3ObagiPJn3+(1cR z3$Er$V&2Shs=XRezs&U5l72EwBvSLWc)ik?)moLDQNDJltx8Ro2uVp-HB+xz%TqdQ zQI&C=zL`_#ydq<`@)s@NRGM)8{w0!0*TBJJS zB%Fr$Yp9Ny68X-O@>?u32G9$Yse-mz71^M9%u3^!MGqAhijbnNP|IsaO+6QY6>@3< zGYU#e>y6)-+xFY@=~&x*_gHtrU-hr}sW+lxv>nA&SNX%H<1#B{fZN)U?leuf8DW)M zl|A*rfHzUomRX+ihsS;1X_$nPl0fo3or}5OxK^jU`$sa3NMR*5Rj#BG)v3cw@6pR! zk-=$0*-z@hcXUh~cp=~>2NtC(h?#P}9bCH~d$@6>tn&!|SWhD)(=C%dI*X(8IVtVb zYBg`1+5esNHMoU}D1z{;g!V^!@OXXyd%Spy0|!?JlTl{MFqM@?T;~P*bZq1`MY+Uy zKcxqk6+e3e%#vEDpw7Fm*`_)61K$T}ukRabkX;jqj9g4MabI(T=HNS}=e4jdxs_Jw z71i2E3slFa#;^)^(-qU+1;rC?e-g?hi%WI7)SQp zUio(s9ZT-Zek{TLG9N9o?yc#TpyoBqENJEu90vuHGqq-Nrq&xNYL9uGiH%;=m#y9P z9lc4D2JyDvM4G0@wD&r2l@ZcB`P&;LiCKx%-1#GonKYrx4kRNSIxz} zd=i;$`fvhBf+EI6o<04RdK+d&mz;G|5xuu?TJhsQ7phA(2?w;tELf1TgYTIXXFqpI zte5eRt933Fi;rNQ%aXmoXTcV|Yj`UQ0i>Qrci5Lumk9f7f-n<@BO)R-;!jyg{6 zz_%Ut6rVzzRe|TEnyG&ZQb<82O+-ynnR^IjV^j6~fQa_6D;j_Jfx9WjyZ-kB?-rF; zv_1wM9&ZXbRbSRLP(krc$s5Q8=`SLGi4{>jpS5L4{ycQ!RFjY8FZs{Ui!PrLEvSJZEhoGYP_1}&4l&hqM5N@_olC;u#3p3 zE}}!p%IoXFf?{fiD<7M`yrL*khqK48p<-A;Fd!Bvm-T;%zi3c6<@qP@X*e;i-8G%@ zyhoR9BIYfvzr46{1;6GK&B?iqb!*i8xcbmjNjMozj;-y>WD?tr0UJzFHrn1-bObO` zO!I2H5o>iu+_|9-3s?HAGv-MLIyplI6pgv+M8syARIV}S3UzA7e4UG#ma3m2|E!XK zm(fiKInQOywYe&p7r|b9PR{F1ubt*EbQ$MMU9=F7s!!*IeK)T$={ZlAx=b3VZ)?u1 zNZEz51znz7lZ|skOnrnELsk$W~V zs9#9fwf_Z^W$7qU-IZE2wY#;$toz5vR9TsM4Rc~7YMN40y`5llJ34bls9%?mqvpHN zz0-yv*j#1GNA@jz>MIyi-Ie=ut-2&v*|@8?vYql-^Q5c6mFG#ni2G|tpI?;yWk7#> zpkmX))PDDjZ-76$Sk|6Xzpq%%#@(V;uL>F)x7pHR}m|AkMug1bcX)Q_9g)g|Z1 zeA9G_Ca}#rk6`8`#5QMsVKoU-R!M<7wy7nP?hIy47;=fKd9txO-IbZt(gF#3)D>z$ zWuICV^Nn<4a1)KWN=f*hRTZ!ysn>j~N#C>9ZCL9YABLwt3i7;X#36RFt{;2tVM_xK zdF5Hyc8r^s(VXc;sIKgn*<^G$6<+uwjf|br(%zPdO(i8&QP0tCp1aic#rw9mC|2l+ z+T^mdt=okkCaMm}fH;AJ}h1II>pS@oaP8 zB$MAI@JcPr+OF&g-h?(CTqo*u( zXOpd^xuu=$%frSMsbj1;0GMc(vjZCBOwwW_@X@D>GMglUN)zgSrJCQMnHX*y1;UYP-7SCbjUMaIdv7IWIz zZ)QrZ?TPV{TANdgvz=Wz*({h#wJ+AbQ*Fw0UCS^iyCUg*wV+_eno5;4J>R5P!DMMn zDzm7g0GHml<-*5(OIT@Ba3^j=|t~&g4Z$}CcWMAGKYRERVUxirWeVw zq8ctsV@*jn+(4}_GC*{&F|#Sy0ifDqd(_o6CX%PMcP86%GGb1y$adv2ZB6CIbwOFX zl8D~bt+v{8Zhh5l4|n7Wx||Zf^JGU>&xU#(p5Po@^zAq|7bc8Eb$yoNj zU!bgdZt}JZ-2CScNX;s!i`nwJHu+61J4&hiYeuK?M8flqiP176-(< z9Ij*K-FHM~^3>;7rt*}_u%n+Q9BVRd&Hh-bpKPer5t(1l#25W@B1xter9MC7oM;MbDKts@LniO%-CUvE1d;Q`54{ME7eVz`lo)O_QmimFsXGpn zbzqq*j8cdJe4=hrM@P#_No8r-h1|BpYaOKPT*_lgaCXbIJ;o2ED8R$LFdM7)Ri>7j zTzdzCC3?8(`Ypy>+tF1An+?p2H27rSgBYdgBTmTD+?hh^0sEtP~$sn5wQ zZ;_dn9zwzovNB7I>;A^CR!@X4Sifv=p`^4C%5#U_MBTKkZtHPtRXzLKIU**}OfV-f zOqhCe3ne^>F`VsPvQLk&J5B%&GhT^H|T-r+aVzigA#ZBxZ&(zaL|Kz-4ulbfp8U zk80HtFiJZ!!2)is#$QJV2m^ieSVaNPN)7E;Aqx5PyXZ)&VnJM2eW2>E+ zQTxj5kxVh0GtHxt?Ka>t6&2I6gp;(i!O|1+_E@dSJs36S9?XWC*hl0?Y^#yOuW}+< zo;TXl>a-*zv2wni{*`1Z^TLvsTB0`lL~Y!$SMVNq)TsM*8m7%_Y;SZ=538^}d<92^ z>_h)0P`pb2sh>;ruN?QJNjFhn&gz{!Zr0vd{DTL~&Mo)OhCX;4clgPg{pM-c5v{mm zpusll3ac%8INo%%TqmLe?ekWtqMj(^Kf$mct?sq4*Nw#mNy$B4-Bp#i)DWk=yj0=m zihiviarY!mlsEoSk5xpCDaz7HszOB@TtuC6k6(#;uA{UlF^|!&j(m)M;Uj8F)auex zc}B?@t+oAZf4}0c*((C<+@|=m%)*IA}={`#Z~TIB@#lgXumn6q1jF|U|RHnsTkV!cec*oicM%Efi0F0<3Q2^ll`OJx_=FX)oz35`pc*OArBb7+mro`xi)=|1bV}LFdCiUA3TuVeaYk^ znW2%iCb{9Wa!wPIf#NI4f?f)+)vo?i$N?c2CYQ}K&v&kXQ=3I~aARH`AhT@tbq$|^ zYBXN5KxccqZ4xTK+J6@9)mBU%cr-H=9WatSVkR9VrOZr8o$xwJ6`zqK-(FI&b7eg> zApP6`x`|qysn9g66BRw0+pqOD%38E7(p&7u$c-{Cx*F;ti*396H*ZIoTtR8?Gishq z!u91O;rfb5!cmTo4rP~fdmb$n49WOTlBBHVt@(hg_e;c#pLBp*#^gv(^As{9C@_cf z6X?OaH{zCMLXGsOnlq*^Eu&a7WY=TOF#YAZ|PT@QqufET~oRv-K2+c&Dgor zujlQTFX_T#^Okx_`liM1&y zVrnxJin8m#>nFRp`<`|x#BO~MpUPBsU%m~tI(QrG8e5tuv~+F0U>2r^U*@$Y@57a6 zy!aV*ZJG#ttJb^a&F$jR-d_u%>o>ArKwnuQRZ9L9d-pvS zig;&ghrBvU+bG?`$7Ql$CRx@7^LB^ZqaEYw+nVO_F=x@=c8h#wU!?o$)J*WzzREx!G`@(=dA?p8le#Pu5OI>{L_SkiMpS{&7uxZ~QMLo3g| zytLJizALJw_Vm3R6Y$O^#7X#VbT1PO;WGd@#8&Dz%>#>yngR-6l!q%z zylR~sSeDlZ%cGLam3!>+NW&965v|N~6~V5m9_O3FcPJfN-@Y=h>`Jsm2jwr3lw`D< z-(7>VAbbM0z3+&_wbrTmCtf1tLWf%1Ykv!U8}Z#j_t~#UJIH<*;esgL_Br1{(b%uo z29a6tStxRY&kOqPQ7`zNpa-YDz?ZQ0PESia;mX(D8=eYK@L`?`|0s2+%WvliF<^+O zVpgco#gVt-Pd&NoQy!((T8SyE9m)H4gL)cJAWw|T&FsmO62+c1m|OGJSB$4!>sE2&pE}8no!KQz z<;j#10{#F)7UX0TslE{0TY~XFC~Gc43bP}f?X1@$uLU_EFEYdidGD*q)rqd0*(l>8 zfir-b(OWW$KU+piqLPJV*$r)+Yy2Iq?EZ{vOs$9;)RdDPWaiWLmHRa+H3yo{nCu6Z$(%mEAm0*kQr<_U{S{R-VIhJHhVDIF`8s=8FFxxIo89f(QeWpyyKq%++jyN={R_-Uzwi%g#A_ijy5nKpVipyW7r zAffVGZqrzp9%gHM*JtKbLbT)kWY?do7)1q+)=WOXxF7rPMcMnAI}5M-x63{T(lE1e zZYpNH^_e*xBK@n`W)SvSs@FQYOts4Md|SI)D|W1xF#&h$Y{4#M2i(=ZUr?^QRY=rdlY3KnxE1Sz)15myONuqs2i@d)+W-%&qCu8 zZ+J0nNn)Hm2h-jubN1odfFq z6cCR9_4@=(WTFfm2dRKw^&%tqEQk?l zrCZ#C#^j;7xu~bvO0I7*4}gg`!93j7JQ&yCU)?|NX3~L^&f`WM2J)5@dezYxcinCLbrLydx#?{zQ6ii zVTD!g9+sDFGrQz)!b6lH8dN24FJN>K){S)1UWdy1*4mC+^?<%o)JB#OF= z|1VmNqVCiLZZXY>H|rSg?^kNGpGcVJf2KOqZA-kTzG~|t9hZJgBvB)(yn{p)W}8_$ zu}{41UeRk$$v$SWUtL^W$X8%&6lHj&1WQrImKr^?-L9qzs|6Ll*k$rJpK}s7Iy2n& zZLmk&4RCaJA;|7#$5l$_dDFS}PTkS(Z32&s;sGz!4l)Y=Mvh{167j>(}1-?5-Sy07$Il@-XB9(tGD>!S0 zmA%$%vc+`q*1l?)TQR4S1I?M^>l+FW#PRSV*6v`WKGjfO3M*4Cl7Bl}WoN6OVZ9fw zC1t_MODQER);h-|ljEE1%OA{U>1AfQ);+Meq@t3EX>-exUHl!_@w>F00dALe@a>W= zD%+W3-mnmO)1KH3t`M@X;B#kz{UF#=6aB^bqpVtG{ey$qtXZ&2@X>qHG)C(Tt{E~W z;)cxuaq8 z^&Yz6U!Mu3+x}Iv>^zvC(uol7^|XPHderDbQk*4^R`(tRYG+N&w7sXjw*_S}!klRG z=V7F64V5K|sNgf4z{QnJ5{Ynn5lLclk4ZvG0&dKT6NUJN6Xil%Ibxh-z74};0#6U# z_zntu5LrC_1^|1mL%K5Fads(idoVj(nTpaAR6so+BEQW}={sps&H75_dEUkk>E`J% z`ug7PsNjM{JP=f)#6FXArWdHvtCnT?`~`J$iodPbM{Blf*hzqz6@Jk+Z>FqSn)B1L zJ|?Y%_}J6b%i_H1$yc%lO-#*rp2ly>rRCl8o!%A=zv^b&+jL#C$P@OqsX<~39jq=W z2sX4O9!?53RrvuEWa@wy-|Pk7F^8*4I_T81T~a*)e->3S3iO#xhu)fHmyGDrGApK= zmkJxL0&hok_)V#(bEBmO>kDNp!`1%8e2N34}`BHi@E zY}dJn^WBwZz3xct=+0HPhot4<$;BPCp0y~^)4A!APHg+t zGh|FpC$_!sh_SL~QC~^8G}F?N>5M(*9d&-(JFz`aJ2;{z@8Gu{xt<|uaB4^J8gqN1 zTkb6C_-usRtbT1*$~)0r#0WUtpUv+I_@mW`-PU->ynp^ZK4TZ;eD2;2x8UG9OY}xy+QOX?q=)e$2zgRe$Z_ zG_|z1WlU-=>!njN!8^Ai-gi>e9pgzKJxokj{^V!ysE>CA=Vt<2*^^V}3p zKi06Q8~hA}SCrXBMN_#sKks}_gN(V&s1DkS9|if1STG*J+_f}fG6waJ&P2`!7Bo-! zCx7bvb2B=fXWzrK_Qq2Y_V+TLDtQWs&22EnB{!qPHt&Q{@Hj=&yr$$Jg*zl&OTYZaw{%8-zyql=R!s4-;C=c{l6Espnr*5Pd zB!_@Q^Mqz@!94LqQoH@kdvHPF-LhjQwbZ?g2>z|GWL~(IsvSZ9d4k?_glsR1*(~g~ zEg;kB3&mTqOWHEcsn$&EqVC0OdD}w%3vzYs+MPwwjb)N&n^vqyBofs!W0-A9Ne?>P zwj}<9%J`=C)(&}EB4_q0t%!8|s-rryzuYbeR+^38X=-^skU0ut!lt}ei7e}V^R2fD zCMF_voGEXsnkRpoQMnduBIUhggvWSdzTVS$7|ECZaT>`Ky_=DUHlwKTdbc1s%DW4> zfnd$8*ejR&ZMsj-2dM|W!CtXf_Ko(xD|NGf_UCy0aeZ`EswrI&k57u~oyzi*SIO-r zV10O9cgCEJaXD5JbJPj7KHL-5+UoB=_>`~Q(c!LKVTn!$Kg-fB-Ez=J2c;1$rB)RE zNDlJ`4`J=YLh@cxV-IS}j(PVeU>ivKy2#GVqI64Io?o{pChN(Dfq9K?HTzR8Y8lbQ zSoIm1U(%YJxAikRE@EynsNMY-=|xQ|ndgU8P(P$Nqt~=!;vWhsqGM9&C0JA=Q|UKR zTn6sf+0Cd1-VC(5J7ihLz6n$FK}7S>Ynt%7VDjatJe{i7nfy`*LCJz~a{ifr8Jo+4 zuIuG5`Ooj#1^v-}44EibbE8*(^*W^kV>c02m~&))$KT#r#Brj}P#e59Dpx-iR#DAa zerQ*^wV$ZY{Z)7fAHz=@hK{xi*qlg7o!$Z3Ysr& zO~j-#7YNK=KKl&sUep&(-}kOxUZ&NR2_INUgm!-QXg7`#=#s{=2Dcn2wdyc=5tBSV zuG~$LvXyR4&K1Oc+wEWW?F&8KJ{xR}2=AVZ{%T1VioGeTySLBHJQ1F<*N~0gnQ7HU zJ$c?8N6<#Imzav!aqew!^k&-d?NH2QgSgPW{$5mYVzV$>xplOs`Au1`2h+Ftf?)n3SZ2jc0Is zt=Wi;+r3xtWRE9^5@VaQi|tDTQn{5KW_@9bKFH3qyR14~@XW(GGlScRJPuIc+}`gi zNL;d;s9?{$zA+({T`Y}XW<^t`BNw}S-rrU0%g}-sKm8Kxfqw@O9*jnPf z8nd_CkNQ6E&wmV;p3NxsL0E8kLDfX?`v*Sa0zXK3vR$Ny(6(~%!5iVEGJ;bYV*fmg zpTJE6;|wi5{30x)`-=;&tV~Wy9*|@w3+%E^ENkS|egO57NBq4Ab{${3OKatTi`C;c z-uIY=!Zt`>&Avf0c)FvtN^*mALG`FiL`ve?y_9cmLZ&UfNZ-w~xPC!br#M2^U1hGf zUN(2iKik@Kse0)c%6o9KT`BJsIxX4b%o|Mf84?MhrZNY|MMPP>?CR4!uXXNId8wr= zD{VQw8JTNTyStiX z-nz41cUDM#aF>?bGbvSqVTvwJ)p^&iuF5|XQ2wbLxxVZIDB*lisrMsml>Yt9PbJ+A z$#W2O|E;~FITG~+2^?>G)OU}GtoJ(AUS-XO7*94ngB4tk?S*cPmFx9(oS|nOd7EC> zv>R*eah0&FgN}Low)k9S254l{)Z=XiX{nK84r8y|yH(0YlhUoxZ8v@!?02?g!;N;S zylpoP=5H^l9+KBJ>1hK{^qv=YDQ_!}zn5rS)T6GYc7^9X*Xr_E{ss}8jn!#PJ%Bl_ zx6`qowuPZ66#E*J-VQ>OiPqpqLNJ2L+tFY8tK4)MWvRSBPL6N7=NyO68Weq6Vn#CA z!#RUmoHJnDhdNu4_0P4n{vQ6Av>3=)2bGu-{qOsuKy9$n&CQ*euCDgQg=ssl@s=K; zrW)I5+RE0;cl?2#j2zbRh=(4Dl|0_-ArG^P-KRA*f0ZHhWMS#zRQlvq^b13pTJ#~o zvS-e$Ylj^u+}n)QzxNk4)wyQ3Q*IRswj;~1-cC#PecR}2Fk0$f+s0mpn?2?vTnT-G zU_4abU_RnLqP3g)9z4X~>=4#XtuhuECy(cAZf{Mco0=qj`42-$<6D&h>u)9f{ z4gbXoWt2(5#aSfi-^nP=j*?_#GetMU=|0V#+ngEmbfjjc7=xL+phOco;QaJ9`f3M6 z8(4qldR!&+EraBx-AXrMToI;WE=oGS#csx}lM-*7C9??LzI@wR4$5EJ4f6=Pm~9Gf z_ifbXhPAafVG4#e(v$Qz`UYEMIUOElNnZ{(dYDF>&iVCX94Y&Uqs;#_9f_62=8QaT zU*EwTQ}(7m3;AqY5%T^Nth7&28(R9QsHQ~~Rg8&it2pv|!#Y@%eeCj={1@JHBbNAm zV|k8}^K<-4u(a~Q7yRv@DS4?y$~;;&rby>`n?jNFi*5nkj6ig^hf_&%Gx-zF1&vzF zl8~J~GVh>vPfF`;%FM}yujwYaeM>@Gv;L40&Ik=jvA(JE)tKsvY!GBdJ2dc@$97@S zF@F|D9xxzRZgxk)b?r~)KMN-GqRJ;?8s782w+K_}Vq9HodPS-$dxFM3qt0 zQk7RocBw0bURi$MqLZW+P~%>^U__RaPw;5hioZWS7#Ds)pSih;zPI96 zMk*}mq745G$5`a;lpRvc_o4PWvQy(XLixiisg%+&@Pp34x zr_{$?&z>(HbUjO0A6RQ$$ewNUyO925;k<$}%O5AjzlT)@GQl3_n%3?P4z_~jC~s?( zH}nolHoSj7B1Ny&Hazs?)?ldaR!S?zG%hwIi(YJy&4yfTkdaKV&=7xX1!d1soj*+% zv-86rX1LB}{B?pUKhY(>^tx3fnDXmMX?}m*pYIzNwVYLOtDFgyxf_2b&dntBFls8$ zmFKpC*pk?edL~%Jpqe&$50x_ebj=Kyj+As(+Mia<+fnRZ3Om2UOQiaeBiDP2pRnRh zdv77=$=wAvrjw6_Ggnf&GS^}z03+`^@=LnfJBJV^}53RMS1chfpLLEJ=!=K{3 zQIMVOEXG)~4PVE2k|v}ZS<-{b#K}_E=X%>XG|d!FiL4d9Yiwi!M)p~q&;v`*-|-j8{yfo-}brR<}ed$2T%u7;bEi)cfuZ5t}#8M}i|)-k0Py5$G+ zY(=e?1xrb$UGy4Pc?nushYmuGq^G0T1{H@Y;`1|wN`Tino+ZH zOfycn87(j0m=&n7`uygiob1@c45#dA3dVeE)k{*zgN)pF$*y{BB)hdcy`0xO46?Bv zERdY6Sy^5qke_|$$)N_5ex=u}hs>%|^=-|W72e^r`WXwlyu_SroFiiTo4jAiK2W!| zhdfc(2am6|kr_8g6Ihq*OK+LpiaTuCcTr>R#$1N)1t_o5N^xoiDCx}&_K|c_&fxJEvR<-(~Gjp5;~9E z)FS6=%~@92#J9NJNHv-q)r*mNLS-50X>dj+b;lMi?|7W?+Pmw@_F#V^F*_|!US1I> z*2Bm(o!xD@Y-`5bAtpYNidvU#?=lZEsjZjz@p{dv=C1bCQaO~+l8F-XHr9zJ)2VbW zvm%=tV15R9e+?KVfB$j)0Ruk%pZBxaazO)r34U7)-(Vf@gRp!W{0Zo}7o7TcST|bF zaLd)sKS9qd$gc)J2K*`T4)CYJPmSRh$MAc={|r5kf%Ce52Y&|gZ-GAxzUg{_AD#mr z2L2cDTJYz=XM+C~{OB0o9>Y%o=XJjZ{sQ!03;qcB4`cWv;J<_XQ{dF|N(}!nhOaL= z^+*5u8}#pKc{u)0f;{8%p%}i?21dQnPx%Ixj_}^fo;C^31xoi*qGWam?SHQ=DzY3lNe+@hZ&ib_s zoN>Miob~Hl;H+P_#qgiU@IQd_x-WsVetiheda>!iz@Oy1fU|z>15Wt^WBBYCz5tx{ ztK0H${kjP9|3tZ51O6}YAAqyG9tNl1o(5-my$;Uu`Xq)A+Bonh<%fauy0zdeuW8`) z^MV+DEI7;S1aRs(Cx(ALhW`NkP5Ai%aMqWXz*)a`*d*}J`_MBE`~&dm;2(lFg1-XZ z1^y2BdEoyBzafS{7{gzT;p=Z2+}D4ge>ga=I~DvR$T!FE(_{Evn|aqAC4c=CdJeN( z(18DepB}?+kKz9U-$>dZ*WcUhbHV-I4*f&G2SPq!xprT)DRcd^36S3y@)JYy^KHLp zdW`(sko-wj{_q(2X7EjL-Qz-fPP2NtAWu8L2)-%wTn@e&`1im+2mWJl=8gL;*Ye!} z^1lY(9Q=>avjzBT;Df+7-#jQsUUw((Eg@eGz7_a^;LPWf!MBF|S>TMTYrq*-KLlr7 zJz}|wt8;C6JqdZ1*XoeGi>v2j{xY92Vt_Y0PXFG&baymIOFPRaK_aT zJ3v)`GOi8)XI#w%XI!N%cje{AZ&}E*ygEYiF0NL@$bUH`@8asL82O9A8CTy3>2Y!O z9mvzp?}Ib09sy@u{TZBb^(r{a_btoAarF^6<7&e#gZ#s|+6kO-br3kOI}@C7wFsPX z)e6qI>I7$8eH)zPjyu6Q?)Vuv`zOBvXMgEW;I!v`%hjKp#~89z;5YV{Mu2aJd^-Vr zd+?dy>{s6ePW?Xx-w}FV0N)w>f8e`-Z?|<||E}O;V)#PvA&@^4oOWIYz8mDP0cZbn zHTdq3e-V5`@c)1h2j6m=;J$Q>@A^x-fHQ9Q0^bAjlfd@`UkpA1{ABQv;1_}K1^!L& zQQ$uVr=3rL)6PGGGj3l6r~ZF~Q~p2Ttar1v4g9$`>}&-e4So*zKH%R49|Qg%_`cwO z1+M~MZ@a)A=FcJE3CK?YuLeI9yav1(d_C|kaF)vnmWT80>EO(_=R*(k?bYDC?p@%# z?gQY=w~vCed|v=(`R=-X;7``OQQ)k16Tw;U4hLtwYXYbJ?cj{(v%p#JZUSe$`z1K* z-D+^wyBEP(FE$t)_z^Q+KaLP{vXStjTJ`Qns4)}QRZ-KMk-3HG3 z@^f(N|1~)EKM&6OwcZYa-&nu41!w&l4$e5Q0jK}>vpihCrh>D6&4nJ;uVcV@zg^&U z@aL)El>at3^>4OQ;5WwezTk}KN#Km<25|a6 z1y27jwmclq9pH@T6QPIkd=5D8_gmnM=bOPP{}?#q`B`wv{~etE9I$iX&;3!p+k!Km zhl4Y&ri0U;M}gCyS#ZX44xI6MCOEHqAvonP1!p`z1AZXx_eF5}=RZth zaK`h%A%TAmMm!G!r+@YUXa9UWIODk7e#6*%Mh575JSei5Aa`yn{vdEn4!|BnP`JdX#b{)55k&jsL&=T>mW^GV>0tE<52 z&pW~C&-=j{&%Xg@d_D)x>%Ia``G0~lo`>%?!2IYu2+;w}Q_A{{=Yx{~;_@N7YF8CSXoG1J$cmw3G0RKGr&tmwm zz?mN&2dDjG_6+Wq_KX8R4A)%HRAX*J!gPZ&n4j0b0s+SJOq9;{Pqm^G2kD94*^e%4E&q|p9Q`Ud;vJ^Tn?Uw z{8=&lD)2>+e+Ik>{59}q@b|$-fv>k$a9`xx#PB_0cojJ7MG~C#;!JSXi_5`T?pK4; zpErQB+@A!e{x`t6?rApgiYv4p4TOKT(vGM6xO}qydfx9lTCVaNLw>iAyj%C&D@ML5 zB=6Qe>tf`S;G5vOvqE~@y61ez)6QeSIW9N>oa>(Ff^*&T8{q6`e%o^WYXjJM6FB?r zKZG9k+n)hvdHoBV<+aY6ILqro%hjzcuWx{}ysm>Dme*b2tiShyv;O`9ob~qw zaF+YO!CCGbjm|Ik`L^7*usmGu+lA$AKVjDx`8`7NuH5&Dk>3xTj<+~j6wDS~jmhY9|EZ%gh!4sh-V`xQ9j;kg+8b`1Y7IQ_6yBJeZEDF=WrK|HJk=X}K};GC~G z8+>Qzxec7-&HKQYLjG~^EckOV{B3a7yA7*@`z7BI{8;GU3!L+olfn0b{NdpAPYd{Q zkUs;QdM*ZMxqkX z0RA{Q=POaN6@WIPKYGY~bfMT=xKQ_SI0u~Z za5*^R;VR3+@o*zJX~I!KvpA zaO$}coa+%kjp2U>r=B;!+tI#kv0vaf_HTCu=XLi3r~b*{)ZYwF{axUUt24prpYy4ybaFvsX_Y(eq((Z56*sRJvj680&vFj@!%aOuk*oq-JgT= zx_<&c9(w)(&g=dgyc6;}9uVAb7kCXg#}WI3YhT`-D>)pT@vs=2dFf1W-tRRr{72y3 zxbCCijJFrT87HrUGfv(GXPj($VBjC>*&3XBb^@oKeZi?`JUI0n3{E|b;M8*@IQ2Av zQ_pg6>iIG_^_&GxJ-2{U&kw=bu00yVKLTgJW%Gjq|FhpR)NSp<37*#gdf%PMg8TfPp?e#;Hu?6=%%dAQ&5 zV{rCcegQq~w~RhGC>NI3!Qd>f&s*-w>qT2$Uw}OQurMU=%4=zie0xaVmDlnZ`P0E! zUSA36apmoste*L%>z^2$yO%8T{)gc!c% zq(GkSv(XsnGGY(&}+{NK&X-o9yUyx_{ zz88{rarjA${05UfeNMlN!_QeB9#8EE&N$pHq{qeKUXZ7qHQ9!G&tj@1Dx@5 zs^#m7ehr;jHh#{5Jj><6ki3hZ%VXrP3dy_pxjshzE^x-rJs~|VejbE8?R*TJ@$)J; zKO-4`)7kw{}JHSe>^z#uL7t3Z^iH* zfb+UP2j_L42IqC(0;ir&z^P~3Lju21&uDPkKLwon8^Ec52{`qi2u}UygH!(%;M9Ky zIQ2gS&ie9aa9;OcF?_x0fqz(Ewu<4qfwR7h2Iu-_0-WocOTp)E5af;1!A}Ig6#OLc z?}C33{0{Ihfj5{FPXRvw{8aGITdw)@H1K~yp7wtT zPCu_dBd~|-*IR&7ej9L>%TeI8e+BsIu=5gdK9}-t@M_3E1kU(>2AuOPFM@Mj`$KR( zw{82Gfgjk8j|Q)SJvEk(lCN?9;ep_6m#0Gy+vTId&w&18!OsN00G$5(6L<^c-vDR( zyWK4BeqDcTn+?6+hsE%PmP=DTfboAaIQxNL17|<*+K~Qx#8&k3#Y;uI`VKe>f!X;_8VQ`DeiyS1*S2xVU;9^0f0kaK_bEbG`cu z$JKCf##IeC<7z+4!*MkgoN+Z5dKgzPgR>lWXb9|NIgSQrIUZzrxE!ZJp8lB~l6U2J zXpH<(A$eDh%`x)FgR>l0g!H&_JQ?z|^Bi!N<8|Q74|jvJ93KK_IX-52xExo5vmE~h zJuJtqKOdAA^T1?q=7Gb(+3)%$__?Up-v?*^WSx1zbr~nyfHO|^v^*RqV<1oej}6JY zI5{vzeribG#mTG~`7eMoP8NprxHwq~dD__t&Nw*_oN;m$IOF6NaK_0GEDy)Yec+6f zUqcV$qp@1uRaLQ@zI~b*Mt6lfK$&0 z;Joez^Mm`P{++=&{u%*J{S&~ce;PRT9}Q0ZOTnrC1aRs<3!M7D2~PbtfK&fZ!C9}L z1E>5yz|VvKKL$S^e9)nRpUH>E@VXd2D~2xzzW~=g6}%n%T<{CQzX8s1%}>EOu6Y!k zKP>PYpXV?FobnUFdA}*}i*UaufqxDBE8x7ZOTd}mZUpBz z>o&{7`RXU&%vZmJo-JU{W8jRp7r|Lx8yz0_jpel+IPYt3aF$mMILm7~IQ@S(ILoU8 zobqRbv%D?`r=M>Ir=Rb#JnZM6fz!{wf*$($8F2dN6>#R60Sf{@GY@Y9elf~%TX5!+ z5#YRTEjX_`6P(v=0Oxg&1m|^I!Fk;iz&sZn!}aB0aMqU@(8Kz26gcf%0?v3?2~PP7!FgX-gEJ2A250>L z9GusE0sJ!f?Okv_e|W%=fuDK)q8gm>HVK^Z&|rBu9u`2J@vsDZH`v()PQQH_oPPTX zIPJd)oOCZ>OS+Cy&r=LFtr#-tK75JI*qrfRY1Dx`Qfm413_&4Ft)4?f! z4LJ4R3QqZt!M_dt+aK-Sm)0+?4-NJ=s69Xadna9F0MXr^UT*F&$zk{ zoaOsH@E^&=-M+qi!Eb;)kASDZe+y1MPg(BlJjUAjSIBex_zpO)`=5}Wg;vkH#{}_1 zJsX45oKO%2dlDf%Cs=zXK%RP%;PhJ)IQK;_1*iQdfYY8+EO+HDg zkf%MDfpfk4DsaxX-(b1M^G^^bKY={;KVZ4D=d0G9U&Y8j1x|bZ3eI-os>OFj7-?#WE&QQ}NC#Tr{&svv z%Lm!N9UpCf9~|Nb+24nTxSg&aFfzm!+25-|JZFEm)!4W5Ov@*RpT1Jv3x;D&tvxYg(3dD{e5YOziof-2=VpxLh`f1`^&dyJIhZF@sXCV3i16czaYeC zS?=yzf7Nn4#`3E|@*S36AL6H4ert$dZ28?Gex2p_h4|f;KOEw}viykg$9`H?C*;6Bt-@}I}>2V?ldF+5KHqcQT2#qi&P4^^kgkKWED_TT!u zjzRQC`K91P4E65!UFacy4}37>+0Pjn!)s%BoSxy3=X}D}mTUgJPV9GibpqtS3(oTT zKKM|`-wa*_ei!bSdTxO{`R(9)LeCxG)!_HX=#R7WF6b%7&L2Xa_Gq8M`HlAcI>w$K zL!S5h6L7}Kz2KC;51jVj51xd79ssAF2V?jz!4uH)5cq-M4}&ufX{W}S{)lS^JOcTH z4fQzfx7{5hPy5*)_!acuLkB{M#!8y)41f1inV*I}v z*QNiT0$&sVKMg(C!as5T|1;!^@&7ZBr~jV?r~jV=r~m%~PXCja>VM{|=b^s_e)uc+ zH1HR|?J}mR7t9X}A^$hXpA63V=exjPg#3%(yzV>TyzVF9e}|q;5Qkp|-x2&D;A6pG z0-p;0GWZeTuYey5PCL&6Xa2kgoPKy4oc3>Q`%_v^so(YQl)nmlMnL{G@NwY0-y}Hi zw-Nkx=t+aW0e&(#?Y|QIpOC)+ocHxOIQ6^){x9fZyZKfOe+Qg-={<0^3-5#5=*_d}R}{tNm4Ko9NN3h~Cg&Hl{) zpl5gJS!cuGx+B0TKN+0z^#8ihL;tS_UX1_OhkP;q-vIJ`;r|Vxzf}J-o;QLX@_{jY zV{rD1HUX!eO~EO@894iOTg31|F?>sK_5)Lht2)F9*Le>C=Q@##2N(Yr%Qf`p81FAr zPj!su`sc0Sp95bB&hgh7;GC~M*K)m&4WQ>zaIP<34Lw|6{yz8-(DO6!Ch*6>w}L<4 z1*iQRpkCAd&w+E@+07ehJHme5E|6z_7>nz&zHec<`sX^>&vM@u_7@|+J>>Vpb#)Hb zl`rG=1YCD0 z;H*b>`rFhC)}wh=K3tEEfF9PPEI8{?H#p<)6mZ6&YX{ZetVb7FdF8A}S3(c#(GB3O z@WW5Rhrw@u1*e^FgVRptZPpjoFV+|KKUrVcZtf0ySiX#Na$O^EaY#LTfLFtQ)- z{bhTtYYk36Ips4k`ggM2#m~p0OMjdm$FH$`jQ6pbHzawwHe#?H~)PD!c zo%;8O{CwQ6u6a2>Q~yEW)X#Z8>OUCr)URu2PCxH!68KQqGZ~!ny4Dt@Ckf8^v1#CY zLOen^9DE%|Q*{*TiIt}{kACR!99P<7bEf`s zJWfB%g+1iO%ma^uot&?8c~9?G*E*e_r$CGoPVR=j>L88H|7oc?P$o;Z@TBp zl_UL@0;k^=g41tlaQcmQ(r=3(&--eM;mzQ2@y7mq2J);gj8FQX@^etWlphJc82anL zSx@JJFM<5g;O8OF=fIhlIKI0O^6Zy#Ke-#G>aeCY26=eTACIOAs}`1#PIdn8>RxEuUL@JGSf-*_JUB*_04oN?~f{WU(R zXIu2g80Q?nGtS+*e>l$ffgZ*c%lC`0ljZv*aF*|v!5N1;qdqbY$?fAYOnc38x5rit zr~G30jl3`7uJRjFZ#A87J&FK9BnU7)}^W+)eN8`Re zMm%)H@Uy_rgr2W~Q$NQ?jAz<;7WB~0Rp4u4=h@IhJE=d;PPUupK+kyGFZ&_vC+l8m zmzNeop7X%V!Ow;KSHN|Tv(s}WIM*+}4^I6Lfyep(Jm{YmBTqk^4|)25{aE_p0?03f z{>{LP@xz6Xryn)|ryr<)ZTW%i;6=DD`%zy5pN{+0IdWHyjAxb$^>hBA26{OEFa!J& z=ud%DKlNM+dA1{$fpa{2IXLCN5yP(p=lK1b;0MCaZ-Mi=SAo+%SA*04-v+1uzXKlU zfBHw~%v^cd?Z~FRyB7Qy*w1*#fnNuC+W%c}UiW%%mhTPVapg-pZ-hMUq~B=g_aM*y zz(3F~Ou>C|yukVDo1mu^^4|w%d;J&b1UWyS1NkrGx>tj9o&8pDuCxCF{AOJDNpR|a z4V?G2A^KytKo9$Aw}KxGdG3#z56=3?cJMannFf0(&w6(U_l z`@t#y065F#=P~@3G5nzz{zwe}6*%qu4LI$26rA<_G4Mm-=f}ZYz&TIFe#;Y(Xa9=& z{{cPJ|6g$G-x>9Y`fI>BUYiEadAXV39IrKkbG+vEzlXnE*Ykk8{E4ACA{J@6G-I{q}X}c^mfJ56-;$ z6gcfPK$)EHC^C#yInLp=2KlA5>;LM+# zzheHRo?`On`_Rw)$?GzI^195QheHqZCpq&c`I_WU+R6M$JDEQZf}LxUKj}B-Puj!$ zNqd+-SzgSa_(m!jGKR-Zutx5i5ePsTmf0#c{!F8EG>9@6& zKba@l@8$d?^Z((4(AS3Pe zKFJ56e+I_UY_C7Ybzg)0f5Dmm=?BIq+i}Jx>lfp*n0iD%F#j+=QqJwE?YtmuS-840y`-mS1$DPR?xpQ^lS~zd97{0 zUAwHqerfIoJSz8~KWvY-g*@%q4t$ySHIp~C2mdPgVDM|fY3F0$*TSDKfHO|s0^b4p zxj%nLaL%h!&)(>_P|qZA>iIl4^(+Br+@1seBiz@s;9NJ^PzywUw4Zh<#mq+shKg>(47rR40>&0+z z)(h%ky`Ub}3+iFLpdQu>=1JBI=I3JS1^0)rUhulC7rZX(1+UxJ^@8(Vd&2)yP>v(O z=Y#V(GmJOZN45(ip@;1tImcP#yWqM{A^*^R@=1{23)gk^NbBz?aMs6Xp`Z0}Z^-k$ zM#u0mF?^pG&i07ybprCVzXqK4)PgfFb>hC5msVq3$$rIH=;8Vr<@bf3$3ecB>poWE zbtxZrUG}@`U=R6(7``9)Fx=OH;9S2u2%P#424`GN1ZVk90xw2>a*RCBkqw9aQy|ay znF>z(lQDc6IQ1L?&N!S7&hn}U=e{HQ`C!;jKhFf80X?*5COEH4{mc)uAb%wEv;Wfu zJ{$F@3!MEHo+o9$|L| zZqPFa@>SrsO44=v`VIhJj{9Z#a-IDM$ah0N3(owu0-Sc93qBWi(myQs8z9epU-TQx z{Rfa|x!(`Ya^DA><&p$vxiCL`9`>`H;ywZ9`C{gu)3`3S zU;2mhv8y5f0osdqz~{ja8?WPipzS-?<#zz*y6PBk-d8<1^>>1Ey_ov}SYF%1&PLct zJ|CR*i|qyTL#gvcoEK$&I0*HK<;8Mgob$eDC)?%SaKDw72WaP-j?`v(#y<*!4KrclrPs)iYZ^tbFzHNS-vgs8_Ty9oaI8! z@@<1W=M&n&$HNaD;M2kDQBRo%Sl`*M@x0YI=(z=YMu2zXx@>pI8)D?!!C4>o0oQl3 zxN$4z8M<&?j=v~RJG&vz_+JK|H!cR}xOfFP+vSzui(vl=;A}TJ&OHb6_rlNTgR_78 zf8ZSFejA+SI}DumGw+=UJJ}wc1U>?Kz6j2C@JliL%Q2kq;iaBaAkTLBRB-0u)4`d? z?uS3;!v51Bp9Vhz{6uidp9y{@|4ne}{}wp&>Q&&A;WxH-wC8HbGY@|!hA)O6SWj8+ z4#IU=?-r1wojnem^{WG%?a>NwwnwLdGY;ubuA8uaaUT)u7dh(@$4AA~BaV+stw)R# zjuY8Vkuy&CoK?zSi}H>053hS2CzaL(_237qkECOG5mLU6_#{rqp#7seIum-U7Hfxhq?*GJaGZ(JYg3%~K4W-)$a zzlHTWiFlwMa@Ok`Azw_rUX%8b^D2D4F6-k>u!s4U{itb(L-wPX&u@mFI>@suX`6buS>or*Zm>%v)u0n=XIHXIG+762JU}Z%=+8>?fZI{wVY?FFgj% z_Tq8yfmY8t^7j+M-OnKV59Rva1oz|mIm(A_=xFfXSLIK}=+XB?xF71-Ax6({WAwba zzSA;b0QI~D?j+Qn--#Y~KfK@HLw_;ye<)G@k0r|gDMtP&;ZgQK4SDyu-tV8md0*?w zFK?wB@%~o%)iLs$qrBX=RQ^Tyd8qwBbyLkmaOZPH3&A(G|JJ`ww*OW=o7#WtUsu_G zE8ooiTmQPx{#*Iy?7#J|=k33hZ*Ko>{!+u`NBLIfU)~??J*~=JUDi+B`&E^1tHAy& zgr4mjl)p~~-yZxba2Kok@qOT~@2dQH@EsMnA2mdN^sk-Fzq~)(b0L)f0p;S(H7mDY zHD9Q=zvy2sN9hMk!S$bmtghq1Ro-3u0&xB3Vq3_UgRA^x`CotT1lNCl+ZMiiUW79J z|6$ADg}lqv^6`Le*3&;d*{{YR7zQH!PIQ{2Y zUKirOw0uE`FWuU^@QM(>$?{Xc)y@a3omYYDwKuet`v!28f8NUL9(et6cD`*Z{gdD- zKfu=8H^KEgvuvf;ch%{SGL_%e$`7_}pVPm>R{Gt*RsIkwKM`ENbDg>PfC0J&r$0`= zdr!AMW6E*;?6hRPrEb8Cp#?dEYktEfLJtN(Xe{$_|@Z}}kG zNI3ZyEUyaj!NXLmyt^U9=UCnm;=i%{f)JmvyQk;Y5P!h(CqjJUa8Lft5Wm~Xcwx_f$hE(`H(EWbO%53u}xaJA~!et^xF?!Go0>0NhYaMkmS)iV-YztganC!YXU`FE{+1Gvf$vlA^HAwJdemEfw! zwI7#(tDeczA5(>t1Z7X#E-H3_aT0+e_jl(*O+eQuLR#&_!8@%d%%Z5&okh* zN}EqV2Deq$@C|Ics@GKgy7s0&L&5j(koj{WxT`AqK|Q$Yxxnga1|MNGcz>J@ZmX90 z;2Q9~Apd=E)vt39`tvaOC=Z!GUk2YB{4H?RbD7n%ne8;IA4WrdTX2=X!pc{H?*sV; za5sk4k2}EK9FFn}z^fG4pIgCg3NW8M0bcEdH?7&s;YYKQR_*C%u;7RZt_%!f~ z!4Cny6Wlf-=F{JU*F*kY@EPFS*nY0sKNGwbd=~h8@Y&!w@HyZYgU1+!aB$ni8u_W~ z7W`%KW5Ea7@s`?u9Qa7^7VreP`bXa#u0Qj^TRmj{JQ`f(H{a0va0Pf9Cn{0_*U1b!#@72tP) z-v|B!@aMsQ2)_Oh?-#ZIZt&sYKLVc${$ucF@SlL64t@{#SHaZ}`Yd4mxgPvp51Bu2 z16O%{7Nq|C2K=WUGJn1f{xk4@gR34lKRalsC!~J3&-Z86!=o` zr@>c&{~7#x@Mpju27ea(W$@>~2M+gsQTzV_J`((S@af=x1z!sO0{ANMzky#5{v!Cp z;C}~y8T=pMZ-HyP-DKl!&>o(U-q%Zzck30(Uj}c0{43xc;ID#T0R9^It>CYNKLP#* z_*39&|8K1QAAtW8@`LyEeo_1X1zrdKCinvIx4>6`zYTsF_&eZtgTD*D8vNhjAAr9H zK6r%pi`xG_cpdl$;75Uf2!0ayf55K*{|Nj(@Q=Zt2mdel`Xjwx)Xq=9hlBqQd@8tG z3)PRC!Pi+Q_(ChVmiy})dY`QVch8K~Pi_KV4|;wBzCQTt;2VH%wwHGuy)XB!HzlLN z-81WyyLBy<9|%1iklz^mV(?AC?*!izd^PxH;2(g04t($^waV*PZw`I{_!i&`!QH!z z_4_A-ZwdKpz_$W_7<_B+m%-h;22}sRz4cGePWMb^{e3j}cF;2me0%T~@WJ5cg1cwG zsQz2QcZB>C;5&i83GSXrsCovC);~S_cY%BrxLd~h5G%Iz}?;-yl5BW#HReqtBe-V5JnN8kH(q zRI1pnhzg1{;brg{mBoaYDFK@*x>=Hitmd(9HV}MbK?OmZDz#|UqO}&4R@zcaEh;K1 zTC~_wi%Kn8v{d;iwbY`e`agH(%ZWkP0NypFK;+e<|)?Eac0De3g*@O2{_}`GZ0p zDa-5sYax#c`3fN~6Y}2(d5w@iB;>P%{I^0rPso+MJ&NcbI+m6>C#S!?Qry2*$R8H+ ztwR2YkoP=2pU$H~UM%FRguGJ79~1JlkUuWu?Lz*9kS`PR)k3~b$e$GQZ9@K(koP#4uHvCL$3wM{zaZ{!6Y@U@`640zqmZu<^7TT#LCF6kSzEn}z%@Lf$==*Z)-^?0T-_QO~q-z4sD5c1cAe1VX^F67@6a+Q8Hr@vgt|0eEVFXWqre7lgpA>_SASe73xxawAzv!w9}4+eA^)$CZx!;LLf)eyumAsqe4vnjB;;d-{9_?+ z5OSx{bCZoM5b|!jv5-zng?u+5Un}Ih3;9+d?=Iv$M(6e4L&y&jaurwYMecn=h1~m= zmilF)knbhZ$qIRqkS`SSy@mXCAy>Rhn0KX+?<4MiQpnZ)-afG{LhgNQUg=phM*ZtP z|Mn2+^cV6k33-W-tMpg1K9xegpSV9OONPWNnp@&$ zr;|;M&2>rf`*`}XG(KTUJex@-<4yEqd`hAvSyCLYiZ`a3QjM*RvC6RbC))D&=kzC? z6v?n0NqsU=m&}|wIF?r$-B21I7tbVHl38_ML25%9Thk}hHaE32HzadEDwn9+1~oL- zCK@zERW@g11#z7akJq-fm6VhWCRJ zRoS8GL@HA;rfOJxyrM6i*nCm4sWO|PT*&6c!eE2_?nD{w=y zrKN(fDm^8NQHFRvPc^0+Dyq(kkDXEyi;Z-=QebVD)7{NEO~)aPiFBu2>vQLD;ZEIk zA{(kkkQ-xNNtdpccjE`Qv<^*Yl6576tC};}GiHuWHciXcJ8@_Z#EPyNh@p)69HSvn zpIsTM_R5LaomN{LPqx)2)7dyRNexL~Rr=W!b$gu?Rj~l$^DtIt`wKB~DW z863-GnlooMH>oyTIGdYrrxGkFsZ3;Ak{Rb#!#%^QvWeP@sG^O_7O0@c96p`ep5{zN z)sVPqZH90)Nv=9USFOu6Ev9A>6>PFi^=rIlRCQfQ!tHct8hKw!RM4=0G1_JjHoG*F z14}jR3~?KTa(!2JBQ27L&Mhfc>9rkB%vR@y3JQqi>V4cC(+QFR9$ec^`M1TDL@@M>!V@r!%QV*uCK+i(rQ?3Lo$)^ zxq6Ix^ypmnrJZLiFR(_$I3qE$C7!&vHPPV9wXR<~yWN^G z{-Et*kJS0@V7PGb)gdLK4vA5<`)S2pFj1H=v8p0mUkvl-nb#0a7}J>^l6u~*nC=Wz z#87Xtq$EC3HFR!cG`6ugHoEgfE`yhss&b2$Q;X>gPgSV2JD2p>DaFpP0n-1od9n!{ z#7MQpCRB~oGfN+4%GZn3uz^;@d_QQ$%s0ECGnlmTTtCKl^N5NwsacppPa?5cVcX%q zx3uEyGz~tan!H;-mxr~$uA29tK!bAbNRpEYqdGLZWUymPWphh*D%~DvdP%W!e?^nH z`*X2AFye+KGl`ZYin^-oXHy95GbE>@%9H}PQBUWyQ8LhPL#L*i>X6%Zok~NJq><P@xGUm`K|8b_6s%?CC9d2Fl&G~1Qf?~GIx`&3s@mc9(-@7m>XqEMD!v#hctWrUR z@3S9XEbO!L`T;MBsq0*vn^3waIg`d28`Fu5Gq2<<;pj}a*;}OGk%-~dAx+5{?f@(I z&Oh7vENy5NWx%eSUeTYv)YOn#1mr%eR)T?Nx+C8M-lZd{Cf%nbr_soVcsw(Pn5i&# zF68jSm|ZwxYcfwQipniU`J&`@Xk&8OueDELpwx0|(ASx!;_*qQ1BX*Vqe(xMY$qp` zN=l|By%|k^y42n9O?x{1j*=2NIU1{NKwUZl500PXtaEV3gJG9NpAgJr)MP2F{_?k| zRgmr!sO)>7J|KAN>YRSAMqWG7xim^fP(~`pPfX`q7Cl#0RXH+As~($YR=9Czw2_vN zOrIF1QaXV;eiMsDg-calWApT6#RL?&v9qb(DjA+hs#|Co=hS2-*;JdXm>7=@&CX0G zV`o#6g&kH(uVn@;B816NY9o?OYB^FoHMOF;h1RqVr@6_dx_HHC=d!6e8?PWrDg&vO zxHH`zZ%AF_FwzwJ;1ZHLx;P_Znbz8DiV~}!SpYQwU+VqpcIOq3^HVG~Y`Qb6Je}2^ zK!B=pO>bb6}Yfbcr>S?KmHorB6t?3t_ z`Z$5=z)W-V7p&@*T5G-Bu3ot))zwNOT24DAj)REmPs4*J75p)AssOt118A3TRnb#( z2TFIH@Is2?ri%K8yRaA_J#nBrb${3DAcR-GD^>MKYgtF;AMd(YTu3Fmc1aWUc136E z?TW&BTRmxYW;DU{q|G_(^z}O&mk?cZur;GoIt`&FtuDzAP)X;xQkxet^qo6a)a&Z1 zXLc`u$!%6oy`{B@bfPu|rrd2)8it3}Y?JYpT4=#;WfWDWgS7@d4iLj4jF}HPCg280eCL;W;v3xQtc} zyKWe+@>d_=8a&w9u+fytrVL?-ME#?dB`LIUb*?4osXB_$2b zGm@G3l;&2vK5mz3=EahzwMtIN&GCIM3*(X(f4&Rj^d5+}=1&z=XVY}4H?^sc3y)V# z;pgm~I{$<}Y2oger+~KJs;_1Y=-G^HEftLwjR5bGMUkpoZE~udy(B}YHfLreGIbT| z{=p^bRI)ZXBSk|rxdH2VHg+}*IFVDpz`Cj++>!NM3oX*D%6`&?{~b|N?H`7knurec zADmA_*1KKs`DrjU`LuShAyJ!**Qc7Y&K|s0+TGVd&WQ|AQx37J@icKk4xuYt;wU&e zj9L19WSZRhIkf`pyH(Y zt<(KcwF{qB1N}usAx1r`PoYp&epZEY7rM`DOH~I~b={S>a$76FW9KeZHB?TUb*B=$ z3zbKH_BI^&+}!n4HPwN;(4(Qkp^LgWlv7vd`s2)V=lXBoJ}p8G^Uf_#9V|u)f4Ue>aR_--4Q<)cQ|N zH8gnd1n`#Q7ZeOJY6RYE;3HDo!M(!bYzL<&<0{&KrC#mky@SAg(#$<^InU1_hLXKx zReP-7&l76V)_A(xr=-*ohFO?VWS=@Y6F$*8IXzh_Dk@)w`g@n1Q4&}yg3;$FRQ2H@ zQaL!>z-^NK=g!meE!@7C&GyWHjam8Db>Wm41Xv(Dm#To*0>`p$ff z)a7(nm1sk9Y6q$pRN7rme=6HF#YQiqalCC>9nwWIAXGQ>ixN$tjQJvkS15zR#+z1Z z^c@BzF(>UZQMoS$7>w!?)dU*a@2WL1(zWYVyhzI~S#%P^oskyGPxl13AE^m>eF~v|l za4|#=m(BXvCS-0EuI%IZ&f za5l%@iNRT~;SBI-ryVL*f>YMgpmd{JOUaw@14!{ubbz%nTAX{PmW#wpGdXI3v%9xD zF}OlK(#dh;aADMm#m@AqTdHBeYG?UC9;AuS{UH?LWy-Q_7P=pgzkBXge)O+QhJNfg zAyvF4x?X^bol8pTW#rmY=ir6Ta+Pye>eIsNSzGn&TjsG#d*Mi9eX45Ljv62h&1>DL zu;-WXe&%2MP@8+ECmO&jQL3^HS@WmDXt%w2@!dpKXHc1;Ri9mJjUCDfsuE~>Y$mB* zx$n5UbL(3T+h_6ORd)!=FzTSbib3xmpFn5#739>em&Bblu(^@P{3>cgA{{M37E7qL zK2=z~s7`cMBdyM+y!O>#VH3)w;@Id*CO0PY`49D>P#NrPg-bQj_lvS}RdhVv+!DBw zS-n-ItJ_FzT%7hz#OMLeUlGxw%C4@zQ=B<}RB<*<9n-FMLy^t(IH-dAymyJvREeQL zcO}1v9E~j8E7i3^Ka>ews~ZtY<&OFlyRbG5rTZsqiF1qE4aFL_#9iGd|Gzakp#tHH z)CPqzD0HLbj+yHH|1UzbTjG58DV|9*O;aD-P_?}`Hq-Tfl9C@xf5=#>F znswLg_crYH?{Wiy1w9Gi&U_=);Vxuv&5(J>tCpS>OKR&A8E-DCR_#KprHL8e*mvQp z+0_%DderVvxm_E`p=y+_Sq4L?{wWnoZ7eO9p`ZWQRVb^2i-u-Ur#6ceq%kI7!pv7x zhSnPy4egU?#18cf7=M7$`Kpld>_l$dqdb7l6U2kp**O!-QXA-T*9e8kgnH*wbEe7p*1|XL88z|7g+srLJe6{$H%km}VWM`%D{Y>! zeovV<6EemdzOpKV-~&Z=Weg+$$`HA7I9k6!U&P8qEL~H)7RM{a+egLAUZ@D^U*nN6 z*3k^eaN|o@uvQ%t#YW`bU8D9ns`(?e+fgY`3rr@))yNZ=Bk^*$!^FL^MpXs9HP?OP zUECesc3#Bd5{W7a)hTL`i+V2te3c6IEj&#)Zi4pZadYJ%vXo1a;3k<#no2};&q8^f`)hWbw)ILq4p(L1exqJC&WS!6}kM%x-q_T zMBR2;8dJCe!`UI-6!^NiMpY`P{5T6mDB%fXXv*5z_DO+MINd_|;U*feutOzTm|kHz zYDNiGdp^Gu)MT+CC&>NSP1!`Mi54L_3xaZ0PpY{|ZPWJWKi+ENHRjG2Hr*ZX-gsTU z1ea*rQ+;a6t`69=qwFngyL~B0L%n#;V|e=zw5xMTJF8mV+5Q&#^g@D0E4B4)omCpY zlN2}=^!hs0i=<*tj`0^oxFRX2WcnM^ko%_Prs=|Hmn+2Z8mn9o!Yx}}ZZyH^u5y3c z8Imz?i!JDLbv;AW`p$G~_6uV~s3+PlWcGx!EL?thbq&?Jgk6_F}LO7FJ7rBBWIa#jMVc60sPgl?0`|{mpViGLXFOEZB|PJtukT^y|~q9 zQdb{Hqve{kfUu#tiPsNy<|`XC1blYk+uC<&n-Qu~67N$89Ki1S*5qHPU^J$Sx9Pqx z?BuSk31YZ~3h*v0erQho3lnundD|fCY{OEp&8d>w3Gj#${y8+)=)_8MdxBKsqa{jp zJ=zMxk3@@rX_0`jc z)U+o0c0^;caZ2k{`syLSxPzQdBPg|PZ6zfogK4rRRU4;Iyr!C_nRl!BC*cb}9;qg; z!4{aV*ZMh|lhtQ$ou%#i#AKIiteshl+z6$kbSGaQKiy(gFLmH{&8ispNuar@B^$3z zxbLme`i!CW#UNAT6&>uivRHg_rg#}*j0W<(Jw~~WJh|$&aEp;%u0O-V*wGYExpCsI zi&c&^E8%{hnzy3R48_H*NoSW3sQ9Sj{G2~W(%9%**6{f&kxm08x>!c4=Z)#kx3Nu2 z^>SSl=e4-BS=xDZZb?h_Q*N>f*NwTKf6;e}@7fkC)Ud&)-)-2X&0aX0)%b1KY_`Mc z@4gF$8aDMs`A)Rsxy?B??ReMESKC^C7uIc|@;OXpr}b!dp-E_j#i?Cd(==x1SrXceW|7; z>3fb9)>y5f%PoFZ1JAMPm1-_dt4}EGt(WTOF}$MAKXjPCMJ|BPOHIH;MJm+FKX1XT zzDzFVn?@>)^Ad)NN^hBb{ux_17KI5|ZtO0TE6GnK$oUE_b5ez?&;9Nf^cu9o0F?`k zDQDFZap$dlDudxdW3ejRm#|^UBrQUyPu5;UZvbwJHCB$P^#zW%%sW(qhE^eOe`5;F zX9O1)`kHnJ`(8?h)upCRO=gl!^wH7m%rtE!A49LhgS%lmQw;R?8hVvaP{rVLS+Jq7 zUZAx!zU9h|&C_W))KseGlWn!hbk?|V*;_41q2odVu$9ACeRY9(8Xkov78JR zi3E8Cr2@_Fu*9J?_#ujgSD&aJX~@85NT|>T4(decQUj>AGIU&ndzN%IIDx7#7s3W# ziuT-4fYBZXH@s+GdN7Aq$AvL&#O~)Z1_A@hxJo#zMPYx4YT|$wEW8#c^5>k z6i_cq6|Ra2{wZjwS?p|jGAS9JNjfDlljQoRVxsq$eYS5>oKjZXAwUgSkT9h?BH5If zqSiZ3t*CCvP)CI(Hk<0`1FX(vQ*$<6LFDxPj#NwB{R&7!>Y}9LR_}W#A*rKPZW1j; ziB+iYn-i+k`!&(hLUW~x$N7oAeCiHaPZu8zsT!>Xq8eV~ugL}2p%w_pB3u%uF9qbR zYRW3RXl7EG&{CUdNMtJ1x(I5XJuS#+r!uFy>P*^a;e4`Oh7ws?jP`H@=oPfxg0!O9 zd5i5JwpP-j)tr@-W1gAx)1SFL3Wuf(Uv8VLKk_RZNc~T9QBff~Evaxm?&a@TP=Vxz z+1EA9jrw%aw?p5FcAGoO8v>}euK)50~$og7yKd}8!2_Xy)vok35dzDiI%qle_s zLR0lHa&;t%OE5ru-n0U<3^TC$~bi%Lh!k*7CFa~JcNqZ=uSHP%Q0*{A+XRz1x? z^ePXr%aM{$+XsedBOcbDJTGlbw8dLempHXeuDlN+X+i&aT>7%YQ$7+mP?b8 z$lA*M2Tq!YPS<_+IwdbuVpl$7VPG#BfonMOZ@-AF^JB}3c+ zd2ZU(9F(o=U?Q~CI>iI3)XSl#AnYwCxC7_+a@`tlG&DCE@`>M=;Y&Ky8#DZ2#4k*7 zH^R8zC#D@)JQ@eOHF7IVqqEJ6;_3ueSIXp6O<~P~cE;t~O4a%D zk6p>sL`Rvjl(NE^(+ko2QZIM&YO_2c?0t1c1H0~5XBhnbFN)j1u8LQ8cyGuu&3*q730c|tXr>fcMQZw<^G#Wm0dx2Ut++{Q^XxuB^ zZkJaWoG2=%aXR-4Yo^ysIF*VR((^U+lup5mCdM|}d>CG&j9#&zrQG?U$T7aL$bu*7 z&$q8G_Q2(HV;7FmgjxcI2W_Y(qE(7**-WC=`FMCi%dtxbo{x?OqrcfPgWKQaQeW^!P@mt!4!IfL0qgWYLJzsQZ+bQL zV|}{i2Z7yLec#YQJ{t5z0-)CaEW4BWM`<`2G0a)2qV{rAf14)#?RMikUn@S_w+f_# zhq}+%dO6@03q9aQi*n?En^?o!uqmZQdK<}Ob&+qye77xid16bM<6D2wv4N|L-CTXF1x3ibSYC=3W7E`d0 zI?Ox5J17AuF}mdzNsm&M4d0Lz#R0A2D>TU9B#2jU(sNheID=J%35}<*4qsm7>o)IW zDduk4Z8CVYC%zMMUgj^;N^z& zq}Dr9G4?qQhUAN%}xz(3y5pi(AvIW2e&YXn!fq9HH4r z)g1W8K00TbsSEHKj^5EGRhlEEZl9VEqlu4_bShb!oROl%EV)X&vNmYYB zie}L0(tXiah*0-cj0G)uN0Di>!UMEy@_o(D`_Z@pKRxceRWpR@)W+o6HGjb|sz;M= zRJse^bcNd#H9ze(D*P@jPbbSRf%mMS`bE^k&=>SkoPK6Qz%HY2O~2WI&$;H4Rkqu6 zRl~srs{-WXr+l|-XA82k$j$0?yZT#8$Vd7L%+6Ms9WThF6_e;q!=G)yc(sli%%-|W z)jkvST4n-`+B?;ZdJVGUj*6zbWShGqpkj1&i(3K3s>ai8>M#04f&ayWL!DR8;j-6J zf6n!Pqj+B;P1sMYRiAx`=cTm`b=j%uxVtXP(NgPnQgvC_Po#8dw^ME*RXj16)>4(k zD%A!P@2z??fiCwgss6K;EKR`bYr&AhG+QVVa_^9@fTYP+_m0B&S2dT=(5Rq9xeZ|+ z=75xCp;w5}BLqDjI`i_>BITcv)aNzSZlOV$=0WjuC!XUpCc~<-iQ0=Qz&0Px-yOkd zzg?*_UsjpT(4tZ?Yb1t~#H%MeOtYk<;SJ5S-Dl9qZ&JukRq^U(OGybxBLtNKAmI! zdy&WiAgMBz74i9zJtC21-6IkD&pEua3180lN&L?(@Rb1n3k!TT!2i+$Ujy*VE%5b> z@4;u~zvFfb@4qbI|Fs4GWq|)T7WlaUKhQ$|g#drN1%5HW53;~71^BO9;8y^Au?2oL zz?WFy*8%)s3;afaA7X*u0`UK`h@b5M|8EO?q??<7EI&gn^zQ-i!z}Q<0e-jzz8}D! zV1X|N_)-h}$pAmX0$&dBCtBbq0{lr9_!@ve*#h4H@TXYd+W`Jl3;Y~_Kg|N)4)A3b z_}c*fbPN0vfd7X@`CSh1?^xhh0sIaN{94A#{>NHsgDDB;@Xn_G%X)x+&H}#?=)c`U z|1ALjz6E|e(0`MK{yPEwH4A)qiZyk}`ujr*{d)rZ85Z%|2jI`N!1rgojGvJfc-2?X z?eA~lKULT1_?QKMIlzyyz)uAD0T%k#Fkbp^xCOo*;7_!`r-A+_S>P`N{HIvp=K%a^ z7Wf4~|I;n-ivT`mfxjEzD=hHK0KVJ;zmoAXenwm1R|EdB7Wj1lKgI&T5$Jyw$-H*Q zJDb{{%>b{;w1@M~Cj3^$%lh|Q7W(f1_;W4r-FJ8EFPVSmS>SsxUg{sW!1o6D8Vh_s zfUmIde=)$1w!ojv_+G9XBWnC$j0L_D@Q<~?PX_$sEbwW@%lvP!@P8Z7ztI9e2jH75 z@a+Jfw!q&8@EHsI5`b^9z%K{*=@$4^06*R$|JMTi*%tT>0DrlK{+k&uKgCyjRgn{jagW7jXk2@z+}5doo_uzw<2ceE@!e1-?JPFS5W71^7EG@MQpB zX%W9;0sb2n_-cTkV1ch=yv+Y93w#5>t7ifh=gy}7M;7S+OAG(c0{p+Qz|RHvNf!FI z1N~Q6@ZSdbe{F%k8}OfFp}(4|QHLzQt1S3e0{mkZ_%#6kxCMSaz<<-i{!IX1ZGqnk z@ZYk)tFbC|$ny7;h5Zq_R~<6{p0>dEV7%lXzi0UJ+Y9hNW5FK<_-8Hf0|EYb7Wh)e zOZ%Uvq__r+ZbpZc=7Wg#4 zzhi;F4B+3jz|RHv_bu=X0scQ0_{EHu@xQ|YzXb4qV1Zu_@E=;>R{{KgE%0lB{TEo& z|LXz1m1JS#e@(_!$=Xt&ErT=l?AHw*%mJv*7Q(m%skr-2ⅇJaJk`vCkN z7Wn=Ezo!L$D8TP!fiDAi)h33Gzp((nw*|f$;P*8%*#7Wg#4_prcU#&}u(?Qemf z1NeJd;M)QI01NzW0DqtbehI+GE$YAJ0Dp)D|0;l2bMj&1cP+ptEbtou{;L-HZwB}y zEb!X^zOMy-C%_+RfiL2~m-T-?3w$qtKgt3h1$fmb4x9f20e+wbzLfENa^^3Ov%r@D z{wWsmHx}S)E%4OiP( z4)j-R%EI#R1pFf{^e@`m-~WzT;Clgl%0mArz+Y&A9|-W{Ec7o0__HnWBN@-x;M6~r z7WlCMKfwY&5#T3T;3ot8L<@W!<7NNh91DCJ@PE?+-v;>Am{QpCGY8 z@FM}f$pT*q@XZ$Z$pEj$)Wg=l^^BMCbFl?J4frz__{#vk#R5MU;M*+l3jw~-qWmmo zy!79j7W_*9f0G6Oa)58Pz^?-MODyzX3-B{7@EZXBQVaZM#!LUJJsn}=e=Fd>+=71x zz+Yj3@4m0U{=U)z--Ge8{+(rk?+x(Zw!rrT_^T}N#Q;Cs0)H~V&#}OlGhW8e)fV_l zz<-SeeloycYk{u^`l~t3u<@S;{PQgEmjV9kEbwyx|9lI4JK$enfnNmpueZS84frp% zsDG9M{C6z)mjnIVE%2)V{<{|VwE%yk1%3m--(-Q`%y?OT)tr3T_}>cnzh{Bp0q{3l z;Jb6hE$i=$Mf~&x_**Ra`v8241%H2l&syMz0(`3lzKroQ|8KXjzZ~%2VS%3r@QW?* zH2{C71-=2`@3O$RF<$!bM;7>5fd6g_`~txLWtvk9TYeV;{vTWLF9!H~EbvPKUaiRq ztN#js|A_^DHNf9%fnUdXng54d_+r55?O2Jk;+ z!M`5hpSHkn0(kXKi?Hq2R$%|-7WnM|e~Lx>vlHmQ*24ax{rvU!a~Aks0ROxNKFW9* zKfkxY_XqfO7WiVI{|grQlL7x9Ebt=%{*M;;u|R*dCOB;TRs;Nt7Wg`V|FZ=?4e&2p z;4cICmn`se0sa*W{6c_NYpTQge=*}_{Qt!QzXb5VYJp!4@PD2sHH(TJh0sK}A{7!(s!lL~s+TTBZ{tb)vqbK9}F~C_r@_!ck_W}5KEb#pS z{#^_FP=McNfiGjcEPwyBz?TF5?H2fn0RL|bd=0?AZ-H+B`2Seo+W=ne$p~Bj%>noi zEb#4&m-#ozBK{Wv{wpoY-`xQJUkm-00sKx2{7QiTp9Ovmz<*?cUk~sfTi`bVe8eLE zwgP-N3;Yg%-`xV=y{Etaon;X}Jpg_W3;te=m-Y9a7WgQ@UuB{HK!E?Y1-=yEXItP$ z0{ng!_E!SD+S3)b{+i5qS^vzj(7z7g547NK0Q&c`z_$VXK^FKq0DrIrz8&BXvB2L3 z@VzbYOBgTn?<*GgWq|)s3;asJf3-#YtOj_sr!Z{%t_Avk)dIf(;J;>p-wg0k3;Z^K zKf(gP6X5$=;EVX95Hfy_w7~adysW?bS>XEs{52Nw(;wiEvEUyH?9W)>PX_#IPixrt zEeH4k7Wjz(f2;+*2H=mgz&9{n#?Q4D`IiO!B^La%0Dg!CegV+G%>us=@T)z^Ve@}6 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

    SK;=*3Ag{4@YMgt=s%8o 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 z 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 fU7X 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

    !3NG;|nPM6HeDsynxdS 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 JolKYi-vLM3ajO6T literal 0 HcmV?d00001 diff --git a/src/third-party/win64/lib/muparserx.lib b/src/third-party/win64/lib/muparserx.lib new file mode 100644 index 0000000000000000000000000000000000000000..aad816bc7deb6df77048d819ec9915e7a673cc71 GIT binary patch literal 4002360 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 z zd2^tkxY24LagW#axa~mV9yY1~t7E^NmiEyHodgV~(nX2B`|$8xl+$&7$1PH4+`iZ6sPt?*JGT+pBecNd@$Q zo{Xfp+YVPuY%xnvLlEAuvE+;x1e)|vwL|!=m@bgoIMP59UFbVrfERi zxrpT3GMsrl0>q?n5n6rL>SG4kbg}?G3GP}zsnRugO!c*H$+d(Eq(1=cVlJ(nP`AIw zk=5VdkyQyqCWo^^tB)Pd0Ee?Dq8$F5neK{cu+$%+tG;>dUpnh8qtn zvswc^dJIx5&O!agNpFgoTm9m2j)!97q1gD?te8+SiR*>~#*3#O))t)=8yMw$Fv>a3 zAAfK2p;9uoBxhbB%;;FOBuMelkdn# zkJcVf>E6dOe;&p>Yf!5|%izx(PSl|#u!5>SXAhL5NAeX*liYnh;u9@FeQaYalX8Bu z{FpPw((J&a_0sEJu>|&T;AYRG)zYhgXslMn@KqXQ+{wP1#-x?mlt?BC%j^*^{Ua!_ zex{k_J|HoRp^}R))g)UU;E@ddQ7JWj4dY!h{!rVgsO?m^VJg+i7-#Be2gU&m3fcL{ z$g=A|M(zt4H-jvX`=PBl5_26{-1obdE<~~k3j;-`6~iV(T(JaoW1$zmq-0GL&A=?7 z=pjY2P6+B$2R}7C+NH*(x7}_9q2_hx$?HuNe&c!W7pwBjg>JnC?LqR|wR>IIXP zTs^&4EE5zAgxENU4ZWk-6W+we6<|If>gwse=+md}Qso0@c0(Pp2Pa!Xd1iwd8{C-a z{u`k&gh+E}1tj%811PvWb;0w1HlYhPn@C4#B7XwWijF+N(1W$FiDtHv+8<~)$ED$y zmMMJsVf-DILJ#Ac8POy7dyL-D(Rv`E+oZ>B(a|v2bQ zMDtvsJE5afI?4xnmwB}oTx#>T!U|~qGI~)X8_q+AH2)I4gm*HBYcEzq2RRm8%pqx* zJB7+(Xk4JfnGE+Ri)fRh)n12lQ3(08Wh=EfYL;QGesNvJj5s7~U?C7jEL>=vH zW$a{u<7}C;;*Eevb!P^A35NC6TbGol1t50Aw&F6#>puo0j!ZLe zLC1AE+VsoApRXwrzh5zW7{AltGFXswEeQi@sV)SaxFSPjURfz4Dde^z zD@IHz^t3%C+0s}m*~3A@1^Ppt8K67v5vL6+7y@{};DLhr zUa^T4NE-&&O=Z!3!NsG9FX5_|2T~4rao5n_B3*^F&?`QRsjJ;}JpzxTA@;1ny5I6N z)ng)R&+1cbc0g`sSwtR4obH;Zr3f2JwIyUe(%^Eyi+G-E^f`>2`wSyy;iCb{3)B2H zG$z8ilN~Y|*Eb-`;E)k;$Oz{=f4gPlua3my#eI`&v%nnX!Y0P7IQGl{w|+DciEz#u zO_S-tCpHc0Fs)S2_!zcN>9b%NzF%TkwKhg z@c$(rb?rs>hOM4byvE^7vBGmsc=MbqjzojsT(i5bMNscx&l;rr4NaHP-*t$_Gy{Kl zfJu$DXZ7~tH_JdsobGy|^{@Yy-)zzRW{aoaa7TtUwPJml?k~4X_m@=o3#L!rJ2lN; zv`#HG+~_kS^JqL5hlv9chlvMrkL=S;Z0u+pjjQ}fV~{lu5m?g)+?@9`}W;57PH(jG-I;L49eLHbLd{l=tl9# zRb4lYRX2@cvg=+0x%(#?eIzwJ&0r)hHlk`PHL_(Ri#2{&tif`mS}al{97;5vrpu}S z;31|PiXwHp07zT!kyVFMha@U~sSh!{3>oWQ^23OeLMsb1jO`VpGp|c<505#+fRJ$S z&wlhoz!UeZ-rAf4)9)~vJz$MiUo9g8ph~;J0Q|g=O3w@276xOT?^fW{CXOOJcU#no z9U}MKAMLW=h-!Smk!8QZi@t56^tHF?n9=m$8O^?OC@E$Mn4_pE0zCw!(4yQ7xJB&9 zJZ(Xb23cuBbjnSdP?bJFG}V)r7J4d(IZzqrYWq@pXWIIsA{J9E?wa^^m<3_#Z8(z`_vZeHrB+ z3DO%oRa&VcX=Ns#S7z8Eb60y(V9O=)G!{iC! zYzM9?TA7xGD7Up8u9={%;pp)F9XEu&ProP<*{G`AeKDiQsyRC`c9h}AYHy4jm>k*Y z#PxJ1-rp?{s$kO9O&r;bbp^7q=B^!(CeAkmNL)^`yk<{vuhjY=^Rz(@mmTfZpN>dW z#Ex8?BQelnK2}f}IF_)hTe!na7wGEmXngFBDn{ulf}U2_U>orBC6<4!a)WkHNpVj9 zjKma-d+3KK5 zkXT7XN<`K|iitqVXrj-^oiB|lt5>E`2^tkFoO@TG@;s;S2PBKM>=V#K^9j9D<5Z=# zaJZsuhFY!drB*GEZ-oTiZ2P;#;+ASQj#l#bb+e(#_lFO{N3a*)3rod!c9QW1QDK^> za1muCQNhaHD*T4=_?B<^=0t=Cia;RA#Fv-RjOovf{riu1Wrl^vI7 zB1)MOWsgevJB^#W%bqbG%oND2_GgeNF+z$o70zAru`WmyUB>|Va4k;&(zM1PXVrR; zhhuf0LgTqf+ucKSn}#`DMw@!C?3W?et)(<$>DaZl41M>RP2!DsnupNIagN2mq+#20 zc%ZD}qf5iqS$c33y0IGB9^DussjC5PRt)He2eT+`ZBiDoqS33_q-%2>p?xQ0LhHxW zH5u(fr^KYg9|R;8nx>;%An6Q0)#EM!$*6S|NV8wY#c=nG!G+UGa=ynE9aQ{SN5va$l_k{=16I9*PM90gBJNyv&3ZtzOoa_u*?U7r zgYC@bw9jd$eNG=*e#R!J6Z@Z7>7~Rf+LAP{Piteh8o=5?p0>8EKfG&mCvZ06s>7D0 zCCF?E>=S4S>P2%Gt?Ms7hoQ%M9$M~&$Q313tf6)&czXgW1>yjlc$reB0XSujs28p{ zK>!GDifC`!4}6dSzKQOS*86E`e=NHBu?`H8IDuD`*3aS6r)-$789Fj=Q?`D3GjUGV zr);*&=Grt!+swwU0eVHWkdM<_7*?V%k+ji7vYK%w9iUe@tzN|yw5Ah*&0XEO?)*@9 z-TkTFu%V#WUCDiFdVHrTIIPBvhE4-eTZ)7E!$#(fg^i@8EY{KUKr%mk2S}DeX)Q_G z$8{j_ff8$kHnBhIwb)W(|G|7#(rO9Bk+O$lv4(=a$P$EM9Q_f-bFGgLyPN(f7r84# zV?`p+voDIs?7&LU`W-e`reiN~9!{xUOB)#F8iD==o7PdTNmwXMLkH5~+q9ZvvOPK^ z#M0595rI)zy|Ixq!q6e9!#rd^cnM@t*A$C28{`s)9g04*fpOr`2h&6822bZrat#l4 z2Oh1IUSZSNf=XIHzG+MW_Az7&1B)}GsX^FBjvSgd5QUUVnW7^qxM%lO4bCl^rpkmjGVie@~VAqx{|knz+QF`cHTKt38U6Ki2J z(Y~VS9CZ2sETmesj=hjJybzm{)+X9H1HG&)^+#leYYP*~zhr5`%u5s4G(N!mw8VKG zD_XGy_h{rG>mJ^*O!{?AzD!*rXtF|65}L5wC#O@3KYO_+Ets&-#D)2bPg=w~Q`vrU zV2O<%Pn}0Hb-s42kdDl=!$CaPJYGhejBKZYq}BflBz=Or+qEJN57@Dyy+^kj?K)*V zs2;Vy+cw&oiE<7Nj&hE-7GD7gXY*fh{%!!^(`ha|D1BX&eH2{u%7uQkS6jlVfq1EEHR%-k1BkZ-f+Y`= zUmD1VV!q|$D0=A)7DQ;1j&gu(IC_F3(>VBw$x+t&5Gy^`FStnCw}!o`=R?BqcxP;@ zi$yccSZ}(@&?_L%vDhJjS+Uq0h$-Y&img<7%fJ-voLI=4n2}+!nG|E==ADGD=yNx< z-SvA!yZh&Mx4TZcdiXBRnfuU~?2LK-ru1@_jr+`b1?5}-dFFkNRgUooaOAj8AeAj^ zU|~^qHgYM-16PL=vkw>T>(F-g4qfhrU!i+OJCkMcm!wP9lt7%Q*7jNdouV}N?cwXH z?6epU(_Bfb&huWYewaoMVY@6S*y4}p#?YHDdfD2^;&tiei!x&^$xHD*;o`mTE}jL& zYiIYhEN%sG*X7z589NP?5aCQ35baEg!}%arIcH>!GiEQM4p=rGa3mhn_KhP8k=aqH zQ9av8*Po~?%MEqks^ zPgW6!n}fRat<=YnDv!J01IaE}8DuHT{{cX_2}fi2 zx9qRA0TR0LKtgu`=ws0On#y5$Oj2z?l1DE+?r9*&?K2=58_xmBIOyk#&-(b26bsN& zmRARePSp6C8Uj7Usm+1(Bb9|HD6aq^Ny{1MzyC>Wj#0uM&I=M^jj>W9#Kt4JWNyVI zXd5FQI>-`}r)GDGwP~knQjn#4F$(8jU!sU&r)o$m3|aibjgK5jYm&G-3MJ_1XL+1f zoGrU@ENk{#GF}75!!E`&MMf0a28u-niUYt`?3TbWHu@dmu!LT`VtF{!5{jdE58M2& zScaVk2*zJLZsJaXDrkg*ekakv89WG|c(h6SgLusNNKHWycV3=>?U~)Pezx(&D1xVNc$I?{zv8gB;0od*Qppty`jeSIv8|G-^Fdw?rU z(hozA3uOZd|Kt?b^=mi4m{WHy9~9 z{M~4xkCy1PiVv5Ecs$u&fISGeHk^C1mV3NWFR}w(F)6MP_l2rxhVC$m2$zPiZx}iv z_MQcM$*cGzQHd@l+I3(@H5efxt7}2Aa=SImTokee6gYJ99xfC2FACX)EBXL*WGJH} zYiURhZn!>l`G&Z|R-{TVMzi2t{P~&&;aB<#S_?eRaSil-r3H|r;?)4Ho%aEfo?{$P zA@8820ZGrX1gMCmKA+iY>Qe(AgN8qr^ zlwvL3Sf%-*vEIZK!`KR6fKgEE+-|wCW+B2@{p=XCG{;C)Dcndg??khU>p=|_hoi9c zH>XSh1w+GeFV`a0qK=5ylYD@-e%`Rv5pfh zi#K^FNO81ss8pl28SN^J!Wx{batD9Q;+u%Te8S!VbBe_manq`3@yC`Ywi2SIG=!hD zdESBP=6;@c`q8{oANzX;+GSc|=XnW{_}g7VgIBC+if}X~$~-90E>jFlEV|Rg^sS=( z9Xii`wxD;hGT;E=YUHi-%?Iv?I9dl)aYq>+b!5y4=2vq9qg^)iBz zIJN^(CnC*M8tgILON0FmNNcdJB@R&P!>~T!QknEvt!ZX0N%lhff4{+^5mGZ9M$MKQ zEHz38?z!0p{j&yp1SQlO>|TP>U}?F&n6smC`ocoWvGb8m4Ym+h6<4CczJx@*!9Ix_ zYOr$?xUmlWZ?)4*$SvMZU;O{CUA=>f^whihaY9e>0b8`%l6)5+~h+FGx+ ztB0MnFn;u#E&D>@w8(3tg4jpo^@W!5v@;q=*8kk+ap;XWyy%6KHFtZgrlVSo!zyMV zB+}svb*#pAZ9gezrC7t#73&9W^aEmc5QrwUb}48UkhT)3Z|?Gko>;*)OTPcgc_gMq}K;(^4UrUQA_l-k6nZ@T!vFxbgASSA=8 zSjpBh*ZhGkQwb?@W~2_#eD>EcFY-NYol>eqvb8*wde~ZyeQ3v4{&(s5zsU}++&o?r z<@L}BA)Bxm8Vg%F_D6=veERtintI49qz>o6@W@ttpxWxlqW8T}`x$(}gegp^2yDah z$^mf|nipBoF_`GJUd+BQufo!bmPRX6VGexAB|1wxl|8#6+O!s_-tVp0gm|=X;23hj z$?fz_5zh2&_^^ezK;lt{>#5I0G4)c3VIF7G9OZx(r@ZN=KdUl+c)~aJ_`e<+R z9IipJO2uLl3)++*FQ||8fI+Aes4hGOfp}i&ZH(E0T1GW%cGTW|73CJ?IPkJGb9>m& zdlB$*aIxdFl^~LG@YH%OzPCvgFQB533 zQx|i6&2qYv@-U*g`hvaG0(hSg%Z2TrxV+P51ETl9%_bTPbur~&)1X* zB)uJN;ylZ7v>+r06!!zsyJ@~A+M)U#PsV2cGSa&Clye>emaq2+)*5lNXdg?f!>a0r| zP#sR4si#su8p3f)^f<~>=r-zc^roHYM`N(09@1040J@*0e5c110*O{Mae5thSd#>L zpAl)^lsV{&CSi=40!fM50zJrav{E5)-GEwgT#O#~A&~47768e(c@0R$AykB#*JKrc zA?qH{;4qguV(p5wX5?cRh~D70{)L_{?9OlSi!_W}IF{KERcLsFzqm|)$P9$c>sZaE zmvGJ#G0kU&=hX$$p1L|5v@EKGRIjJ2a4<%WhFJo;+Gy|5vbAe`raj)(b+pqy8e287 zt*+4?KQ+Eyw9)^7@mM{dhQdC~U;i+17M&>*;mE^k$3u^nqaq-B57bcG+O)3N>vVM1 zPbMmQ1!_~%(#Yr|84E6^K(u?Us>FhF6fH2|Kn7l3k*|W_0}cIEF9+O1Jv6?7{4pYF zZy(cLw5xK23tw$R4{k47{t{vwE{~N+S%IW4TF@GYRn|CY(E`M*l^g&@l0FVVByWoC zpe+*`0AvX!Tg`HDMABb$D!>3(j?NTh=Yuq}*lOk2yIi8I4o+=}66iy&hAujq2Q-Zv z;=4f7z0o}Aoqawy7$b>**U z!HN8wnmI31};d;cNO3NZKfEQcD${1Coj> z0FsKk3M3V00-uX{X`B-dI_V@F&47f1`c18>J@$k2MK1k$^>hQkt>Gi0xC`z4Wp}j|DTCkUdVHMJQBa@beN2j6)`r=4*NQ%@A z*7lD=L+WEJTf4=hEqwuK%iI}q99Px!usRxu|20Ox^;l9YNZ5hljA|aQ0z*GwRrAHgyvAjbf{l%2Be5i6YJvj~MDF&`}sNJWP)X;t1V<#1R$(Nfo{cBrdT{M+bnG z!E(N)d>}t=^Ou3Pahw^y{v1c`JB#CJ(OgEy#y~P$cLEaUhyW7j=nJGfM+!uGx1NEh23k%chZQXda$-_(~6{GBh;>qREeOcp*_ZPUaAC zJlGqC7d}9~c_LOTB%NNp0nO07ieS4TqJ(CYqQT6*8@}_=tSl%@j|QasZ^AKoVrfbG z6l1LcidyAa9~MF(uC;gL7EWtrP74xV2d=N7C_?o-GHPC^#qb8 zMBB&zstMhVcg&v|KQ$Dpp(}5J+614v@G)7?8L^TOe@->R11jEAUeA-SsqD z?;{J|n^RREhnE8B@t{~|X4z_wr*4RjI~)2j-oj177Ovjc;Mqa?G8%IDSXQ&#N4url zC7O?*7iDiknidg?6L)kAzr+EHNeA#j41AWP*=2r9T<>7f;d2MeS9F*5WIC{0!QncF zVSz^!XvI%Rj-vSRK*%f0qnPIzQk=qu^Ycpt|KjBPtB|W!s{hfO8Uwta8!hqX*gror zs=YCQ4`mo$wvYvw!-Jr%JV;H|Q7+IvxR$TU{mR%4#LeM2@dWxpAl@9;KOspUPoCx2 z?*0tzvFTIg^OfUor8pK8@h3;|mBv2quQVRH+pjbh(N`L^C1!k~(TNXK!hf~}WIkMYia(u& zv+8HzkZXyL*0T-|`GHe#;Y9301FClMCY2=z|o;&7G%zp?OxQ zBJM!XvSKV6#wCvGnw8AB!mG z$f}Kx6ywN|jA8qHTcO9o;RybkFuf~9>nC~9Pzjk>vBb?E)>NA%IzbO8L)(dclc;Jo_lWcr*_eowsSb~31O{~?DK7FxN z2=g2ru3H|zLQ$?y<*UI*w66y5FY(o2>h+Z2UTqRQ(|xk-NypT5080S{8jM zN}Qz^(35Uo#s|6=+~EEUix53;MA4^Z;VBt8H~1SCcn-lgyN_bb(H&9iYg-`~kxgsb zB6~qXaM5q{DtzvOs9@T=&ZC%{dJNhLKJq#&B$&?44-`+p*8$4#yPKB9DNrlpR#AFY z>W_zEg&w_xeWZOjpR;w*BrX&KAwCv>j|2Qg?`RV#kQSdfP3ToVX-A zJ_P$qv@1NSaS>RfED?V>GK#FJe)g=1)`I)csUvhr^>bu3=~7VnLvgdeEE%UzIQqI1 zYUDW9T+_&haG0iUw(* zt6K_rOWYei^s?`MY`&*K8`c9!83!;QI)o3;if!ma(y=g*SHr+k+o;5i#Y!RBR zJ={^`PpRb@yZkeQTIJy05^>bECy&)(M=81SZyy}(nu(k+4YJ$tHQFdwTWwb-AgW!@ zM-WSmIF$xfEZ~vA+zNt{@d1Z11d! zVbS=0c>(=@3iq-k2)UN_4Ko9NoOZNlR&5KX1X4fg7=MY33_XtNze^blRekRKRf0LzkIg_Pj1=jFe z1NVHLTM%*A5^jSfXdbD;0-Zw;anutI4@*QT7F-wVT!M(}{u23&G;l1^IRp_$(-It9 zQ5qMW6_Yv=L>#T$nvE`R3g{V>*{0;%diS_3)@!wl&?GOp1fjEY1_ja(%GZUS&XlsY>herYbEf7gkKE z5KoMc(~lN1^%4uBGSRCqW)qkAoRnB`(4Ejxi3L%Kg@dS?Vsuo&o9wQrNT0uLlAMy@|sUq#e!?L&LxPr z7P#~2C;cqV!cfLB#c>J0DH6u1YOjpVB!5 z5yxug;8v52WCX=QsX|AsMi8|c;UKD1{Hfqg_KPB0BT;gx)wuI_=OA)P=3*sOr!3C1 zmgNRjEknJb-hGn3X()o37XjX38WLn2X`beEk|v0F-eSu7WuK%q@nS*UTeVoaCyp)5 z5e)P`Bbrze3CX>mbBLi^E$jvx##lf1sN7v8;kr`SND#@V9XzwCMyCpXFV;tU&lW6nH7LCUvy1O3y_Q<&wjcRPM@(OuGhZ z*HG=M%Kb5OP`M8?Qsw@;t5SqFrogT46(4CsLEY1tF$xvrqQ?^-IjPie8%EU-H;xh6 zA&OB55WO&IHbnppVH6FNz=+zaAo7ePjvEa$hS3BddSk+DiUT5zXd9aXJztR}eDFi@ z&2a^xiJq~@;@h?O?{OtfA4DRRjI^T?oyV0*^arlgqG%MQ`=@ZF^s~5<+-hL1gnJ6P zESsbVqM8vzwIIlXjtvc3w> z>yibLe@#E5DEH+oQ#R6Nz*1FQpSYhy&j z0PG2ho@CQ2w`P+K$QZ(LLsIH7FU?I!HtpvS?<)L}teW@(JBK_Zm|1T@BwG;aEploE zphs-!7b_f6N_UUwwxv}O=$vFDkwKREnRPbySPvRFUSOSxLlAKkG6#<$X?{$rI4D)< zsJwzmci|wamH1P^o9t^MTO(0&i|6moLFAImSCmj(y~+JkO38DKa{99m?ToANl3r3l zRF*QxSes?yxrBn^pj4rwk_w`d3I|cm!k-G>Wc!P3jYP?%lDhME=OA)P<_;xPr!3A> zndSPFGXHu-FQp(V2lYW1vuXyIYNnMp)g0|_syU#XsU})_&6fA(Q+BFXB)mqKAc!Q? zWC=A|lsDBKP{&lO^?jzwKEbAP`DIgl7*UHK#E7&N)B}iQ zsdOM4bXo+60!6J*s9l|^IgPS~g*+L6YBsJ!&@ zzCQC{jz)?cSJ9m~1QACY;qaJu4>oYE)oVf!adq&@6=&djP3ICsTz28A;A^UYLETTA zuO=I~Ue~z<5myi9suAjEsxjJPs@A%)$!|rO6vfmPfGjEgM0M4l=_&mN{b=D$U9upO z9K)34Pv{tm1tf5=YFDaD;uypnR9_D>Qgy45>Hb9gEjUN&8G0}x-5zGtNh7EIEs{JL ze@NiN;Y#ACy0-|TG76&H1(oI*k_+h|h%_I@`UcfRdv0C9RI#6bO1XIVxIxlo+#oHJ znHIqGHvMQ}9qUd~1(DQIOi30b{f$9c)T%`)3yxst|X7b5#3ILs3d|)vyRB5d<0QBrm!xat75B=qQYCO32_M`uIbEmcQ(ynT9Rh$ zyVvVd1(DP_OzF)lOS9=?%t1DFGV-*kvK10djX6iMt(_6o_W(x9%H0t|Asc^4;BZX0 zvLLdupwg@?(kVwlRI;V4U5)mYOrgmYO(CP}nXCh>rrNFRnk+swP5y;``MxQf9skfs zVa1=c>=2+;%nx8nQ$+%Po3*E$1W`^an9|!wQ5LBbLgm7KL>$jC2ifoiMy1(MW8?XL zbIzG;8Oexj8OMl53PIG9lC0^tQlNPXDSr=sKx&G?Rpmv`b}~W;A}b3by#!fxRGQ^Q z7qW*SD&5OmCL@P&To6r(LlAMi&Kxz`RWjX=x@s_>zNv2OdZsFS`-UuY(_u@<%jOUZ3lAC5Y-u5a}hzsw1Q2jbpgzLi!0Jd+g*g z899t~C7Ke4AmZ4=96`apreLg~s`X+d@Dqph>!jbOOh@sF^rMB1Yz2}ih$J3hN~#k> zqzU5p<&N+jMTlKOCBF(;HN^kvXIbuh!@~^ur`OHDNoMoiSqLJwrB$}FV zj^tNe8IhI)8PRhKaSq3o!a4krs%A~!4!DAl{~Kpq_z;WA={VBFE`q4`1d&#PtU3zS zQJ9X5{$unw(ULS5L>BsyOIaF+l!iD25ywR%2W4uiPCr_BpUY1if{5daaPT}6KC10I zJ*rr6-L7*9BCZ?E#ZQ?7{Fqj8P^!?8?FEsQgoCJ-;!g!{vTuuQ(g-W@WwEYdf$93xg_&9{HfqgZh$VAsFXcQlPmThnYWZs zT)oK+WVtn(l{3{I-4Z=X3sVK3W+vl^JPKY(HjrMPJh3+Okl;>8Q{e->CIwMR?`2AA zh2-Afat{nWQ)eS1sbXh5KFHg%1W3ZDo?||wSWy&6i5(p z(7ApyKP|T?)dC%K3-o5x5`0wRjkr?Sfj_!Gf~!*SB!E~z5S2&}SwN6ad0$icmSqdg zDN_DTsGi233f^S57ui_UsEqy4ve+3m zaut^<{8Tf-MY1m{;kbH}Zxi`QHOeLb66)e55V<6i4%e&TO>TExE>S6alqOf~K{5mX zMs76A^|{B-bPt}R%lGqMOSyV238GT;6OGDZkN6zf&8-!s3LV7@qFNFTqg@cGrBg}V zvg1TH*HQ)4Qa~|l7MChqR7=9;Sxb^$T>c2%nnrDk(+D5sC2}tUl`~k=o7~a5To4zl zC7~{E8Lu9<7KHV%K$B%^$+>fTWgV&*dTL5hP?g^tQ4h;$SV zqFRMN6}-u&H=Hn<8~Pw4S8=JrPu?wDB%3@@1#j|~i+qq6<&sr|x_AjhF3B|ZLEhv( zqsyh-l|4$6EB5g0gS^T856cb0`~G!CS1{E;Yp;f953K2>P(Bo>{O5TmM+k9OP*m87Z$Mxh*+|=YS}76Rs4l;ZIS0r~9rT@(V$w zd928EODC;2bIzU~n~oF}KGw@Bh`6>fm(gPt2c-%f`IaEkOgMkxJT%bFcwX?0j4)yo5hRm9KlPAo2}CrFpH$bW10#f8d;Jv@CD3j_!n& zxQFvY*7&XkN~AU+dPU zig?~En~x`scqD0I6l9WC?q^OMLeOk?N@a}nqrhT2L1eq~OnE2Yvx15Om54a1=(fY; z8uF-wl@XkCB4LEB&m*WvnWzP3!fo#v6&#UK(KBzrJ16pGE=be zuiIwzben|~vzbQ5J$FCOiFAr*L_1()fk!o>6S$IM_ZYPM0az>|h{_>|EF$RcO5ap3 z{V;?4FIW>Ql^`np{r|Z1VS4FXm0J3~dg(_pQY(X5$dN(;{z$P6A1!>XOA|yqw5Vvt`qJI6a}Q?@ zs)Kk&6pm*1cj8x396Q+YCaEY<1<#K zVwHRupTz<+Z<)+Ilv>9y?0%zLKoChE%amjR)xL>~0unfcX$^uM` zA9at+IFQ`ooHNx;A|vW6X=FC@S;n!99!4DT(rl8#oA{$V_u&r&Ch0@4+kqRE$7S8F zf~b`UBK-tebrh;2qy3v9Rt3@1tud8%2A9&v@qi-7Rdgo~LBuiF$ic0%o`Hi#E$MXy z5yzqu9E}Vd-|8HKh+_$J)M!!`dnH|E1W0kS&B zD+wZwH}ulKRjl;N3M9Y1UV8dOo!QhMag;t5R|?DUNB0MDCAr^e_qgzf`Nax1*&b9f zL1YC%Rvj7r)VS{>8n|^K%{Q>VrE!R+#36_{wg`vE+VC`_sBlKNsUYIo!Cc0tT*X1D zLPwqw z(pyiZ20g3BuG;Ev%t7tu8Y60R8VO&>{xnOM^M73!bweD{jnoL2<4W=2_vW0`>_E!}E>`itPk&RTNT(YH57tcZDlFVg)Be$h4 z7ou1;T}zWIwjh~n|3+>&%k>EkFa@XinS!zP5$c^%F%gnPz;nx!OFkVyHQ*cbC9~3=p6gS;rDRe5<2hFwkTHbghU7J1c{GMnzH2lR8ZAj) z5(JT~C-6ghyo@W&<#ymo^bLTepOg;@%UtVTmPvUFqOuFJ>L^r4VLBq6M4vmqo8hiE z;!r_2NlQUg3sbo4ckdB%n4To=q+)B~2A78<3nIzWnev}_#C+x;t7I@Dt2h~vC2_+R zrK`$XT~#`1K!L8ESSPB%5Jn+Dck2<4ajrIS7z5do0s|pKvJnL<|B8*M)Xy;o)fQQc z5`$T8jXSQ&ysB%|gIKh1OV>ycY4n1wkgP4O=yHc$Y$Lq{Nx~*fR^rDiAN7V(Q zSXy~hfgW(BwF~m8fKxwR%jK6nYSvHv80T((>beS|oZsgB>fu{dz4lf#bx*5cs{Fez zpMIcR6gTzR!b3U=qIDYKCMx5JW^ehtEBSzuf|5(+bL%3A{9ojfO!@$k3f|;yXSqIg zDw^s*_d0lzt}~##sSds%P^V?h!r=USbBOydgOuC46$FtLc8e5`akUGvYN1Hy5=2}d zF;@`AqZ-&luGTuhKDYmE3tm$S-4j**IRvo7{QQ`0A`=Ol|9?_`)2($$w-(I= ze0UF+)2Ktr}wbN6KW&nM|Xg<)_j52{}N7aYlGokfLA3lRayIMY`myk;55PeK<0G(j8 z35a%md`#Pbeq@vbM0+7VrUO9d865?>z~}_f&y4bcXcx|hKjlm(#(hkMh`Y$>2GB2z z5N-OEkw1R(B@U^j1!^(A+#gV{`xkpPnDjvDX8+RKQEbB0)TF7A++HW9r~GYuU8Tzv zK+>t3ku#!Z)}wK;@!o^s|KRNq=p}t%AoP+xur8xuXkle!1qxsk3RHnn7||QIe?}xiUpd=C=RF+qj;dojFN#SGD-oO%xDJC1V#WQLb|SR9i3*CMwN-Hb!fuq z(NjBx%`kParc6%lWU3F4HZvuu6M<<76FQkfCnls#9XsOz)3nJG5Ql%0CZ}0V!%O64 zjG#Jv8!jU&PVJzD*-NkM<{t)nsCOiINtmTDb6dD8u9)`STYCQr9cOrMZ8Hf6%t!~`DVJc+Fn$ELzmiOHsE zNr`Ebr*<6B*_t+avUS4bNspLPVZup|xbKav$wM*ymdY<9N+3{Q)|F;lG!DB*Fry^m zz%gP&Dk3-xE)lCnOPfYvytv0P$<>&Lkd&)4R#3`m5@3% zairL0RQecO#K0~giOC65N2X0p7@L-Ai;$5RlvD$-J7xe8wwAV12Wa@X9!Q}?ubC^7 zF`P<{Fjl8iMZJ@Gq?qJ3QcNX}u6N>_z_}3LWIaD4uZK~R5+>fkD5cs!m4GCZ4W@d{ zOG-?%tMErQC@qkT87zY;b`~S5Sn68treaaOD9Qh308@GTLAaC8h~-JDSf1!1 zp2MB^9@n*5!boG$FGgP*JNeFal+zDw!qAYgUx{KM7I+R25PIRD3Zko*U}X;?#@ zBc&z#NNGuyyR^p6k*H(w=NVqqOZ$pf9g3B9GJ0t5J+@bmp}dsE36pkfz2-ux#_$GH zk1!jI{Fol}+TPPOQ*T&knI6W<2Tg*@pUJwKynWDhi-kr>I6N-eZfkQk}ZTfB-= zVx@>wSa%UA4NQ0JDR$_pe&|)cRNcs^$*H4kj#711Mxh)@*Br01@=CYg-~r4+K|cdQL{xU{6B@|4ABBgg4tsVYTX@s=uhsZ8!k zs?z07`n#8OL=VNI9$OZ6s~;tH9H${{7ft)WD! z54cl_L^JX~(d=$Zbd7VS65V7(C8FgLV>u9oKps3OVM2P6t+WSoBM({YPp@)VnBk|0 zsi^E_Fei`&%gT(1=x)j`WuUT48Hi7n|4ue5%efGrzn&lQsz4=}hX)V9F!TGKYJ=|Mle|Rl^nkjw*xpb#+~B+Vq>(K7KPV;n$4V+7qrl8MgjV z?T;FltvN8J+KY>pB=&BZzy9oR7guK1dAoj+1?hi*UEs^+CfSJvKLepylY#(iT#E}nj|AmHKe&Yt=z^V6}fuWxi= z-Q0FnDzd%V!J{IO1Bdc=*(x>Oq7wGw3!nhG<((eEIKAGcT3f44x3W{$ zI=9U$>^$&7*O2#u@992j-K&#ALazV((fNWC_aFOh;_R=6$6a{)%Zc}Ao&MGS%oBSv zrhj_))tIJlM85e*@`(%6KfL^6i<5gQmH+Nrm9DOH%FTZ)?x#OGJ^sPt>z2A^r7fOa zr|yz9i#qrAt@+Tsn^&yacF@03#nX|k+ih!-T(8*|)fQd-tXA$HyDVGtXBOPryfo=z ze6!y|{v4A3D3D_RGt=?)^K)a$A`asJJi}m+3%fEk@uI+ z8T(y?@AZ^dj`i%ZbIXRH4WBICJS^j@?c0Yf*uHbnoNnh^zUi8Grfy-<>pxcOHKg2> zoA3X$>hY>IJ{YjeK73c1@iFZ>^*owRsQ3|lqZ@jOxd(y zK+>Ls3UBP4ceu3l?>7IH70{={Q?Ip}=~s1q+?O||PPlPTOxJ7gwaEP@b)ui|j#Y#D z?w%B}-E{I{*W%6>rtLZX{lcI&ovVL+?)=&JcmMF0x>wgjxmhDRjoD!TWzQd%pP7E$ zxo6(fsrvK!YT-%s z2W?UH*CTe_(CD#0>{oiLau>aJCF1hM1O1eJ)OA{3wVGX?yH#|&=fE3V4mWH zory*3hrRnw+qbS>x%OrD(z2a~e9&rt|I_WCy!k=@W%D<@-8=uC8RxG>6;6)cF`&kG zE3AX(rL_I>vsT^nxA`5LHmk><@1A~Wz>v?M*!1gbXC`~fTl&+VZ}pne{~piyGP$;y z>kg&*E{Sc}=;K)*9Q#lAk!#Jb_gXr&Z`)~SgI+K4In?9mj4g|5%}jncVvJ+qbFPT? z7sB6J;B=Pze8jj`&-SR)@ZCn+y8M}|+S8cfv%Z{=Qn{+SzLqfbhcDJ-tQ~VY|K0VI zHmv(AeRuz$;|rU=_Il@toogw|^HT*4qSi+^_zt?NAeBPwq zHwV`0S>{Z^<2{=W9uz)#>R+1|PTAOITD!<$A<>_I@!cDK9ft1An0%;d<|BonzrApE zz@cN4T5d}ir0y>?u9|o0O#Qx1{(L|5i7sFL{Nj@htE46j=%eI4wxa42Z=9WKQu3}0 zz4*h~W3!K_^cGbc%{wHzqH6>h|f8-;T;pNc**s{ewk=c7?Xd&42vnisxz#IrVFI-zu9bOtMby6s*#_ zT*#Wfu=`_Els-y7RbKz+95wDgerBaAPek^voQRz}|4{V(E|w_@nYhQH(v|)GDjZ#5 zxAXT=9WVaeY{P}F=DVd={B=h4{&d`H1wUnkgGPgH&E{bl^XWhsRPQ(wK+CgNQCj7qg)%RO^`sYT^mZGXk4qiTodv>8-> zPOqf;e~w-~u*QN%3O_mjXQff^CwINlJ?@Y>sKTb;_7$E_ikTMWmw4pp7Xi*Sk9@P> z;_1DElQypZ(PZy_EiJ#(@yhp{3mv)P*-N!|SAKc)%rT!F`EqdfBY9Kz4hf2__(|-T z$G1()ygkzO-3Qyc_Fwa^-{{frRO|lWqP}hVz4X&7!H*qO`i$#P@kl`@%i(oxejQq| z-tdqe&&+(`%ZopMVg3Bs1}Rm2;~r>wdVj0;2W5|)y>n}p?_*!wiqF{7cy!};7Hn9! zw~8(EsrII|m*&0mNV;wDiSzaDeQNJp4RhPCc;Opg&w86t@q_iXvaX(d<7#Bl-hs<} zUwve+Z_By2KACi*@a3KX=E!Gje)7xC+BK&?^F)SIGZ;wsfv-0Yb17=pAR6laEU)RX5j&B;`n_D*a zu*yf}8`1BTwYw@mS>wYc?=JcIn^wJ^XlQ+P#y1}wZ%}vG#eMg#KKS;6dh>5wUA)kf zPwBJw^v&+06BY$3IaB^P@=E{HgIDYvJgj{8W2gJ5{8ulT`$>;^zjXDKv%>Le(YLk# zv(CTLL-zG8r{}(V{EXz!ff&yP<$Qtrhr=hpO&IMFQoo$y*OH}6+=rT;5~P7ii``pAAI z-!ngTul&_IxaYLm=bJtL^KpXC3&12Ud+c5RnIfLuE*}2czI;_$fj48HchPBvq$s2ZC=co(tdw>`+4g( zyuC7F$o3^O`n0W@tIBnAjZgR5duFGqa$OocfAjn(wK_9h&%S+oY59Yp z%8#P*{(5TDsfZHoQR%TVvT27o(zWj{F{{{n7Zu$qzp7wR52}abvsA z!#}7o{cY9WPkjCSYs&-sHdFbl{>t-S`Kvjt{G!g=H#WiX@anF#pX)Ag= zOt*I*n;QJc{i?sp{B~lSxl2BO$^6m}zxlseZ@=HcD{X&yuKm{ZSyw7Qd}P5hYFvpb z(>mSvv8tU^`S#oz7XG+tcN2AQ{j>`H&oSqL=L_oPJhuOIYL&dGBjGO;?DZVK>ON2u zkT`3vP3f)ds^ko=Y;E^Tt+|cH-M(k@@4M#oPMkdDT=|5m4d>r?dHs$(L3Y(%2S(bP zU3jIYuacwet>k=e>zSH1px5lLc71EJ)a&QB+5W(@hySdYUHDtq_Y*%zYqDV4jG|A6 zcly3k#Po#ww!a;7J-qYm9|u12^s(wsAFQ|dy{%mn+i&=y{(@;ijnAE&aeQgPzQ2w- z?wyp7Ib_J;VH@8+dVArp>9sZ|$4894_Uj+7{623}pAQbqZjw3H;%P56uj;$}KYJG+ zd}XK7Pt7~q_^e#s_WLU{4w+7OGEZ#~@I>|ZR&QR`^z^Y8{&VAvr#~Fuu)?~bwQF^` zPtCLD*V%p8vTf-}HP8Bd=-%DWZ@K-hk~5)pLd|~N-@5&Ga?VwMHFx4w(-luSXejx0?xPAIv-7Vdz)SUsCm(a`M5smZNq1whd}=;A-4!o8NmlBOZ?( z**E;U&R7ur`s*hq4B7Hh`Laoonac)tzWUcqWk)sN{w>#a)|GVfT%8Yl9(kwwsp+2c z-;7s>=YD99JNuvPCys30Jm|YR6P|l}z{`$b)&1)=j(->z_E`G2bL@?0S6sK@+Qhdi zt{wM;Mcr3FesxXz_pWVF^yf~@Tw|N_!;JRd{!y*=S0C>^n7PcBcktl+T@!b3`tiaAKCou_qAHT@l&^ZEn~mf^YxD*Q`)X;m$G$!?f(ovvFS!aqd6b_eE-Dv zyU*=)(DLQ_7S4Vtk?;I`G`91Vp0z$*^?O)Wb-!IT?rXcP^YSNGY!17a<{V*fq3c(s zLd}>(4?Vg4nFe*+PY=AH%GLLU{FhJ7O)?cdaJlK&QHA&YzNf-p4PRe4DZBsSu?zdI zI1#inXjqv>EuXJ{vHkat+s|&f=i;ow_sX^0(mD4?w>F!6YpV2wPiuErbJg`u!y!XX zhJ3p2i|=}Tym{`n&rS75d~)gCgvtjLeV^)&{nal%{Vh*>l^o0SNvUMjsb{Z;x8Per}=$$d?-N~2Tq&b;^IhE5~y9qgH(D#!LemtSc= z;OYU-a!%;jZqk?U8anh{U+M|z@q@fptN~aNh zNDH$My>vwA*v;(EO6r5n4iA0GmCy%E^B#GXq@fcn#q}}Lh&~mVh7PMzu8Y4|u*;~A z&`_z(K6E6Wa(#V=rDsW+N=%c2U$W2gMjI;|X~fQm^3bP}pNCBo zyJbF9l7{xf%sxNhm+CZg`nt(R8Y%ldOw$a%l-JN#x}K?K&{=5iWg60oXzu@T-UCJ& zu@7lt_W20ERIXOj*5Qo3yIdkCm}#u|rIZ)WP0OlYA}@MtrMPdDq@hopxM|M)k~`i= zBl^^08hT}cT3X@dp#zQj2n`*NG5ZYAXoj6VwW%b{eN2<6(LC1W7TN__!Po}tFpX-1 zTcW>9zRyrD$%|fCG5hSmFWKk$BRP+jlw)NYCFi5cb@tXZ$PpXXV;a(mv`870{c1^? z`b?wz@QEy)nuukTcp5$Jj>pYX_U^@KW+YV zNC}-AF^$r>{A&-qT$1MgVl+!X$b7>{Bl?6gO*&Md_TJ*zU8q`5eI8&MrBA}LIjcfT z=tHk3n0=H!3m^UIg_1OlnT9l{9I7^dJI6>P`ZQsh!T2Q`9`AAa7o$ExL$7O@eP%-l z^<$Txcor8=ovHP?{h4%bT0-aMOk>o!BuyC87 z!xkm2~5jzn7%x z#x(Eam+JJJwYwrq(nK)LAo|7Mtj7b;m^||W8}cfPU($KQ+Pw`+(sXAU`UD2$wJv9B zUP+oBOhcn8_{Z6jI`?K8vJ%;_)`dgpAU*BehiRyEM6+(t z_Ag4(#4-)_LPS&ki<59(PdR;=hGq*yGc9~bs34<{kq4T6YJ$KI=+>>!fkql>@BNuZ zwVlkYmv{Cvv_WYXJhJ=HheXLg-ijXveJEFBUJ#AE0yUa$S+UlVH0*&s^nqxSb8$dp zOfEd-&?q1}6HV=eob5&$(V1GYd)&D^CwTkd5;{N3H1w%x8sm01OM*CeULt1*)2RN3 z#*2pya)f4RvAq6RGU7QSjo61~v+lAdr>r_)%u8s7GmYxQn^t-d9h+Mpp&7w6_3%q! z(88t{OVUtpVD<@M3Vg2Rr@Eh(q=_#^^Vq7*D1>KT3B_n?hG)UuJZVNTO=~oERFr8& zi!%R3^3d!Z^EsF2jqAR+Bd|Qx!q1xT+rD{zKzV9}=9!$S&je~}g(mN=%qN{1Rh~N1 zTnXhl6!x;So`;TL`?Jc=Ea3;sQx{O4*+PTm3DlrB+kdb;PK_$hT+-lZ#dGBmkFSUG z7Zgs+nHP{o_rr=$CLb24xsWuM!86il_iwu-P;(J!=HoLwR#g2CCr1BR&|RR+sql

    J5tOWDnH;F$`jtt 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

  1. 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

      ^H);Oe$@3(27YWTi1r_e*P z#*-{~zm2A%yg7v)vZqWy3icE@M#1}SGh^?-u++h{7NET_;zs7Z=q z5WcchL2cLma-2dB*{;b*$#n?tx6#y*@|;2s$(n+c+?U~%z=|sCgg>XyL$aolEO@_- zrVa;i3Oyw2AEclf(BKubvFcp8w-Tq&L$aokEO`HhrZQIH6naS3bW@hS+O8IXoI(%D znnAKgo$420w4}wAu8R0^t zjiIv*i=NHvy{tfzS!WYbw+1%)0m!evN#v7VE&ub11r z!Zfuxh-aaPP|J~O%?SA9hVM^bztL3B8k|B8p<)E9{jzYqX%y zL#nX@DOnA8-TAx$s zA=Exafg|ht<|)>yY8((0dPp_)BPA<8JU=vV4K)i*vM|5HMO@P&q5EO4kHC?9vZAeP4#cY zDfEzP96?G}1JnsNVr9!+f&6naSI&#Nq08^v3! zNTR7%fWUg6dtlkLWY;uJ6>1Ke#eyDE`Kw6D zS^jk6M3|l(=#GI{q&P3;yGdPvrFlC|g4(Y>0oYr#i|9+GtfDY< (JNS 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%0D*{ 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

      t84JNiQceNVPmQ*tebK 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±eFL3Vs+z(>j1m>E+xz?|% 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

      *O7(zNM)i=Wn6YA=sPm!>zS^_>1H0({ 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 Date: Mon, 23 Dec 2019 16:45:58 +0100 Subject: [PATCH 20/24] Compress static libraries and integrate them into the build system (#502) --- CMakeLists.txt | 22 ++++++++++++---------- MANIFEST.in | 4 +++- src/third-party/linux/lib/libmuparserx.a | Bin 3239354 -> 0 bytes src/third-party/linux/lib/muparserx.7z | Bin 0 -> 259057 bytes src/third-party/macos/lib/muparserx.7z | Bin 0 -> 306316 bytes src/third-party/win64/lib/muparserx.7z | Bin 0 -> 404454 bytes src/third-party/win64/lib/muparserx.lib | Bin 4002360 -> 0 bytes 7 files changed, 15 insertions(+), 11 deletions(-) delete mode 100644 src/third-party/linux/lib/libmuparserx.a create mode 100644 src/third-party/linux/lib/muparserx.7z create mode 100644 src/third-party/macos/lib/muparserx.7z create mode 100644 src/third-party/win64/lib/muparserx.7z delete mode 100644 src/third-party/win64/lib/muparserx.lib diff --git a/CMakeLists.txt b/CMakeLists.txt index 53177bc138..eeb660bba7 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -189,18 +189,20 @@ else() set(SPDLOG_LIB "") endif() - -message(STATUS "Looking for muparserx library...") - -set(MUPARSERX_LIB_PATH "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/linux/lib") -if(APPLE) - set(MUPARSERX_LIB_PATH "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/macos/lib") -elseif(WIN32) - set(MUPARSERX_LIB_PATH "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/win32/lib") -endif() +message(STATUS "Uncompressing muparserx static library...") +if(MSVC) + set(PLATFORM "win64") +elseif(APPLE) + set(PLATFORM "macos") +elseif(UNIX) + set(PLATFORM "linux") +endif() +execute_process(COMMAND ${CMAKE_COMMAND} -E tar "xvfj" "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/${PLATFORM}/lib/muparserx.7z" + WORKING_DIRECTORY "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/${PLATFORM}/lib/") +set(MUPARSERX_LIB_PATH "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/${PLATFORM}/lib") find_library(MUPARSERX_LIB NAMES libmuparserx.a muparserx HINTS ${MUPARSERX_LIB_PATH}) -if(${MUPARSERX_LIB} MATCHES "MUPARSERX-NOTFOUND") +if(${MUPARSERX_LIB} MATCHES "MUPARSERX_LIB-NOTFOUND") message(FATAL_ERROR "No muparserx library found") endif() message(STATUS "Muparserx library found: ${MUPARSERX_LIB}") diff --git a/MANIFEST.in b/MANIFEST.in index bc15eecdda..1986959d97 100644 --- a/MANIFEST.in +++ b/MANIFEST.in @@ -3,4 +3,6 @@ recursive-include src * recursive-include contrib * include CMakeLists.txt include cmake/*.cmake - +# Exclude static libraries (they are all compressed with 7z) +exclude src/third-party/*/lib/*.a +exclude src/third-party/*/lib/*.lib diff --git a/src/third-party/linux/lib/libmuparserx.a b/src/third-party/linux/lib/libmuparserx.a deleted file mode 100644 index ae4dada2094f056c15af27ff1ed69e1ebc07b607..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 3239354 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

      `Z+!KQI zU*oFv;Pb`KFtMX?-6D9q;2PIg2rmtO9og5ozUPsDLhvs{1LHpt7!g&@RG<% ze&Jb>uc7wjqH%2|d|2?^5TySa*LDwn;85xRVn^dD6Z}5GHLl5omj*wL>}y;XdE}b~ z=YGdU<623$E3Ugm{zhsyE*jSpgbxeu4MF-pL6%H`aEd`mb?)fN;)(Ek9cD8DdA{Y9!nh*F2H`i^ywSiwPeVtc`dl z$kGZAzEj?0!mOz@k;j>dHf;jXwEME+3X z;i7TfNcgbe{t%@98rMn>{)pHq6FVB$ZwYtt{*Ca`AV1z%(h&?g)GdFk2e0^{#1mkKlgg%*BSfy@z`qrWh4JgWJmpc!{E z|7T=J?U!UZZ~uyLwLi?@artqCm%?~>wSSh8|4(E`?O$T>?Gdi_TRrmE6J8qR$Iq+% z&l&mr^HXYnwZV6b`m@@9*dzZ7!b@Siz1rVwH`$PbC^sQnKbeBTIH|7$(+orIUdcz(6N*vKCc*-`snGWh!=T3C{6PG`j@KShQK_Mw8~gd^9n}87;hdk!$d1}S$lzy1xY{4-kw2aA(jfo* zh1x&g$e$hAQTwwEeolm|{VP54HyQi+=Rwr|?MD9m$d20ow!x=GxY~cjBmV;7uJfpO z2`>#UitNbGt>FDfy5&a_UJB2n4GF?>y210$ohjEegXfmS2G2kLrT(ljcxxoD_@f5TKhL$d`2W1YyJGTxGI;*^EcO522LEUzuYT@L z4N(fuTd91h!LN(t6(4W#{PRB!Sl~6sr-)&o_{V$<9){9`R9)mf5qVW=ZqA8gK&*eQg3E^98GwCM8f3*8IQw3 znFkMQFP_#}HTtBsriS{4E9txHwdRB1?OpYqVbz4%+9vv%d6TS;9$VMk+*;3H53j9j zpBu`Y&@{KDwY`B>&ONENc5X{oZGCrl)tJ$>wX+-M)O9s?){@EZN$lct z&*tv{Owg~APd#^9?Fr#W$15vmH&o8A98HF*FQ}}k`B3ed)6bn;GxfZ4Yimh!92xEC zq_3>k*RoShb3*Vf!!R^QgfF0&^mO`S|}&8n-vV)FRP3(lTa&RnKO-udo==@suTnBM4a!{&wc zKHOnOUvTfTLuPU=oXj|JenG!2Z$2R4GGr=TmZDD%*rqr?^vwbrW_k0;1G_@MnPB7L zHy3P_rTL2uE}XykVB_o!eKEoX(+4M9FnzDWhS_)XxeHf?`EG_?!EW*gIBb0M7^;Xq z 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


      SD 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
        Ntl%z-5DgY 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 t%^zsvfwLOz>(`}q!K^8b^onGL!)j$h z|0ESY<{0x9Wo2{IhzZ9ZbBwrtSjnMD^U03nxfj_;POEYl-0YT%>=MOG-Y-&0W+hxFhjJ^L6LX zlkDnVkfq5{NcNpxkfro%xldEqj?s=1YfK56&Vx$)&6J?@Yq@wg&r@Pa9&9{sN<5qg z8NvjpP2aN590O=|I&v=VoO@uZ-TWN%$fFof{6%{Gt$Hh}zhf>M)o$%m zOD?CQHA1!yWb}Y6Z}DSCBK?#4FMYmy()u4q+fz>Ml{5>#lC5{2oZR+y%C2pnYO%82G0bfzbQX1{MP$q z&d2i{VLpFDALTFS{2HB~J0&c?g!7AZzM2c*QO;ki^K%!3<=^CdJkt=`&$W{}?9X}G z%vpfvA$n;Y&Rhcc-Y^25*9h&*OSe-E=O3=~r`vq|Vtq9@g~4<#o?+({%vq2)D3?Ux z?>($1uDzj0P805q*Rw?QY+^mW?b3(JBgC~E?BMxogznl!zFXq+cM~Ahhk0X5V7{S-BFLM4U2ub-b z+VX{jHgG;ahHbwPo(ExmS6j;PyeBA=c|qjWK0%hwePf+>Wv1`um{}uj z5#cz-Kwj1*E@#fWgfJha6K2Lqq|)IuN3Fv;vh%m?s_;;AFx){TRoO zib5iv{G1%+9=j)c_-GHWi1212XwOd0!E>Av66R}7vX+h$;TL?;45@^9b0L#iJ~j%C zyxDU{@)G82H4#ku@x*5|BzSfk^Ph@

        AKG~OJ%?K8;8{WbF?%*{R-859y`h8vsK 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

        n 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ⅇJaJk`vCkN z7Wn=Ezo!L$D8TP!fiDAi)h33Gzp((nw*|f$;P*8%*#7Wg#4_prcU#&}u(?Qemf z1NeJd;M)QI01NzW0DqtbehI+GE$YAJ0Dp)D|0;l2bMj&1cP+ptEbtou{;L-HZwB}y zEb!X^zOMy-C%_+RfiL2~m-T-?3w$qtKgt3h1$fmb4x9f20e+wbzLfENa^^3Ov%r@D z{wWsmHx}S)E%4OiP( z4)j-R%EI#R1pFf{^e@`m-~WzT;Clgl%0mArz+Y&A9|-W{Ec7o0__HnWBN@-x;M6~r z7WlCMKfwY&5#T3T;3ot8L<@W!<7NNh91DCJ@PE?+-v;>Am{QpCGY8 z@FM}f$pT*q@XZ$Z$pEj$)Wg=l^^BMCbFl?J4frz__{#vk#R5MU;M*+l3jw~-qWmmo zy!79j7W_*9f0G6Oa)58Pz^?-MODyzX3-B{7@EZXBQVaZM#!LUJJsn}=e=Fd>+=71x zz+Yj3@4m0U{=U)z--Ge8{+(rk?+x(Zw!rrT_^T}N#Q;Cs0)H~V&#}OlGhW8e)fV_l zz<-SeeloycYk{u^`l~t3u<@S;{PQgEmjV9kEbwyx|9lI4JK$enfnNmpueZS84frp% zsDG9M{C6z)mjnIVE%2)V{<{|VwE%yk1%3m--(-Q`%y?OT)tr3T_}>cnzh{Bp0q{3l z;Jb6hE$i=$Mf~&x_**Ra`v8241%H2l&syMz0(`3lzKroQ|8KXjzZ~%2VS%3r@QW?* zH2{C71-=2`@3O$RF<$!bM;7>5fd6g_`~txLWtvk9TYeV;{vTWLF9!H~EbvPKUaiRq ztN#js|A_^DHNf9%fnUdXng54d_+r55?O2Jk;+ z!M`5hpSHkn0(kXKi?Hq2R$%|-7WnM|e~Lx>vlHmQ*24ax{rvU!a~Aks0ROxNKFW9* zKfkxY_XqfO7WiVI{|grQlL7x9Ebt=%{*M;;u|R*dCOB;TRs;Nt7Wg`V|FZ=?4e&2p z;4cICmn`se0sa*W{6c_NYpTQge=*}_{Qt!QzXb5VYJp!4@PD2sHH(TJh0sK}A{7!(s!lL~s+TTBZ{tb)vqbK9}F~C_r@_!ck_W}5KEb#pS z{#^_FP=McNfiGjcEPwyBz?TF5?H2fn0RL|bd=0?AZ-H+B`2Seo+W=ne$p~Bj%>noi zEb#4&m-#ozBK{Wv{wpoY-`xQJUkm-00sKx2{7QiTp9Ovmz<*?cUk~sfTi`bVe8eLE zwgP-N3;Yg%-`xV=y{Etaon;X}Jpg_W3;te=m-Y9a7WgQ@UuB{HK!E?Y1-=yEXItP$ z0{ng!_E!SD+S3)b{+i5qS^vzj(7z7g547NK0Q&c`z_$VXK^FKq0DrIrz8&BXvB2L3 z@VzbYOBgTn?<*GgWq|)s3;asJf3-#YtOj_sr!Z{%t_Avk)dIf(;J;>p-wg0k3;Z^K zKf(gP6X5$=;EVX95Hfy_w7~adysW?bS>XEs{52Nw(;wiEvEUyH?9W)>PX_#IPixrt zEeH4k7Wjz(f2;+*2H=mgz&9{n#?Q4D`IiO!B^La%0Dg!CegV+G%>us=@T)z^Ve@}6 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

        SK;=*3Ag{4@YMgt=s%8o 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 z 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 fU7X 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

        !3NG;|nPM6HeDsynxdS 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 JolKYi-vLM3ajO6T diff --git a/src/third-party/linux/lib/muparserx.7z b/src/third-party/linux/lib/muparserx.7z new file mode 100644 index 0000000000000000000000000000000000000000..5c01a826c000461d7878d003cde72ad57522220d GIT binary patch literal 259057 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

        k44+1i~Q+^hZ=aWoUcRSywED3000e5 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

        QvS7kW$2hn;5H5cOmbR@^6R8a{8BGCYzmW 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%0DrAlKWPWJJ62veiWDM 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 a02B%V006?ID-^la0Tl)T03d**fdBw|HKyeN literal 0 HcmV?d00001 diff --git a/src/third-party/macos/lib/muparserx.7z b/src/third-party/macos/lib/muparserx.7z new file mode 100644 index 0000000000000000000000000000000000000000..5ce6ce42ad4013d9c6892ec99c2841641826a0ff GIT binary patch literal 306316 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 A}wZg(QL&X}Jn&x6A@6HKL%HI3Zy|u)r%|;{-{F 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 z zyG<{g2ojE=VT}2WCuzI2i)j)^G^;*h@>}zlB*6c4k14JbdgllgDv0^~wSHef!(=v% zc~I%=?pQQ`c<8!^C%WJ{q27bplAbW-a&TYcWVymu900-2#V-V;+&<9b_n!Urpp()2l)WZSm6{_Nq-w#;84}yTfY0Q z1|bKc-*0AWSdHm5Mecs0!nl9WR!o>lwGsGkhELMiv@44aRF9uc+{}pSuSir&@03o` zWo_XFCc3e|HpU%0tCi2~ZUmET*BAV=tgn9IM+AbsqEJs>>SB#LC&Vu}c^Hcp&Z;LCB!LYr~q zSDDdUvvTIuA@Xp{Wkgq2!+{8}7S_f+WR?Qf5LKbaMAB>^#Xqso09Fu4ZSntDm+K(I z_uX(W>@Z=dDycj`%d9^P@>gDeFy-#b964{T&qC5BfG;klI2|epRwJj!F$=mbFPuM2 zbvBIvb=N&N)g7oX$fYq3jX@$+u0JO8kefsS^~X%1h-qIIkBB~vmVXH(+HYZCCg%Od zzv=8Ker1e|1t5Rd!cM!Q1v_6N59Tn+9LT1GL>0$Th z01-(>c6PInkJO WP<5fR=PC$C_?PNnml{f*D0}d7UmpIHB#_Oyd2z_|f6DKK2q5 z696={!-BB)@CQWY{SEH@Z&Qidf`aGk{Qj=&j$>}jP2L3$QoXt5`GfM~?WO+ut1Dw5 zOaUS8+t|!PLo%}EWhiYm1ak?0UpRen>>pHOdy)?DL1wmj^k&eTAzT{>usX+5vF;pF zurC!TB;+_u3qQ#8=_tz629qb_#fYM!Ia)J1`H8aPSiJ!kA}EdyD}p8N*G$;iUiR&M zm((1Pg{m;`X{D6)gb9C-vC<^q4zpU_frZW|L;{h;j4YV#uzT}z%Rm6(%NtG=jdw=3 z-WZvU!iobroeA?zW@4EzY{Fw(OzhTD8UZpA?{GsT5kg(-L5YQL2mo%)RxkU%0K5t| zIAp0K8BubAM9=&}7WxMb&49 zOi1#2T<0=-EfkMeSb=!@h5cidf!oBj57_8!cZ1;HaiWVq68CVbw_lGIH`kbBX*%&g zv&Za<*Zh`4sfgy`>xlT`MOYuSDTLI(0u;JVHMHG6D3mdIo8sPLDw^@F2}S6%Hv4Nr z=P)AX3meNHJ8Q3e@^489n~|4M*eGchky>g6(;B_wv(R(Qh$fShr7=Q-x2n+XTu_YM{;;z;% zwQ1DbYcn}-fm;;+!!Qz*LR*>uKS4m9t8da;Abx2FVPTT9XCFlqm&={FE!$TiB~63U zuasl17O5^fu&hsBDe&D7?T@OYs|#W2Ns&b%Sf&K53U!_z6HiaGDEEI9h9W&du;U%X z>xo6~H}`xb$2sn=E4>{@qWebbjW#1WbDV8!f5%Cl8e??HyVpzSYjj+*OL}LgiRJK^ z*S}U4hvC0!VOiO2ETvlbEuSS$O13d8JZ{fZO3H&CVkY8#ERfNOGk2lzk>&<@M37xn z%^tDdzggrt*9>A((cpDRMsY>Y)+nJ|XZ-o9-@szSF#FzJ3nQOG@eb_Rd)>H^O@&Te zW4JCq5-0xzX3FGj6m@z0c?=_NO$l&L{*-_gNurl*C3cpDbDX&Mr{h=)LIk6Whn~aq2Fj2yVUc; zf)Cf}T|-lwGW4d6u~S`>kdtxqP|7)2YFV3XV3`;sd?wCr_IK+2F6oXSljju``8VV( zU;Y!W2KU<|5Q`G%{!W}U=uk=$(>kQO2iG^@SX3>$_$_;2Bu$iK0)h9P>3B7#;b*6( zEf?ab`#pUJ_v$N9vq-`AgVxkuK4g8%yBy{ao)e@)*lO-GRfAHO*HJ*Xl zj{ad(yo=V*;LG;TUf5_nJhAj#O*0&ZHaPQX(QgcCu#BWb(3dNKFS-vu&^PGFj8@CN z#9ekw972d^*B2Lvsg@AXge88eJ<1YGWGRJ*T#%vhS~AI(8w%t z9xS)3z_Z074d9nj+Z(?Unhoe+F+julEN82H{T03YQNtatr}2Jxl$6Ma#5mLT?V*TQ zVUMKu81ysMA{JMQV_b3w{AU%mTeerv$3vEqU+Umrxa0%vR7ztqTfT?lrjq)mj14VZ zk$6hq4I&7PJ&%w3HRR=Qry$~)hDm1Fnw5ilg z#a86Afe27HIG@O91+=jOMIrR(B=e;~V_OT}pMz>7JY+O_N}_to%xic<52(Q|tqL+u z9^#=U!_R=2%!DlW2|Ke91gXDZh+pKJcSW%(LZ?o#jk~Z<<-C}#(M=pT9Mqo zhGCP!K`eqZ(}3)hXv77+Ar&LM&+nX~kno7djoS1#Rcp*2_E~tS(eI>3qmIk%$6C(x z1)UeNj5K|oMBiBln=YC4hod1ej-7~33IcXns)_$F29aE`z6(UL;U?JTLtd3Ea4yC* zC~2?z5QqC#fJ#n&5CREeeQosE*3udfbyfp0f$-LEs#C4GBZpgth?9u}Vo%V2(YA7R zBh4Ao{Na*{jgVW!_8jr)7tq_uoBmAfP$t){a{byQ(7PEfu^hH%^}-5$vn99IL?qop zFj2VFLWK@|8K!*MyEEX|W9EQM`%N1n4sgZOK~|chG!~5Y1Xw- zB}mbz5)2j)Ljq9x)Bt=g>OBa5ay1HwLp;^Eoa#Kjv*uIrOoJkFg-`!c1mZK#VAuA6 zgRH-QyC_$z>M7V>YdNoCdwU31r5~6HA;{o7bN!v5RbOBe4>CIDu)z$ zY61+WbLa<+J}-s{BU$d2*!S0+{K#8jwy$*u*eUSOZhax9~ zAXz6w%e45FTXyMF+W8;?Kh-#1$j$MBXq!>u%~A3PGxp3Ja;4$A7K~4c zv*LJ*5}V44oD!m?ke9A#<**{fO;&+Bn4Gb*kn>nw31n@L!+#ns5)HJ8-ngzub0DD-{_&9|INlyU8=yjhKdu+f~Q1-}U$fJ46| zcLJ<6Dn#p7$6j8Ce~#rE#HQPzE+AcKO97aYdn~U{LcJGhF#&w~ipR<@QAONri-OUO zt-NT$B;up4yGPhso0&}hAI-sBS7`HJo6xSrGkIcJs+=9pfi#-~prsU})p}N4>TcNT z#a(ZKqX^F?q{jHP)6bT1g;gwv0}@#k!~d@4EY+9z$-syoNI}AUNbTVvM+L?AEE4!m zdd`PQ<>$t>fO=;_z>H@>rv$;XEJ5UNKMW@UCO~Wt#rc7X@6ZV^X&9^!{nsX@FpZKN z$i9?a$+DYyFIHKwu9uJBZ}wb}+*&JGD4k>Fp|Vy?M%VKYuGY^PsB<%&y}U4Zr-~ZRQ!++ugaD) zdbFCoBPGjoRN4sHX&kB7$4!zH2I9Rx>9tCJZv3RH*t3f;9IJj2Z%I& zDCeBGnrON@T$112^Fi$MMqB{4EUR!?EfkBYEe>5EU9)h4s=QsUI|?kt!7%s8A-17b zY0U^qJIh^-03=ZZyRB>XNtW=4qJ7iGU^#FK7#5*i&&rqp&{mzM( z(E1!$lHlVUj8B~ z;{uHfEz=T=raNewEr!~dbaxWT&PSrHx;BO2{SkyFr`i)|Cg{+h0RP-j(`mJoERiaD zCO|98d6O{bes&$1lmHXd8fBMc0lfM@iNf3?n%@!Rupni?${E(IX@rMQA)}RJ0Uo}v zd|eH`(1Z1dE#fpm9NqyQSz?hjAD6!k1n7=G+?htz*CA0!O;q?^Ba)~Px=U{$u_l=q zQdeaWsMW^s;#3RWz~Cx;0PKC#(;f(`6DnhRtjevU90-zi3EZN-t$D!^~ z&;(wOYQkS2(Oa!IIh>sxUP^g8O%FI+$c7wppN5~vqJQ}L%}Er-yLQn>Y>tMYHDExk*>nv%FFrap1xEBfoN;)~wW8EzGu z(-)_vsvyRwrRZTMP{_qvPu2F+QYvKZVn0T&=OPd1#2Q2uM{4(F=gc!r8G*b1RRw=# zfcN%%sdWTDQt}{nSq-{skKa$(VF-}&Q(Q@LZp&ffR;f>iXw!XwZZ6F<0ujH7PntW{ zz}0h7S}p2nLgSQMdRM90QXh!0?Jo~#@X85yc?T9W$}f6C#`val){-A1H9xa5_Wlw%`vvk876;3_4g=R?L{;SSxtNTQBd z?w2ze> z*|>V(c$HW5OoJI81IDkDr4KeR_>CnG<|S7mtTzQKaSuU0uZR$#ACia(Y+f$ve1 zwZq*uzNXo0>7ykJl*ohG5nkoPUK5dvjRWmPdUHkfHEnk@?gT>gODInF$`t{|Ax%ECw8bD}zKOeER-k5~0hjxv#=~ZRlZA+1R+9hZF_N$}G?# zNp_);{leS+AaIwcTkTHcYrsDArl`}_Uko40w;p^oCAqj z5ZhCUAm`?p8sh}9n)o|`C(&y*8x|S5rQzD&yu+Ci08Bu$zxYdSSHfu=+=-87O-x3^ zh)}81A)&e@AiGc|^I61iY=NltdA|4PQh2RhJ$}`fh2L+_!TYT-|FZ4{@0cc~))bef|jdb1Z zMW6YT6{)A(TgpmOR8F-KU~?}$Fc$}lwC*RS(yO;RZh<#ViCy>b9M$}xFA1RZerP1z zor<9N@Cr3RNGsiB#eJ;{ueCA!nt-H1tZWS3jCqOMNtC$L(=tK^41eGs7(L8ZP~Rlg z8~o$vwnQlW^&fjXHrV&76kll`XGwz1$$a)NKr~5&!C=3-e2KIAc(gc=l3TU@t&ujo z2&>al=Ugsr@t>8@v94gn?YKwXkY^hG+h#$w_n?353aMfQ7WD|S4(u$AhmviLY~3PI z7sUU65-Mc^mq!QynzWlbzQW-sPsWoH`jzNUs4fFTt^%J9wRJi1MHtR){^&ujOonOd zVxsP_2f%eBv} zE6fm1FI!7swjEJ->P18sXsbg0Mo0o{PvQ!m|L|_K)+`?p`jWvkmu`>+bYE@oFRsk( z5!_J{L*UO)89N2Ssm&L;yIk&mDa5!`NU~WP(pb65t$SvbPKYWT`h$=zgAt3C+@O{t z?H?M){f!7<5#{7i5>r>xZ~vN`%ykvAKeuESR9u0Y8ohrrVabI2k|GWRPtV*0r%@J! zV1MKbJ$_dbTahB`X}f&nOjkOVi|z5M=q7XPW9CI%hb}RLrp?iFEeokN4x04Qmy6 zP-Sv|P#*z}9K9!68O&+aemYgB>j`U8%Om*8#K%6Q=!83$NO;EHrX@~B_0xTEG2d>^ zV}hIgrQHkK0^cJrD{PAug)!`+UomBD55LilSJBh@A?zs`i^(m1&(m5h?YmP%19> zdvNHF!$_db=^XI}{kyO_-Y_2G7ES;Ud1euHa~tOMgcEE-w7<;;k2NwN1$?!wSLy<^ zm!8hXIo+{)X}2_`-~NR8xP9nu8P@&!G3=B6XgWwMtdF|7o%bmNtjJDQ_^jM5o-NNO z5M3->cCEKc!_9rz_7KD^*i*z3U%#1Y7NEI3OxrsyozDH$LaHXbsV7d39uaJ&qX3yj zCWEnn>S2LNH6$8vZ=?OQ`%gSN&z-h`U8yjYf3@&*t}RqMTYZTI^u4GJU5y(H_u9TI z#Imk8C2c4n(M5#HGcNSfvKk?@5aaaOdc%juc*Ma&mk4*^)r9YR*5#@=1&5+sENQz5 zB`Qcvj)pxH-#iWkrgqZ0yu5WD_N_w0Tl8hDS@c>*ig5&?!@!&cWBj@C?_1o2knMf~ zXm&dapy2wv{B}~>OE&9=-g0b3(RW>WMCb~#6Rsghikt?~&y@6ZC;@QkYz#BeAmTNByOtJ$Qor`ZT%AWD z`meLgqm?n{U}5lfxzlOy)Z^h1)H}cFE>VP5KLy^*X5 znb9^kXu-P~9_fq4$$TG){dIOF)H(C{-EeqhxbIU$!iIYtfIdY)Q}!`~)iShlg@e&# z(0Pzt`e8&dZ3myoS|GeHpFw++fIoTVhhkq-cNyb1uAefm3%l)gG0VwO&vQ(2CCTY| z&Klr(lM@b{R-LpuMKVUE!BNGgzQ%uc;+%VL}^+Uw)Rv_5=NlvqUp>z+YH~!p3RP46^ zznwML&(!>=i1PXj08C}pyMjoXV8kGrF|?7 zKinCVr1%dUrlu?fcm5ir7!MYg=7dC$dEMA9o8}pM_LfaYK-cqo@c3AZvIq{j3v<0{ zxZ)1M>;^cEk@eF6&Ifwwv3wTEx0_6&KY1xwuj)H}d+Z-|BBDS< zQnYvwJWt49EUI%M{u5|D9!9B5jdGo*Gs=`_+2ZRVnklY)bL8{Td~v#K-~^M9*|($7 zi-h^e2<<+LT~5XiO9kfh-PdgGU_9{ zNu#8cK-f>gYwT-3ZG)_ii+Z(iBXJ?O8*TF4q@1EiuH{~;0C*|^0}#)h;h{fi_afys zC+NM{t4B8{?$salxCVGo0*Aphf{hM#1+n4>NDAGzdd0vTF@u^s`|&sr(=26H5~_Aw zC+cICdO~!YNY9?yCciG-x}ZJyiy0oM7K#7U80?QA8PzzpZb zaX0tNhN$hk2zwFDXf@XwO)!R?EspUfkYP}noz0_?;)LcRH3Cki8Z}&_~aPQy3f3uAw#y2MdX4quimkTSuU?odz4XQG0g7A`y z1`KY~$F#Et0e0V)-Hnr$+>=|#$Iwe8yqPdj&dsXJ1VjM350CoXSgMkN9-?QL5b(81p6^clpF69M$Aw~9-Egss zmp$mmkm3p$BFSC)wp%^X(OcR)e^MZN^*_FVes4c#I9Z53ZXroOmk<0K6Fxrc&5s~@ zVau(az|c>kgZaXsbQjuQVdI#7wT8_-&!D7it2j|?Tc zBU8DR>!t@th@L4N46sqg@)f@!@yaRKAzcTBkpw3kB}{ER9)LW|ZE^?!=%HCLb^`-` zlP8)SEX534yLOJ#I%QoKk=J4Z{rxJ6$W3%Vo%YfJ7zL7G%1C~d*rh+{M>@8MWEo-Y z)*1@#d?`$V7To+m8t}W*bj-W5xwK>u4rG-0ZHr<*B`Hgdmd1Efiyyn)tyS~omu8R| zvtuwI`1~rGC}eJWDia09eS}*SKfz}JUHh6}{4Ma%E@rE)OGLmHU-tk%nG08f3X$-W z04eeaIHFN2I)9D6E0E09`{S%8WrjS3PYPLS7gj!IJZ~NL!}f2)T@5B2x*h*WBvyWa z9+wUB<*5ONLD%#6iWM+aiWl!q5NtM)k!U@BLR`~#x37RVGJ*u;I9ru0bYA2d$Tl%4 z(ELme^2~F*GHhx+xw2Do?oQf9G?x0erXSQF9IFlqCtx6F>yNdVJPW}gOdN4OgKZG9^LkisZuh;5>^kP{muDR-_wMN zo3oLf_5|YzETiK;`2I6=+(FTzbtEy%j^RDt$S&Ei(MH~o1fv8pJp4O5W|OH*dU4?A ztDlZ*%wIdub@z>S#nFY}#DYx$EV%kRF!j0KC$*li5??gK9MLSGT;u^zg8+3ZEuuLS zTniM2BJMG)#>Jzg1Nc4y`}w&yUUk_8^*_P zTeywC9U8h;)eXJ^kPz{yt{X?%rAUTtx~yBjjm6Zw_CeMzZJh%8dS zO}w)~K7I2J*Fc8f{(uG5@4*(k>Ty$kG{o+Ob{tRFmieojAQq!Aa$Q!3zxKQWVby6Y z9t+2Yo0;nScA*$HQ)B;{9})`z;_X;;%q^Da$Qq-9W<=#HX*YCBUHCgLS!%k=YDo(58ZD7>Wpmb+p+j7o@cz)2#0Hn}C& zIGm<~07QWho?$^#TBSNPzvumI0F8v(SBByZNOMC8D)@i|PJD zvy-I|`v-omd3mqLFnWC-Af~%t&nWph`GUW% zQmpSl0qtKM#M^c3*{DDE^Uv0;u&)AcYfezyrxivbUgH!>peEW*c^Y=l#saGBn6z0~ z`-T-KB8>w_{1V4#YaAL*k(G7n{9gH3zh#IAo&=WrE!r85u1`%QIP7gD&@<>DF*6}Yd=caWnd%y9ak&mWS z=r)5O<9*7nlv^b|D=BQ9_T$F$3yHyKp+@@#gW*6E6TM+C^kN!t;Meo!?pjcUP> zE}IB~QqdBXbOeZermI)n^L;I|tpN0Sc|gz9u-(TXe=A&MXvL&%r3SdCDNDhow!Vr8 zr7(JWL459(J!L@|1Ge}`6*~^l$zD4$$Oyj z9|v%WGtOx=kJ}2ihNIjC7{RG{6}Z9p!UG?FThfU^ah2} zBQo$U6L6z1sCDl3t?~JvjW4`iE)L}p_7};D{g0vYrL&hAU}8G4P<13s!s>=j>&J1p zPp3{>qlC@!9P3UejC`&=Gn=uT(=5#wnrJNwTPX=;$L?$W^M<<()$qg<*Y{C{!8{YS ziztn<$kRz9yT!^Te4D?O&_E00&!o`0)++eX*r?(pvLn0D8&-{rm?E%6uQ00=LgK16 zoY0oQ;MhE#^#lO9e^N$^?*UTtO*OTD@^yjfW(;!2y?~TDlj;%53Lp)wOJ#&8k}Xj4 zgvJEa-*asE6F3>Q6MH6*zIhYg+f|6u8i_O;4-nkk%A9OFIg(an{(aqN>q*^vr9c0T zAvUw3(nitcG}Z(i;-LLtv`ZanEJXO&D{g0i8Svw#IyIW~z;gJmB+NDQ{|S|s@%@lU zdzT|W`o2w1Lbbz!fVBqa%DEy?-3^bCTcK?925~44z_hJ-UT^2r8B}OeIhB$HH78~` z6gTxA(firx6~K2nu_h5+zvyn4Oc{~abA$}zJhd*Ei6+5ear8pd{ z;?X@dQR*`*FTwu%%1^JGVsdE*(K?1PegI#xpQ4xK(sp1>a!*D^jvZSU3j`OHO9xr2 zH#dta5FuNKCAI3X$8I*>IRU|I`Y71wYcF|?Rs?Wx&L`)*$rgIp&xI)1J^HpzGUbnd zDXHc++R+(TfaGGI7W@Z2ny_Z%Eg#f9jTxL8cV%LP)Y5Z3U&BQy6W_*Ki409KZw6Dt zS7(#To1lKl&5E4$_KTTDO}k^KuC_V}-`B6Pwav2TukS``x zydtx%07}#Qk1g>YjT=l*SaaA$vF~{pHpf$C2%~x0{g}zM%apBiE5Y@o931@;A1GP( z@GKNdqqsOJcs<94LfTb(?|C~S(<7lQG1eSO`N}qj zdrd5mz&D#j3UcaOwqz((1yVftW^8|?AL8`^_QyXlDk!kKohrlr_Q~k23o-e@80OH}W@&}A5TH6D$`T=nl zwH~oSX-G7qlw)pE)|`?4&*rC6&Ogs3SWGOJoz8a2Ys(3rLfbN08|UojTa-x)v)(!C zSluARX;e90_x=(Yk8^mPR~&2Qn$7l`ChxM6TT+QI1?r^Z;stgDhXEsBE|)7bn(?11 zelt9P@`k#u)ORD8b?T+*;efZuk}zHq52R^_Pcor1qvTdQc6qsVDN}Rj9XtoVwC56V zoMDAgG^|P+f-n+rZHo7Re6nQbmYsG$R`~W%eLiM;)Em=C`6VEMrUW>7HHEKr;y$AQw@5G=*Cf9 z-QerKvtD^*w>4sN5V(ozzhK(cPZ*whVjjg3kBJ^i&yP1+GEwNOkelGV>o>Q51D(P8c zz4h(VnA{rylieOkAMTglQB}*c_sB*E$2hRcFAx)7gfy=!S<&qH@MMjks{pD4qiwXa zvh#~FKZ@O!#>!W0r(dD>86raXE)jg~q)0%Qa8AZiZu_UFC4p=e=PdulVlY#qB~PtP zcEftC-MpQ^>B^!rX)b2x%C7-5B>u__3M1!Fl1)$1%6;!H4iI`F;&Sz~4r^9-a*0P+{7A6bJ+&Bf_t1 zSA28O%e={Y2<3hCHI0Nepc=Qz?7FpuO2d!FP70<0tC&||f;!W!`FW(q*L-w@IMy}ECR{f97 z55W*F+)Jof8gQuIxCIAv!g*mZ14Z=fO6v_dz0vZWzt-E{LV_liR9+W#@a$6DBPa`{ zSY5EQKL=#gxFV;r8XsVuXPp=)Xx5L>@2`9;b=}nmd%B(&bn3o0E*N5Q-%ljERaVyR zuB|hk1M`&|ZMA7u7sw+aS=~&$#6Vv}qM)ml0yBC^0w2r2w=oB&=Ts zz3WTgA$#icjOigmZ0O-JCoL%OAAhaoBcZZ4?99{`Kn~kx8_ZYr?CDDRVzY=&3#xz@ znd)WKU6z!P91qV&cODv{F#H;$(t_HJ17^L(B7=5`0G7ONmWW8O?z{sh&Cu8oOHT*} z5}GGcb=v2=D%Y~8MB&Km;Huhz^~K>t9wH(*5fCJ{Gz083%ML=@42p?cz=EcWFx@fY z0`LRov4!qyn8)+hZYx(?9MRCt$5jmqp3|2Tze*{W!V@LlDR%07Kv`u{?RYQazz})A+spFdfwidB&L-AgQaYC+yHP~ZJNjX_%`9KQ!B$82#v*2o1x4x(w*BI;#G zCTrZeA_-EkRuT)(fY9TL5VPZ4$zf7R6397hlXk}71QMsBIF>&2zYEiFGbEtMNWv4X zF|~ffi3@|wRTr<~CzgS-6?o()0k}|DKFmpLC7_~HzmKi`Ae|G1R&2iZrA=|);v5c$ z$+ANK*>o*e@({gAZrS|T$)WX6m?;y8%9DYCjxi&+aKSGSroE?c6_=Mk!1Ac@W1}3 zLi~OrMHA*iN%fAV+Pm=uU`nCebyWISp!Qu)$XeGePP_w)F>YdKR&l5#CmGH)jVv{Q zlowhOyb?CR>$Vf)Mnl=FnXgoxka3EQEP6g*#=9aZ`fY+z^Ii>kU%{?W+t49VfjnL-hn*D=2$)rdI{^ouNu9681Lo_HfF>cP5$%_O|nXr0}$j*JF6~ z#RC%7i!6Jtc#I_{J&L#QJ21sz%~Z(SJ&8@Z^x|`rp2hH;b~t-DO>lLtp|GU;G<#8w z3FVtg6fgI6T`$g&h9zJlI5y)GJeHq`P5qWt7iwDRb-V-o^rWvS(tG*n$ta0XI;A!YL^LQJKYHcT! zINZyGFid7l|KOrI83CY=)%m$|vd>7&Xc%!lBucj@G@>_}zPi4o;G;}7PsIBL-U<3|%GDy(tp|G(;|NI!*Q zwJu^s%C(w+k`CrZ`y@qfh?vi7ico<%u$J7!uAUk6?n6m4tiN{1z>oL0GdF7^ zGI0Kt@El2)hT;3l>g)S^i;eoxRnJq|N-kmCQVu}%l{a?@VuOH4lh@}XiZ3y!oK=p| zBr1ABXvjaKRLjJ^p0i0xR~_G5p(8p`^HzB@#CBDBjd^WZxcPfMD6O| za&Xx7FLqxr_Rw;nyCmwo{>fb7GiuW~$~)8*2*nZh4BaNzL)Ms;HXRg@+2lDgQ+1;- z^0Bq_WqDV1Z1>>mF5w@WseBlAI}paJkD{QXW|#$3$BuYlek#cMC@9TFjW8vX(w+vw zs%pD+$*`0psp%zMHVnfb(AS|!kQY^d}^eLnx)jW*!<@04+Af6bsn3sqe-zw zmN<6ISqFt^9~V7)BV!t>bDE`PGaEMs!3zt67IS<_F`bcp%=}!uIz*;Z$HvyHAB-Ee zKvNXTLD+V%Hrc=HX?ZR0h9H)iHAZ*$;(K2BZ!Jz9y@(17Zhuyg8J>ttg(;cnW{n|C zZGM1YB{)DnrTK1DRR~!N%1ebu1S4Bq3us+s_Y(;(1^I@vdGbCEP=%mq%@p9(bXL3I zA&aqHZEN%X2$W1js0AloDL-h{a(EIg4sBnF;ZzEf%XBLuDY9Sle$JV1)<#KD|e3`l1WcQ*GrBE_V#TjDfcDyH5CiXXYZHYbtl@bW{y4xZxFIt zFGE9py3$zC_vkFA+gzNRX=u??>|9w4k3G~=_ zn^_qWfc!zOc~W1}3pAEVk~;*W$me^Z1R@uk$E3r8{H5@-3HtrwsIa+d(9ZS|8Dj!R zOaM$W{*$$Y38nw%u78s*1NZ+>ym>a~*g#>HUFJv2`ba8bQ67@_;GUo+x)j=OBzVaJ zX4S~j9Qg-Z^lzbe*w~2MA5jL#em}2FSQnM-VFWiaJ*rO!!*xw2TgHD0M1~D0bnm4l z42bfqW&0_Zf-)gBSi*x4s%+7pi648UuYt3;-w;@Xm}WjR#TTerw-^plSOq|$MH?jt z46!frjby8{ka!e?Ogwq%`F*xayd-m+W2w&EwG(^Z*cA_2;E{);Nnx^%n78PHKGgUv z>0Bn?e4BPmt_t`l$smwiHRQHqovB5Dl){2(>`3&H+l-1F55$#UJV*Y^RnA}uQRdNc zm}Gv&UZnJ6|N0ord2S``d}cR5EVX`~+;q^c#>+K**+2|9`Ev?}gl%SqAt4}=8uiV_ zWeoc(5JX%;whT9L+I2mrbHt7B>fDFS|z0>U*Z+io~tdxv`Qi{|-Da zqm~dFx?67mU*zGsQ}SZGFkLDuLoJge5a``x2!g^;xVu-In-T|xU)3b&!-m3bm)vlL zuz00(eMESfl@fsd0a1xNa&8pCcdF+T{{hV0pXQ0R5f%VyDTn~)DC3ky3|XPBn5>S9 zs&>xczv(436800Hf@4$`CyHqA1xMIU$p1Hz7KKs>dA(`p2T%&N}{7)TNxA|kw9CpwiaYvM-oj(<5^E{hWkK(5ERG_Rl zzZEVNJitb)HRP|ZjnFc_Uk~W!yA8iy;=7aFF^qW11Pe8!AqjTA0nRYwQUp!CwUs!` zx0pl6PDreLpn&Wlzjy^xj!3iy4l4R^5TW7iuSqz`FK$S4^ejDjzet@lg2}rY&H@#E z;+x#Z#Qb>9(W4pj#DGY0i}S%pj0#^?to3jJ+h=PO2d))G3J|(C z=%2*z*F}kwJV!|LKH9Bb_ah*;-K}`Tdz94DbWKz)t7P<2tm;90kR#=?d4U)iig5Qr z>};}0)?^;&A!AtXh20Y3W(X;8)CE5rq^$l19>ML~LN{bQFD^N^e4`}WmAEX3xt5^w<`pyUK3-HMV%7ov zhA@zq4(MqS%;*Q>W(R$e)oN8;ru*{ z+oDkzSXJ939j$ulp2S~l(3>RDCR~p5MTA0~BJz{*dCyh|k|^0o=G!^?1q}4|R8_!r z;EVt1==~WJ<2&@^WCiLAqnSOs7`)`gf$v$Z#kG@M0gBzO!#AVz<_?k=87Mppt~=;s zylx!mc&!!RR3y;4qar*GS_fK{g#4TWuJ+@=Z=VpAb{j+QwRhl3FeX^ zCEgy(37l1{>|UnXB_ zN`>o%n1}on>Q){gUs-%rL2;%`mn}HG;{z)>w{!OzOxAN&`Ng*Ofl)|EygKG2&`=l0 zZN3EXVGH+O!~{R%IY`7>%dBl|OOpv;bjM=zkO~8rpH~-A`N05w;Jffa~$XJ-Cc)lPq<`7L;jcLNJJW4d8nNselp3^SxBSux%3#M#HCR1*RBn9 zemP8WDUDy}$^*{G7Vf)W`W{p*o=2U;oVThHhDTY5rZQve-x?n5UV(xWBH(kENk8Le z%}d!9o8I08YszYfl&pzf`iR#Fmk%?B8_Ef+snnP;u?ZU!7eU$huR)M1G(h_x$bGc; zzz;%7EN|D^vKHx5hvD6TQu5%$cmEzYkg2$ezW-nwu-FNZP!Y1eVGJBL4t$WHE!DDF znu7l&K@qcK9m=1U(WpOqf?b^Bd;`EKaj>9n(#_;)x6Zx2CQ@E({+UU1{R=0W`j)2g zc5uaCtxTWZvJK%u;&>CM9BOZRCrJ`eUvkQzPnLJd%Vbk zU(qQ`CUbwv>r7CFi^*$l3c7ivSXLdag{(FQoPt+2z>wePFVa-Yn&ZTXfg_C$J)o=I z`Wg2^@ahFAmq5uV?k#G}M7L}q0vsCiH-<3pLmP^EPBTs#8R~}2zX)R%;jz17H%+W_ z2dfZ5F3Tsxj02Px!8K3S<}X>H5mhM|xAu7~eTRvlHs*D!hG|*ky2U%gN`F&h)*Jgw z`jE2^#1ZT(49#5=j#n;iRPpOJkUYQyU_V< z{1kdopvS0!_TFBL0G5J@o*-Me>>f@&rjzI84y!@{c-KNtp`0)@rL3Oq6-)f?&2w* z=5?`jZI3j=i3efH{3X^R0c)&v@f5^VtNnanM9?z8G+@U)f*Z&`vmS)=vuWrw+sqFa zm23q`62zmb6)%q)`E}(G7>5sy-Yu6J!2d|j6Hf<=Loh1(m}ou!EZS-4K7okGddJi{ z-S)dTMt}BWkf2OMEaUtL8Qeha9;<}9SMl1s(H55!*acG0T+v8ua+L+A&(y$hH?m^I z>PB4Ux?T;NAx$C=KGdbvvvdCx)C@N8(ZsqTln5xQtlEv}%4a-)mSYeF5JJV^J5AOh zgexlP<=PC^Qy9;?ncqo^@Md@W8G@e$0m5-Vs)wRYmI<)=1#KZtZb6e=YfZj}!;kle z861f?L>FWV>3r;}q+?OIuEzL-pODUJW`lX>=SS>%gG~$4MiJC5%72%WjV;{O72tIN z{|F9+Iv`z61>7WaWo=hl&(xPyJ#l4&b6agp+&*N~%8{C{DqYrGggp9a@r&Wz;?vd* zKE@v5^m1Mm^Hp$UVQ9f?-8c$8MKO{{bk53z!Em!xqUh@C|K{t~j`V8(u<({(!&C3k z#{3WYZw_6$3y*XRsK9YLpQ-{zJ9|!a5TQo=+T!(Ad}XN_*Id;JLhm5TPbPTQtT|#? z6tJ-RzyMp|kHc%b8vn{rZr!jyOXv#=h1El4eC)}-t)dtILEiWk2 zPth&lHXXxFd-jspv~2*(L(|>IEg_9|%Bc?XNuAhg;oKv??eOAzCxFGEbF_ma<~w@` z=8ECm69a*sXA<{}S`WDjw{GANH9tXxlez!SD~Sd8hjubNy-a<=hPb*xdauwKdkoFV z3bsnstxjfFeVNn1V_dGaLlTOET$XQTbzhR0 zR4yRs^lSLNqd}l_*Sa2QInd|^2eop%c8~VkO7JR4QXmCfh!0Y}9dV2br$=C|ioqkt z4esI#1BEWUHcCCdiDs9s4ozjAwsBFclO{73_Dd@DiKRt$MROMxI-p`V)ke8wl6H8%>h4&?y}^mw zitx+G@EG0CxVffE246$!+Jjw#?{|Skx)wZ|GhvMw2_|!2ak&T7tl*v)F{u_ZsH6`H zcf~WBcsH04TLvVT`DjnoO|w>q0~8rX?Wf6Rz%$pT(bb&7peXAW{tk)7VJ&h=e@;Y8 zPDg$}3i!;1J$3Oknbj6&5%r4!v}a;O(;rowI5(*2F`AT!reiOzeAFKn(gmsTHewo6 z-#x`rA8S)pkmOzeX%G8j{+ImRYokhbAM^7R->2Mu>xlrH9FC?7=rfH8etwe0wr#+M zK9{`6f5RZne2OpoNMkjm%y>T}8(=ZlbM_f{o@0g1gA`ofxppu>X(hh)3YJ zT?n6^%|VbX#Gq1b*vw=?Cje_}!PB9isKI#EbvEa0II2#fv^n?xU5w3?DyPwS8*P9y znlOsVC7a_O8hz4-r;oiyo5!R>l-FzccgB0=;65?zSQgm4k1`I{KNlAZNPkPYZyo6D z%_fu)A61wM3Is~Sd}j0?YD$aQ%H0zEb6{NKX!#j}+uX<`MQx4P)cQ}#PPRvQ=}JA1 zGF5g%R8cedz*I&E?5`>?LrN_pt|eLLJ=c7orH+mB3>@V>t?^Lc+pK>L&472so6W^> zB)M}0zzQN<3|+#q{T~2^C$-3%IGcK;ND+1*=j-`NdXcs?hW=m8B&Iu+VMowhKQ-@wCvP~#!pVf@4VzH=|ERb^5i5kPP&yE3wum_oa+$^g`fWt zX-U^qnF?o&_@VvJ!pe)TKzaRxSrd^4W7nGbW+^<=HqD(S!kmkYOiKrgg*S};YSR-p zc0eAlDosNAz2v+z6HZC9ikboHC=Tvs>?rO|5<^QltL%|V>R&iXKGZ`}qQl{#>CPr! z**B158t(#+Jp;C?{rknl!g)XzO;CN7f&5sPS?;GIXt6Y^Tk78dU$ZaNx-=Qz+=O*q z8_oeXhEPW&G9ltLLSNfF*~D5~U`?k;>V%4vN^dkQ#!ybS=p{pVAxC(ZL1Sz#aPX9f zF)@^*iG_vYo2OByBbp8Xnzcm6fFNrI?g0YBROgJIO5GZM^a197%NY@F7L~L_n+|`3 z(1ubeZ^fGWw}eXnnMuPNzq4Vxqt*G?lXjkRZkjx6EhZjje3f;R|&RogP!?=Ld@;VvEpJz$XL0y(+Sn)P(&i*o6INRy7gG9qI8@A!X4VFfl5=&H@m{C`m zTtRM^DUm!WNTUS~=Rj}9y)ABPQZ1yV!vcBhNEI-Sn^E2Z*p4yY2Ex36zMUGa(_3mP z@dI#w)fkE0PVux3nztuKS%z_tx zq^0mlLQ+D|A^=~jik(gA*Rl};;_R(uER^z297v6#7*18UlN9~|}G7`Yi%aboVbx%m?+$7`#9(iql)kymot^q;%j&9dr z4A4&>7>S!Puu`E{y8&rLsj-QTy*#Q7Sxno}up|}K7eAp${`{@TpXMlIm26yQy0BMi zJ@vtgmT6W*e~8394EN+gykq{?iN1vyNHKy_SAZmrg?66iy2=#b=XX4X%-2HmHv^r3 zTVpP`p~2q?@y~YZ;r;u4supZJ+y{iJ&Za^`IA{f4;`5y_Gs|Qsyi!2yv?FuyXZTA^ zs)&wy`qJ7Fz|KiYCy|!sUp|;6g9u7pwNgG;5cycT_7C#wj1MOwDWyI4_s~BQf>>nSUW|SL@KNe2)g)=eRP}3c5B<>CZWjDyR1XNqv7Z#JC zS1U7BZqW85-hi9QxOk*+4(gE^X@TK%~wyk_RG3c`B9o&DZfxnZ+9 zG33Z}Zz9IVk{;&Oh!Da$i>1nJFfiBItYVRi5`o-&E?qbqxr2z;h7rj8^|3SZEu%{;rv zJ)u{*&n|J;hI9br+#agPNmpIb`cdtq(U-S{UDZ;_;!EE4EPF*9PA9yi5#8HvLuLqh z@B^l0+@sBPYpBhFVuw3l1g}guj`n=uqv$q(Y#ft#*o_kDaZoUrba{ZE0qyhqde<^Z zv7}5JO%Fl3SOni~vnN9#PB5zo;F*|;&=B%LiLZ?#{iX&V4MPb zgza(SrpZknz-k1%*dKuI>za{9F(%zqIi7YC$3KKswNqp#>T(5pn6j4Wof?DI?$_}F zjK8f*qUG6IN1@5Li%UahUHvmAp4mNd9$#W z=a#dQ3k}uaW)K4qwk5b49@_SCF~FZr}v z1s8gDGFjX->Vegcb~piNV{9cZ$HbI${mWDUw!pr@Olkhe?)?{zD0&kaySTz17FDOg z!C)!5Tr!&nY!wg^YI&J=rAL0OFV*S}QgL#Q8?OvE=#3L$)(}j46k|z{;uhX8(wBXL z$c2YfV-e-|em>Gma#1l5MV47=OBds}45S4I)@EMkXs+l|<^jVY06^3^Sk+yaR5~Z$ zy8Hlq9~tlMfg@TGR(#t5CWJ8$-Jao!R7S;j@+&}MJ2OB7KS4PlU6px$8KPjx_OFM8 zeTE&q?GJ+_LAr@Z#MuZ}{gYl2T~i()!w%@tU9b@6MD?I6gw~h8Ng=d<0`f_1E#&8P zdC0Eim(h8UssGwJD8;(T9X8faLC)I7#&;ozdu2k$E4vr~H#9lm(%G@Cw`E^t`nHL6 z{_G%!0ASz)0RP#1ooM}I_}wb&%pT||m&=i)+nWCOzd8TVm)EWR&@2P6dMVjlva5#h zVh8%DxFh<K1fa)Pc*SDJ3|4aL-&X+0!fFi*Adt>;f-ol121aGBA8Vy$~`|=x5b$g@h0F@IyKI z*lvoUL_x?(z8*76sHZc#e9f!x0GvFK=lUyIwo58+TJWju0|P^@f$)hkhxzAx@k&6C zKU0&*be*=)S0_KTD*ciQbVi-_W^6ZtY7HwV>%3Qgdd+Lbu|h_gk2n4kqH6 z)Xx#AB&_}KmH@WkS-_%_lRmx}IKL2rIFDg`Wq^QS+)38xkE z5OeVpZA}l7j%42lVy=E>6s$#6ZiV4XUXx74lmh|MuplUL5tCwy3Vda`ycaj!NrX~o zH*?c~%SK6E)_*4MfhB(p;4)qU0-)*EQt}rWvFjiM=ht9PXU=Hpf{6Ge9)&nKPY|ID zn(u%&l*j8?>mUE-$RcDr(WI1}2K^ny&1H=W;VL-Cv9ie$D`UbaW^W;3p2^>jJ0T75 zu)>^hGrbWz+-FG4xG^@>uJPKVc94$~rm$$Dw>++O`V0uc?yy ziUA#1j3;)twWQXpH#Uh|t&rk#>IqGR-%zNpZ z0(;e}Fu^`~JnHyC%PJ0nX~?SuH#e|7q^x^P1ahNpIFGijEhtzQ;w<@-!d?7qmfr=K zVuD+GKg>|hO>IQz1+KQ+xWDpu#fL##hd~JI&BjWdaIF0LC3};Sf>L&#!iYDGv<|T8(WXw#M$~A9L2N<8)u2s- z<*q_%iG30IUl&FbW436;UlG z;rI*8iH2EZ)7KXzQ~Z+^TlkAWx-h>t95YyIW2Co>ARQY@;9YHD&&b(l$2biS6kKX$ z)d(|^&eTr-D-QTUdqN2D+XQd)rGak{K4{u0lEp)xRi4cBd zDmZSiKl1h-2a-$t^35Sa`bHo3$IP#;j&b!)Ch|r}WZdYEuVYa=cqMQ75~|M;`k*$H zr~)G~QLHIYH(9~#WXykGzy0FMl#=P@G_wM)SkuO1Th!E|+>-Cqqc(fo+GbtRzAgL( znq)+uxgw(1JWP(*aKygWhI_T8=djHV-h9FF5j0bb@OG!Si#mFrANe^J=~BC~9Oh09 zZtg3}=YSB=m;qNF1({{pfhQ|hW(vyf&q~HnQ;`)X2-R1c5N6t>yAS8nL!<`+G%Lxw z(2=}I5#4b|af7YI&9%4Ljxt41sVp;er1hbX^C6A#2EZJz8^-H6?BO1VpbIow*J=D9 zZ#CCJD}F?phz=8FY9jx2mXtzm%y^dRgO9#sZ z#5egzLX5Muz~BrPdYO#XO{&fkcOZ#k<@ZuiQ%aihg{Ix2U_;y4kS!|F#HmTLg~HfV zP?=V+#Rc~%$RwUbFdl*}0TV6B2NRtJA{cDHhn72r)`WJJX3>G`5C2`zs|8=Ld8wH z^|Tr|o2Tx|ZQN_c!5gpEc~h*qHG{dO7UQ_D?}%aJuKopRHgv4mGU@zg95JMmwi`oP z%|JJo;tsA|S8h}#TH;&fRVRo&fqocNZ2WRp4~csL^z6+Y=Z6dtw?oi)Kj4LSqTv0n z$tg3o)`-8K-np4aZ(CspQ#H%cAbRuewq`Zyl$8Mv=m&%?a#6qYlo?sdB~sy8hhw$JGM^^;d}&I&2g< zC$%cHQ82R!gE#ux0%ABl0y`#W-71VR%ozs;bNM#S2Uxgjh(=!0Em)->!jl@yP5Ntl zHfUgv_qxY!Fqglb!<;DhHI|l^l6}GN+nDbgI%zn{Cvv_*T*^1hbcS*d= z9s%Jmnk2^+Jq5CqCQ>R=Gk&T`p-q)V_^C|`2h#EEA-B95V0(Ck4s;cTE|;nq{yP~+ z*Fr5et0_BhdGVW5W?f_v)S%+kVxjn|#!bq!87ryAI4{9RNup8Y z?9)nGug&ovhr5UE?e^txqMV6=yN$|{H3q_bkeuSv0MJP_>-Rn%RP%u{W@%J`=frqC z53|C~Of5syX7AQc&l>>|5y#V|v~26s^+3z7Ama>7@zfpU2Em1Cu*=TTE15>o^~o%A z$z8|uD^`oRe-z6&zPf>x-x9jXY zwu@<7@jnI%W{1hbwqU`y-;ta}KWZS4t|3sIi(Zv0h)WFMq^i|Ke}7AfmN`4Q295l0 z$wVIcBxKv_!@ZU4H_Z@=vZL&48t#w6^V?kOzZ;jg%^*VI0%jsqs&~=Gf-Ey|x(L%3 zN0EQnqMmoAc93bdqvr)1>`hJc2uqrfuJZAgMj{It#~2oLvB9heYpn!6 zZBE8O@6RY#)i!9Q6nP9P;1M4>id?Cg{vU(awuh=!cFg%IuqR&TP7_z`2RDHONW-wF zF6LpV+86-iSlz_qn!4bk>i7P)v2tB?nD!In!X}vys@|KpF?6xZSAA2hMuo%cl5f~` z$m;Q}lEgnkL#FV8hG%=Yf^F6UQd@IaAn73cZ++1)KOF?Aujw8XU8rC*bh_led>-h5LtX| z$`Xq}v0@+*=~X#%eVsA263+!kFjV*iw+M-UbL|uuFk@u?#PaNbn~hxf;V_Wr&4jwF z$+tgR-Asa19?w>j<|(IwTN8kZR{}bZzfit z3ISu2WqM2K9K#is#j`-16~U1=z297N03bkK`;#o zBEitC&?5!t+mp1><(#?cJ&&j{2{2t-wb+5UTB3CJDO4x^5QbH`c4MeR-PnAYuR_t> ziF6{@BSx6xKXPEAlv8%GMvfjb?yb6Yu~B1#9rR9xT3|MCh+ zk6}|!&W2)4PHs!_xhyWB_Hf&DghM1^r`z_qIjSTu*AraX#UU){A{b~5d?u+))N+$ z_8CgeK}BdBZGjYHg5@V7*{X>H$@B#>jqFMvZ<9uG#0$mm%#add5QD(|1=*QE7)4Ja zW<^V(EPvfW3!dpsq@-PU_K6Muj}4#dFa%K$n!-=&o?YYhJXt$uMz2q+|5x`mH<*N9 z#xz{Qm0tKkzqEX%K6)F-e)96Fu3meRn#zn~56`5VXYC&QvQ+Jhossk{$GFkEELUb_W9iueSUp+Y7(jZ!YxC=VV?jW855@^+%!?5n<8zn=JIve4s{V92@HvcFHN{ znXq&hb3gCkSf-9%f0ON~<6fCqgWIwW@NV-S_3!~3Z^ElfKca%GI5t1R_WvXIKjAQ< zQU$6rRXBi7layp?nI}XEhL}2Yh#z-B87_T?7*FV+E(nGjVoun}fg}aWq(ytB{N7f> zDw@GcC+bV5$YGnIsp4Zxuv z@vSx1_$IWKpFhwFi3u~Zr-}Qs>}cu}C}>$Dg@!p$KkHXaE)fMkK8oTJUF8uiELX@qO?Uz4G+ zA(>vt{A9V@ujRje9;K|sGQS>V)w`E&o076GK@QFK+n|0-gcu z$Y?FwIm!rWUw}lWmA+HO!*(|*b8Ml27evj20-}4|X~3kf{>c4lCCx}iV!$Ah8*@)v zhjqM)<&t_ci$9ybfHPC;6_8=!!_yVj9>IX1=1m4xV9b!U0!(kNn-UOH04hQ0(a`TQ zbZ13(6|!Z%8wAHQQo?32j3%6mtL5s(*FNK~vcCcU)>v@q3KE+cvyDRg+MhP97i4<8 zLMIWpz&eGQvo<2d^}D!b(dzCHED-cwncv{)@w9|i!n&s!27SAsoXD|ts%etu4+tg3 z$#C--elFIVxiEphfWApJd)NA>{=N$*iHh`SXiIsh9C6EWl{>m?-o$7)n_Gt&v?+ zWiTf5h{XWEtS>eV{y*C6oc*>gFVQBosGT25@*Y7j(Sbu#!m-89&7B`vuA~)(P7~Dz zkMn}cH(-`@!;1)1N!RjS70xE2Yr|#0Vj#@VP^-!_h06dS)%_GSCq5SOi(u+)+a5W} zm+Pu;QZVN`OMMm#rxB!G3?C7k)X(RPJ(md>L5_X2;RyJ?48641T|6!cgyOmZxi!W( zT$KW+CFnC{1QEa)%-jypx_koZm`l(KA@&iQ6&^MlZ4gACTasffB6?VXYodz>jXj(~ zZ3lsU04Fd*pSY`E7`DwN0I9*90jO)dV!u<8-mfZu-OCo}cs}+v zyIF7^xQ%`$jWbttmB`0@B9e%HfLt^rr(kFuLUzkJnuHKoa!Rcv|BuzKOfbI@B@;kn zg8cwdz|majE|{#lvsC%>&CXf~Y-OWvL>Bse0O%?7NA_&fQc6WAej<+oIhN2PT|sMCeo(V?MX}(3<<$=(K0Wg#VF_ze zQF0KG_x7_6?DQ@;TvKlG884p$>%+a1vGSBE5zayi{hln(lWr{9P4ckl3s?Mv4RRTa ze*To2iw)o%;Y0%)F^>EP7e}vWatVov8F6jHq?p!D=ME+G0gVh43P?H`dESQ%6`uPz z<)UGRBr8Cbx}euLE4o#Q(Rs)X!?s?M%WT=Fj4KBFrG4keGUEP?V57A6LlYFj=bSc0 z_PQ;`f!RcV%VpvqrA9cb4sBtG#S#PJQ8R@H^Ltq2d%Vfxfl#xQ-p-?T(I$D(&AuzWsOU1ZYD9w1yvHKAdHnfO1s696c55|R<@amvoP%=#wEv? z*PKpa?kka*z6%hoA!Y4c^`$xumxHtq0A1@NR4do;O5>7(m;#|Yc462ph)};22!@co z&2sH9uy}TzupYBB;`!R365Y9s8$dYmtuOs{?s2=I=^oNE07`1cYB2?WFxXQ(|4wFy zEeMJr=sc=>Li}5Zciv{c{Rf8HRjYIxuiK}St$5mw26*|!bY z6)z#HN-vTq>qw8ZcQuHrc}IP6B0B>x`za~c2M(EmFX<$#h#?h>W`2SE%WCVQ%Yco45ah0S6YmW#51yx9iLiW*JN0+ z1kxH~H=CX@*jVF|aoOHVB*eZuHcEr6>c=8bw_$j8myiLW z+QRCethi`AXDL9JthNf!Huaf8ujVsYLlq0dbFDmdtjfgDnVF5gT&#RA;3{gSd?JVi z`2_Nr&DlJg_;$FZsXfe7>#p_lx#jT#rhcJo8ql;cTP zVrj3Wws2YY5-+id4n^`ym8B~D%P{&mNexgbceswL?v-|$^oq|e!6)q1c$iPR@7UobMBnhkXSSLZlxN;@{Dm!r|dd`x6%E_m3)>*+EqNkeJ7+fLSXoeH6ZQ=YlUuH<; zeO7w=kVtomvxyWikC73Y<6{Lp2>I_acNc*4TxvB?z$yUu7=-f8K_~hPNX|e|PGtPT z76PehP4yy(&80Vho}9y2*UO%o*56JAg#OLoJxF7EvdFX*Ctr?jdTNJYNHr@_J`1tQ zH>n|QBWRh?5lEtR`}#1l{F~%PEw+zCP7mPeG~I)E?MqZ7GslSa+L}&NvtfSS0`uXN zOCM}X@Q@!R15r;N5TayB@#@O65p2N45)vjg?I|ge;Q?pTNLM`k_XqYG#kCsVo#TI>w-E_mxBgdc6uZ?Eh%qcEz4AIB>YpiL^ zECkXF-^+PIrd}#LMq1z$iS1AJuB644*pzQS38;#^KZobQZ&-t{4o0^mDr8zH3L^y|%4!_15!VvWR}soSfI%6-9@J4z-Kie;ZnnJ2i`^QB1rGrd zXMp8~l=oMEPq*r5DBk826NEE%gCecVt+^;w#j`)2eqz#4>#Wnx^*UEvN8@ zs4;_(p8xWnb6$7hY{53V)~&EQNschbYa$wj94D&8SonB@Xg{izSQ3QMomO!vqy!5# z;9@jc$^m6DeI)yd5z4nN8H4U$T3bBnh3S63kFT7tFbw4(xw+E~YJ`D+VQ})2!cLwm z>sjQN!#iK2?zbG+!cY zWo-(HSK2G(%%ofyXZbv(`gJ2e8v8C@WrpKP5S~cn=pSN64;5nLN0x)trpq55$e_v* zPfQ;bXFtE8^9Ssk>Bt8}fQzIM3p)HtF2HAyA$Ef+P_dojV&03d>S`5VOR}JOGx7&D zTi6+|a%7ccA?vs=_#Z-KdF>2}OnnUodQw)D)=k_HA@$YQe`DeVp%0Q{S37r*2L(V~ z>l(80o~$JcmE_;oJ&~5l7bmpL*DXjwSiY)jI;C7@Vceu>_>iqa}%K$hun<} z+JHE`aM0tn$FUEjYxnmDXj`tDQl&CtJSP3QR)0sEtuZr9Cn$S_^3PNf0LyLS0J9aV zJ9>?`c4`D9?~UUH+&U@shOzR2WY4Hv?5LY$JMnp5bu(JW6^lc{NZg+x2e4Pqh!Q#p zx4rkGnxxU+?pYEo;O9_Y_2`ukh5ANM2RQiL1}#^H=kX9Ih~sca@IfX;d7LT6(X;I_Rz; zS*?JHLNN~aWNwob&`)%$GT(Hl(0jQ0%X2!4pT!-CnDnUYsTdA}Xyi<+1p>5WYW+9^0)f(Yf) z3#v$`@@8%m4=*KRH$~ADU`$fK{r;6H^3W3Qbj?X(w#(lJ(_B@8la~cnSS>TC+wEj& z_El&)9yFly09Bkh_tx*VsgX=~-p=EC)zH;Hvf+Ojj8%O!&WD#{R=N5miY;G|lZc#9 zVTxcW2i|4U&g5ptfi8*d?)~@F```!v5J`+G5}l{#&^SWV6+3J1+P)v&4=j8P!87pD zFT>Kf;7M-}E&%a3-%i@vy&hI*FZT%swBVLHR3cvIe~rbp95FcURQ40#ATSV3ztbBT zBkAUs=8iHtFzZ`%FPrj)*J%O1iK2@Z>4CxOw&kTPU#YqdAdeI*ic^L$saKRiflx9X znUD#;zG0a8N!ri~hbp518%HfWJh?DFJkT0(4=^-4Yvz8y-7f%KYzejeNg4$=uBz1j zL0jn=eZG|$f#)t-Z0>BG*9ru;=GJA^2Oxyj*6*4-BXg4!kDj@)~oE)3BJ`Hi3?_tg~5a`FH18$Zr{ z#?kG-kGctDDS2r8a#xs@vY_%fg_vGMDf)q3Dn8}1Q?!LbPmTXX*hzl4ECb3;ZoY#c z{nu>07QT0W)E2$|pE!h?Fs}9Fe$y5tLl+t@P1^_v@d%I)SotC*lm)U&IDACmVC)ho z`J^t%!12zE$;fMTH zKW#WKrN?hs6F>Kcp4)RrbT*f>W&#RLMXU{dPi4`7(3T+U@2F0GyN^<;z6iIC@Qj!s zEjoa6tSH2x9KQvIsP`~ia;NHM^jP!%QH#Yi?-a5$h0O1feh!iiYnUsU$*qCWNUJ0N zy?I`+wU8nU@FNO7bkDPuUBgvf%ir5=kijiyriI{m1hyHweTW%MXWXj$>6w73<#G#` zm%`DZf*^lviK)R!>6_RI;NEl99Hw;@|C{Z8Kn*bGlyvtgrXP}qq3lJqn$fCj6M?c+(IuRZI?)IIRh#J5>gFTv~iVtdQNz|1A08KQ}GmG+_X|h zV*(nmvSFhyqhbGJX6(2a{DVQdUu z$$1_--jdJxk0w~o3D1-VS*GUV$$OcJ9_o7K0qTPydSZy*^GPQv{XNfJ|3T=P5SGYD z-<5hFGO>NYTGqc>i6rxx(VJyPMM)jIz<>@UMe>)FG39gU*;3lRpq=nHMX{bpNT}i1U+To3Zn?{uX*X{f?&YeMYj1;clG)e!f!G+Z*Ph1tvLt4;h z)JPnEg9g5OEAd#F?7p2sFQsq%3Ex0H9r9bXOAqcG?NnxkJdGzCI+k~DbaZUGTzjIH!>*b z(IiR~gB4O93BgR*^Q(=`-PgRsYuKd0t&E~K;9nGc0kb6WzYm%^D*87f0l-!Ooa*#%>*14+ev|>h?FZzO4dlWu_FG-{x{7^m^K$89Yxb+*TkmS6mK2 z6W4DolgU6e$J0U9q*_P!i&t>^Rj-eLXaG=In`rtJ_~rNJsoohy5id<4!_&4^ZC1+- z8I6TBRkyg)P+EBBf_1b&(L|(GzKqH9zWSz~&WB^QH4oIr)pMuh)v-ogIE}K!EPdg> z4cgqRnR<|z+`lQr8x{{&M&C#2l>r@31e$e#RcjPc3%Kr&HSJB zj!IoTkG1gQXB#(uiRCV0z}HtuM=Vo4blRL;=I1V9Jo+gWrrh-iyuFu_!x{9n15EyU zzUL;DAKcS#mu>D9?#jQre1`uGShQ*N7}?!&5yTpITFUfAD(notQt7=3wtYqPAvRfO zVw(6~qepR7gcqdq_fu|Kb)i%2qp1x5F!kusAs6R+?I4hW;Z;Q0dF9dI}Pe z_3@5aQL-9%G59+|ikzGHDJ;G9`Ro36z~ zV=a4Zpi{ACl;T+dLy?GvhP02A`>(B&&4Y_F*D{3q{b=wbiJSxiV@Hgx`bfPM+ajMF z=|?}O*A8}0zM1#7s|+EQqpU2ZYY*(K6K&^%Sg9iAh+Wu#ZdL}kq%lszMvW{jgY`Wn z3?^uR*zayFgsHxCt>u;*bx48i7@&97EFokS$;%PlMu7`(RJwwkRc=wbxTK$pV9r>> zby=4F6r_cf-U_mp`u@R$N#^qmKaC$&m0#lV|AHUNu{6VWD#T!*~9ye{h9XnNWhPV_$dIw z2j>ud8_RAq4Lz|~TXynOJFE)(R^*@dG5+U(F^&B}gw225}C0e9hzxC|7nakm9%+7*3XK z+WXp5?n6hrZRkH%SXhK-*M~@A{mW!7qN6d5iOw;{Xz7XRqlN};N2-sQV8{(i5a9{{+Ugkr(6Ke}m8<__%())VU8qTsC<*m3 zlK03ew(=x#_PSnhC+CGAm0uyXB(5O~h!)voGbUGTkW6}|{-&Akgw5jY!nP!}^_Wkl zU)4R*?N66tYt?qmL|vt&sr(T1rSBU3<^QOw`nu%#I_XOADObhuXj;ew?x?p__?`f$ z8~1x*8Q50A%6qG(?;LlhnPI?d9!{8+7?;1aXHg>%^$nqeiIg0f{F zf4_rhJ+#-r6Fk4oLQt<6O?f!V5erUMQ~jtl@!&rnd}+!QAn|WDcx!U#wnis>U3z-+ z7F}_e?^J=;-A6Pv(qni*sW01rQN{egJRymH4zS5qUg7uLqY4ld{y(1S{@wlXL+VNP z>F0XKVxQWP4TIDPTFL$b4_Ycb%6aW{eL}=e*}fJb10*C_Qc0UBBnx^lb9bS66NJJl zZ%uRZ`RSP^;6mS7m)(wnL|h^WmQ9Xiv-Ze4B|cCxquSAR!sN_|{K&Ax+@3nSz8}TL zR8b{K{`mc^&K798HHzF{Y9z>5PGqyofZ9t&lg}C*a^zb@@@j(4YDuw`piSWi;_9rO z^G_bKT*BvjLeiGc%Le4WR7;|Q%RciJ{dIdAIqD>3;iejv9RzDGrn>8`TC_IXz$1wy z9&9FtGpQ$dF}Gox|8E-FtC9&Ui@gaAo(dG-s9UJ@t?9x9lCf1M!YsAR-Y$Gk_K5{PC%PW9t{SQkd(oXk))?{7+U;`uP{ zZa)34TT|-jeVIntxRV9-@#H4yK(BmhZLd)(+o-5M&EbMv@M#k^0HfXhWaH_denB!vO64uz=qCAT_!?M~ zOB}D3tVfE^vc22|ZH(_D7xxnWe!~^_Q0twD#bzK1YB$w0zHp9+=I8hC3~_49C6Dq$ zl-zd}<`e=HljJsc4a#ONt8Qg0Kls1gP!Yb32WJiIFxf3$Whq=`klQNkSO~X0ZRb46 zfWEZt?LylS6wm2e$!H}PcG)8@Nqp=L(T}7DGS)!~5`feN-2tSJ_3>iqEMR!yG31oR z4(|asdhvl8&cW%&uw6fxNi_U^331o9>{hHUM8Nf}A6YvC|2RQ|+&67P`eM}79W;)i zJHbae75qPKEhBSRMxbh1Ry~al#*0Cm|Dn81>p%|Q@X?186Mx zD);WJWo{2|{SPe309ZTy&}p|4JI@5J4WZ3{TE)C7TJpxJz`v2x78Zp3xYP*uQO|F; zDYdx2wL`$E{y;NC2qV2{jfrU&g{BGc`5yQJ(Yxa12lx_X_0s)ONme%y zTo&G(sU=2hyG~etZ|!4G;C>|xu+qke&o75mx^2j0gNsL#L5cCEprBL*_jG>lQJu&B zRGcO9_HaXq@7&|lnOdn6&ei+=t8UNb+0)ZsEh_huc>!w{duuX)%=J+1KwJFV`Rk*E zzGTKovQ)ys@d#pi1f8AualqD!*Go#;G`Lz1KN-0pLy%Mx2cpj*8P-0mf+uofuJVS{ zDVh!La~j%xs7XMF23jG2_ZBxuLM+c|?JZuRq=zKX*CK`o#%ZJ=e0++qonB;&_@J2D zQ*gaGuD;)!nJ!h_t1O-Pe1y`lLv$w;;kZ9MLlPVDBm}G6F%74I1!9r_?Z(I!X*^tz zSGW&PM3JP03hjZ5h;-tTQ!-p;))+(i9RTpLde2B-5_1vn7VJAUN0CXhM#H;$K>hGN zENZ!F;wznTz1@Krr?r{o;rrQv<`Tj96!b_UWU(4ySVV$k#X^DZUL}*c#6zbgCwv4Q z>uA)P3p}ifd?KX&!b)lQ1QKwvrn5&-I*}03$aAfhuabJJo}x}*L|y+OUfs5 zi=0kZtchfgO5{Tcw1p#r&$hw4@rUk7F+Kp<*L4XR}sB4&wmcsamld zXy{M?rv)(|K$ojLuPD?T*>Pl3bB#(wpbEE3^S1`5bjJo~=Q<>at$x!Fn`)j~ac4b2 zD^S0COUs9;QH#ILLizvpFLG5UCL61BX5{5m#CHO;HtvhB+Io$}cZxzpDf8xi$e()( zoMIGdNg{1l8#vs~6p*6_WMAPH5W_TSPk5lUky5;U7~2Cb^R&@Eb)Q`@ z5KZ3b+iJQ-Km0Cp%Jd-9p1G)yyNuUX+Bbg@n81+!?y z*4_bsC+4kCIvGu;1SlvYOd^tIEA0c2DZkq5jq#Dm6a^J==Jp96tnnuSJ%}`d(~;n3 zE!D2d*$d5Jkz!lAlv}cHD_JmzJDD8sECLK4>6v7QW9b|JM^l#k6L0c;_e)vYCp}__WWv8U0ETgI1z4T5yk)UaZ9;3 zWkObYtA$0m%EhBFX_J&lnCyjfq)L_C9-Dbs%p;(K!eaHHXTqsTQ7(vmLE1>9;rI9%h znvG1rl|54YxJ6-)DdhStZ;Yx>*a}U0hEKmK{=@)NZAdgC(f*|wZc>&mFUkG}=}A1r z+g3slKCvF0W1}}6_*W>UK!!Er*gg`=kYTOveA|0mDETj}q&CQJZ-qmN`?@qec5E;D zKH_vUu$xjD{)s-241%VpBJS#sq;)w$G5AM;j6Y=* zcm|3YPZJI6t))jZQ~c0|arObm$^8hES3P++1rl=~gR$7`VG4(7hHV}4b}|;yh!FsW zuuNZ}q?_m(9%ShBY3LR8Ukx&Zb3NpxSjR188({$4EA=evc~@-L))D8Q7e8M}4Q z}(PpxNPX09M&9`WxHljVLM`BwpM1A8mjs6P4agE7u2 zd`!Qqe$%J~?a7F<_t+R-)V;_u-&m@7WCutpxohAm*D8f)I7aHnrH(P1_K9n+RAq}a zO_fY^#feq)ph2Gre1;~Kty)07MMwiqtbz(3_zsZWbGn4Tyg@JVKx)6Z?CC{Z8le!D z3s`k^=^;VGz8$~uBOhqVSwC4vsEaYr^2+Y;&Pt06=NHYN`g_mUlYVG+w6~WASEpBkbGaV^Pa#9LQ0Z3*^hB zh^zFpgNjl*5|Rb%e}`eTMCM%VAYHX2lzzyWs>OqJXiU+gvs$Ql-Eq@r*J^%iJlm)l zQKfbiu=#pnt;Ce8qPYP>!p?+@ZT1#qh?fJ`ae~=C z0_-AX6P)X}K|`eKY-|{l((#a<=QHygtS{#T=PHq3T`q*+AbzzjEi;3+zOv5P#QdX{ zoevVfWyWb+9qNg_0|f5h0zW~g?wl6ZgVsnw(GjGdQTd&b-d-}kAwEx*S1WJE3Xbj- zM0UxO1m||itwrEKqLm;eZ*hm=HMo&^vf|o%oS4vmOM5KNoO8drvNL$v20AW)xht0a z*HYOt;~&4OwUmS=#7NiCPxcgCF;vq|Xyk6o68#;ApyMCB3AOolFkD2dp-y5#z`|>( z?oR>`oGxQ04P(fVUZ0{Ic|%IDIjc$tWIa#fpT(PT8cy}PEjnJG3Zj%qvXZfVcvS3Q z#zF=QPa$EyR;z*~z$baE@%v~aaFGWQ6z5@$6$=cA*xi%3dBZjDoS=aQ4mo*7k5Rh6 zXVW^A!%y5Bq3MJ9D-Ab*uwNZ!a4l?U`?+&!Wkw@vRVuKoMdJx39D})5;D#%li2-;K zC8myPdrk-WK&tqoe1eO`yuJH2H5SYkQ{a9)3r<{Njh{i36W3@DvXZEit1b%Sm zmEm(kroLN-f8R&*tgr9Sh*{2+)U7Ut+0eU4DKZf%RKya0hMxOj(uZCFAuo{Sv3{@> zl4J-0(Wi7;v+nrxNI(m~7VJG+9FSQBENMjB71vZm6V@T~ z86R~l%jB!3;U~guYr6n(=rKr=Lz{T2pYSZdxmZ%EBkoX*1fvlH@LZW?H4McseG?SMn031?OK?kepKDj+2@uoOAi$eb@T#@HUm2ikM z6c?Pne;?!CVu@wp%J9|F8hAT0(thzeiltXw9=1nJ^n{HiM#ds2+kK1_S-nN&f}z1E zA3L3dMqF~9`{Igg(^`v1LiVYEH0|F*HI9H#bCBbgg^92i?n$(LuqU|$f8GIA1W`f4 zy1x&CkgHGMkS*GKg7VjJRAG`eBbJEiRcKSE2_@J(5YH6GB6fH_nFmNd(t3YU*VWm?tFff12}fnE6BX0xS2)wkqK9$Jhw5}yOr z`u-+5bkPcpS8BeK8h%1WOSM{Kic?|T3dIphL!<{jU)f=PBxa%?up(F;Y2ee`%|R*I zXKM3#pcjn6k3#+PQ{s%evdruzOTkX3709I<29|9cv9+>mSLW`;|*y;B@Q>IHektLO$zmXnk4&vdLN? z%H@(!#b8WNW)hT`L|Y@HU}SxwILRDMLfLD9gO);5Z?_q zr}r)C5(9N28iI~=SaK>($uC&QlvH|!f3*^^2ipGa%Jw=tsda5|M6JU{WJB{xMwp8P z1Z78rxsfJh6n$cC+C<1y601s{l#x9no%R1&4hbl%SoB8o z*4StYMp1gtfgT4@JGOjcP`4TI0z>ZkWUUk0cn_e}?xz)O%B2&_Qz`81#fcHgxF9Ed3I%dWaGmxwBlH1A(9li&+XjBj8 zd4f{qbLsVe)Xf1IZSHTTUqtQ@AO}fOK$K5^S}shZ+=kkS1}fLQQ}40QX}r33P;i`Z`7lzV<16)k{?FiXfrsL<#e2J;2#NL;T|B z9Ex?Tei&tmp|(@ed0h&6AWQYI##=(OYrBg1LzG+>hXFJ$IAE0;6oWqB5U)s&aFYl?1n= z52Pruli{(ju_ZA_Q5V*=aY#Uct^e4qD!Csk2^`O&vdYtKQEx<0wFB&++u6lQgw$oE zuqk^&d*f=bGI0Pti6W=Z_T{R!GQbj&Z(=iJ8&yR{E0taoKkZ|f%ig5rXRsW)G4E63 z?v9O=XNwQ(qt88GtK0PQ9JEdI$ylnuAm$*V9DjzF6h11tz{#Y_nqkZKgqw2Zg8I%Y zo)Bk&lPna_aoWyDmWIqg&S5}*=_7F9aWpo=kY2gNf{@x_pwMR2T2Ul(x=ziPy^5|mWBy!G)TFS%zKF(i z@Dh$vmWBB&Bu?tc90e1f7+;XSn?_AUw_Leyo~u?B%>%al$qoewWhzf2P9mHS+q%jV zc+iFp>0oJLd*^}zbD2zCP%0TSaDA{hrcX@KEDyf>%XjlRe-(hS5GQ)N&UDIslbjgY z!n1m)mZn*?&)iapgO=^sULs6eI-x-Hl?l3kiq=TxP%?Wx+l}ibRdM&ar=jG^TS5pn z@fdv0Lqsa8r~KIw^THoy|E#{J<)fQ#6^6~zZmrM_!c={1a1;7kb(pR6u{XkW+i!h+SExYeBR@@VA$n7&oE@M5NpCLob0!AU@iP zBahA*k4ZgJ%r2t`=B!BE^dEf*#uRfmuEp#Et651&!u$ixYxu5F#3h$GM)2$T|(f%=81h zpG6cKjjFyTQ^u_y($&jAcyj934*tp3NFa4jBzOw!Ldnzx=Vwd+%N6Y8?Xu)iYEHeC z9xm^R-Q8kQ3C{H>m`PfbK!2r}5%%6fvON8p8i7pOG2jjGMG@xA9soE%$G_CvRk|;a zX;3j`yr?7U^nT3gxRI9WJ>+`|CooD4u46`MSsfTkm*#^P;}1}2j0dgsZ1k;pV5 zV}%gZLFBSJMg~YdB}E7D-WBL(@6hN)VoSSd6>z->P&Z9EFiX|n)x|2l0ZJ!I@aBCaBd z@d~PUr*?;46=!R^dEnv!ib?~6zTAOnZ-*@inMgs0p~jK6JHt_!5%jBtvo zRr)FU8eWDL#+aBT)hKLR#EjJ0o~M#MtopeGn5Sk3)QxuFbC;NKQZtid1vHn(~B3g_6aS8*j`>gL!MOQzP2(5I3hx)wGuD?F=RDufRyeB(^w%9Ia?4Pbkn zzV1Qhg%ttx~t|EblSC*YDO$alEjBxxKGMi~d`O{z~wp zW6O_^q3s`x6QL?^gQdjvA|p{|beGCF6rMN(;h$+8s9O@+a5kQ*u5ZQAp4<=Be)IxTM5O z048J6k#L~iRC0D39edCX(d*uZhJjklb>4;cl;h%_WG0Nc{iCEbNqkuB#U52gjOc@p zK9KGXHC~yWCoAbzPn&TD*Bi#=nd=+tV&&SsP`WFsAPT;y)Y0j#3|7Yw)4g6 zk`(lyu5YaXZAWw&B73cSi*Hn$FEN!)DL z-Leii2K45f{h~NmP=EtALe6SCKQlb^y1tFZs3D-t&$viXQH%Fnt&kL*^OTHz*5-V< zQTn4!>9OO1r|go`nGm}ei~T;b&kK92Z9e~GTw=+yY2PObd;P>LOcL(U(c{tJ#& zvNWuVE;cLpsd@I>ekdzPdMvaUWI?coIDK0QoVEkG7u=8Dz+Ld&F2CSouy_5;J9hKoJb&W5!&>rVHFiv1WeHPjB ztop&XxG;<=AS#c!bB)Ots{+?f1^MzqHMJj$Wy{~I+pO}*pFq&aeX=w6el)`i`G0T< zzA3@v8U}KmY6{ek>_luS{a{j(yi}okAlYu4zO|FLDf)HUlKDBl`dFLGPYg71p)tI) zBr(0;dhO%pNar7;G1;QTd^8po$ZABM@)= zUUeC&7HVk;WvW!^e;L7bh}hmlXD`HyFu>^|e_D2o>^aB=Jlpf=Vo^1wAhmbaUgso$ zh~XXnQJH=H2@6g5$hu1m(gG%Ocq$0A3Y89^5UN*8q2*27+%9lq*tAOgIYv?OQse5l z#(x$4r}p&9AKO{``5a9D&k>hZrUh3jE!?3$fN!!7gr=#!YhPaKm@U0eQu=8?+f_7y zVi>l8PXvYQ;plM^n^>Y*wt=2r0BPQ$!Dx3r^ct1jN>XF1X%<1sO*7rpWCUKkjHZ4{ z(oA0lSw`RkcyBETHvaAkoT0}~vhT3rzqpD|vy)T1(#sIEH$M&I!7V-EDkg5r{r|J? zvWa+2kMKSX6vC81auEopA#XA9;`J$py1E$o+fS~+tv#!pg-kyPtCYn>Nt)L}tV()G>&1fFQ4|>M)i|@kbWX{_uwUQa_O9 za`+9t^=g18JrmTArQLWyW|yJyThfMR?#kSz8Wvw?QMfoZVL+c(B%LPmZ^Jy#q&>mP zR!}}f;)bTvQ;o(wZBP*K+g+Sfe2ALl1@eaE^_6oCCgF`ot5~V6U49x>+TkKFDeAJY z(YJ#bBLg&5uP;ur_am5d=rF5;$IbgR{WOclNuXH;>~XVaSzdIno;Wu;W*k=>4MZ$cX2i=*Vn~x5J9>W#KOM-b=f`%v&qv_5{?8b#;-I zzfXc^os3bM)j2&0pjO6_wU#E_5#5`4{Ww%r0~tc#B!Sa?(2^mN>!H$H1?@5jMom(n zf?FaJ8%EH%PNjH+JB@1;Yn#K(5nicP-e0rxqs=X!V49$MVRQk(;-cJZi0E0UAHK{Gi= zA@8bs-CLpbuz7CU4+v^XJ+|Gk+(#uhHN}9}?7H6UoIqeEma6iTRA0CxD#YC!L2*in z50w$d${%an&2P$fg~?Cr-(~>*1ob#Q0i%(O7TuogwC%ffNw}^pKRH<7;OBND@2DI@ z+#DAa!kjM-91}Z@cJOjOxYV2{)UVp3mMlt&e8G{Bu_XnF5S8R?M-~7Fb?iO-pGBrF zkHt^h!icLa>$!l|(?Y#G`D3uFJW=k42vIVExB_D~3#bo2(LT#^_W&^~j@2{7CrsVE z0bSprWX@s_6$Gyu=;8nD6Ry0U!2nOUuWa{bnUVR@5~xI(t<@cTsUDHN7m)u$)F}qU zYxA!uKvP;5U(dQ(&=MgFeBabDgKPn^iR8^o2u=+~L*kxa%l5C;E8CJpZ%>7T62Jo88cWj{JnKm(GoqKyMUoswRK9VER9G?uOq4LjPQ;)IP% zr0PIzv$Q&Uia_Op;Y?R6+omiZpj^#=Vy~8UA2YlE$twg1O$O87wEUsp5ZKs+_#@Ns zq=a6dlBOf$%L49(vk?&pQWQ8viCQKsI?oO@J0DpNQ|CgWhahEAV*_|XYD_mJ#&Z@S zK1Q>^{RIVmler;$cIUNBZ@uHLaWfl2?S9GV=9!T|s(f_!M@yt~kdIBX;0%d@REr=5 z8ywbPB~8WoFDa9$>I|^dh&C`vdzk+su^pOJk8K62yt}B>kDR%UJ@pi+!_3|$p5-k< z+WyhlE2}Sp6sN>!OTS7o$qB(=vwI=vRPCzrwB0u_+&`|i?8FK~R1oVqgG9o$A3hz( z?Ojn@0c-HoHN$P8U76EI9x_61pv^Z*?2hh^8nMbPyQSp@lqb_Yu%|d}O0TZ)m&(-_ z$SV^5S$IjH3~SnAbJR0WYb;MxdpZ`*Lx7l4=&NCIvk{*w%XRL{c|j;8M=pMWk;#;g zd$?RryajmYq~`N6=|DO62z|iYHb3CL0ruPOsB*cUPbzX7*U3~p%`$29@oUh#wk~7e z_Q0cCEs_*7M2M!)l~x}tyfHafr*ww4ncLHyr6@rx-HG*G$+$NU8P&&gL5Q(aZkq!d z?>!`@VA$jVhpPZ9Ez{}%tLhcBn@Co(DceK%NSdni(v~vKpN)9?l2t*E1~KVR7nkW* zk|Tc)xXRyB4+r!VQhQ+0frzcrQHb*>9{~IXN9vz9AKS>_2=p>4etPgtg78#MJWriW zUZ_`S@L{@l6oqSlGCiiei~0C>CtpsVJ!Sbz*S~pa36wJZy|Clhl=s#6dog^9!`03RK?&;LG5Lrga1 zcc2}!%6|Ya8zNWnlL&oT+GPyaQk5-SxM%bYV(S4P_50lGzTaxg@@v|C<#ubyuTr$< z*v^*G=i=stEo6W}OklWD<%q0>oQ6VT65{AU7C9AdD;`@0j{9i=lQh&Xe1NPi*%ddTbkv^^sJjEwTgW5ZqA@Qs~eq1vc zEMMw#dQN2!w9@A;6(b{SywD`bvL&A9a*0(jf-_WApfyrJ z6)po>pI=*FH8HtP9};Cm>!c}sMFX<@B@Exdv?K5vC`uF{H$Td z;9prpaXf$#j5I+6X1RRCx&sr9b$G>M-#X1QPv>`ex+f)jg~!r>hB9?Uu1snbjOH;s z^1Nmfxf}ic+m%hQhlf~RD!jE%1xQi7XYn1~*~aqq z2r^tw10uC|P@t-w{w&|>wa2k|6g2K*_1QBSC9g2wzz6(h--1Y$Os>GWEjv)E);V~? zeLDPD@le@Y4yWZ7dTo~`!0vVf56}O9P_XXp$a%lPnQQO~Za^ZR04OGRhc&nB4H6C+ zXf9@!J**W3XT*&~M}bh8fGg19y3&-t;YthmCr8;Icucmv3wXwHD|3oORPxpHw`_@ib+8e6&__fqk0Bw!sb@1Eg$x3{w zjZWEaYKmS5C~oWZiA<^pGeu6lkj>O~H-?~nx=m6Slz91PZttq8)yb8D7iJ?xe{Td$ z;Z+ZmLJ3sAy85>ykgR3fQ zMk|~h;oR2FNN*RQHk{8L4Xs#$0(I)x_>P4r3uk@;=nR!0cF4YRet#6)`_Fb?BCwCC z2B{62(3)mH17Oc>2RL>b?)^U`71<{9YxQr{L-F59N$m_Sc1v1<=X$B{#$do&-{3S3 zYBPGtH;XHB&j70#sc$`+Cc*|Uy1;Gx|9$5XYj*JeN1gxvDYTuJlVb0O?VOhW`!RXW z>7ocr)K)&1xkuUPzawc)ln;-3WbRt z`HViE8;S@aS2F*cw7d+-bpH8;-1XP>ra*_Pk$&n;1TiZp1995^Kab~>u*D*Q1)X%n zFo)F7{6aOAwF&}__~4>OW=nV4UBGapdj-ZEA`y&#I5Qx3Z0Y^9PtpmSss78!khH&y zT!o)-9&{q(Of&!g#bve1i9(utrVRK0(Nas<-H_=GE~VJuztHz_OI5 z)!0x29bcbL`BGNeOX%Kd`dSFQ{KlU^NDW-rF(%jn)705vMZGQX)}Ra5h>O#Lg%Q0j zoD2&H6<>4{Eg&j!)OrWomv9WlsiTF!!7h`lE{%sUl)7h;OL72`sFg8>*u0JBJ?UIn z3@Op)`pnvDX&$CpnyuPZn{+9}t!X-uKQ$ckSbHpY4&CWKhDLiSq(Zm<>*{h=-C8oH zM#2RprD+>+JJ>H;$G|p+l#>uomE^6KGdE}8 zTPyqvyrHAU%-Uy$giG;W;~r57Fg4S2{NAxu`oy=02BA!lnsk1ZYZ9P_xY4~iSZwt_ z5u33F%BS`-&#U8mmFJLC-hRP~ix&`PfJ2o4M^O7OBtJO35r=bfms3_K@ zzop{7V$kP+)q#QQ^TP@&TGQwPS{nm>Rq)cN@Oi(LkCLmY!o0Dx`>i~FxI<7ZX9T6$ z&VI#+Q8-hVXXgGiI}8pcPG;Mh1G*CIy2`q$x5qTqfB7!U3s$|igHhl0LDo4 z@`2wwjW2klnJ?zJ^cw9_T*c&m5Qt;PZ}i;kvtv#)A;i*MXy{iDJ;w;uV+w-`jL@)s z3g33LU07+TYO8=|zB?!n>4;H)E_5~K!@C7BaEl)UEDUEYZ#TmIDoBsXPxmfuh83|K z@zUohLm)l{cKz$pdOzIlsq_@u_8Wp9FW=luSHxw**#_B^Vmdomc4IinwuMIkTUArc z`?C1^$E}bTQTGNMd{5jjv+anW364r1x3LM3)!L{U%%1i*BO`Baztq2*{o&Whq`mF! za^|QWQ8)Cm9Ld^fa3khq;mfmp2b{bpe?x>SmrG^N1|{_E@2=4WYru)cgYpuXJ)J#W zu=*(+XuX!sb}b=es@Z9fE2>T(9-%em1eDSOTke$l{~}{|d2jTGG(9T0=j>Pw{Yt%n zBGeLSox|pLwd2+m0bog?*O)&@ei*;gn5h(kdsBqIoX4@^lMe>SOSr7u3QVp4r%&zi z+!`r{8NO$Gk25?RW$4loKGcfE-6B6xT9fridSubu^M^;}H`k@|hplL! zg`%g}4jNyzu*j5b(viQ|&}dHB4x&aQY<*Gtdsq90Kuwbfkg}ks}4hYcZ%cNV=kN)Np%T6aoLOf~KF9Bn!;J=Lvjjcj7aeS7B z2Xr%Y20|N8iNZx1OLG#UvJt`XnvFn1%DAps=J%taigmsiJD<5T8GQIJmxuhh5P-BX zTu>#=+K4&IG4?~sb>*&GUZ{UH*q0@QnGA&AG!c(-=s zHb^}HI7Np1>L{kFrvNg#VrcK#`ubBhGd`g{_ z-of=qe?JDg6biK!a6RoGPOeWjlQpLV26te(xXAT)IHJp8etKNI~~P?UHH3wO3b$G=a)Pm)>l8D$~M zHkv#CQ8BR)m|yY!Czd}-EV-uS!<*TJ|J7^I1Y?Rlvp+<3SQI5tzNb90E^s%5p&@ZK~Ph&R+r=`GE0p-SDJ@% z{0=|D-J1-*E-a-^+#O$(sZ+%*7fz4#{(=l?DNP+k#aZCp;!#1tKk?FJ!*{(Sa0fU2MBYyIn2DItM~?+@~TZv?D{ zpYuA0=g=+^@a>GDpx~z{Q@rJf9inAje$8o5^l!zJ{B4NF#ZR= zCa{f#so^9^PFwBzc9vZjy$*LY2}BXrX^TwvlPpHJh_ZElxw3OBZFP6kkZqd~Hu<2u%$u+=N_D#at{WxZ`PIdS_*0 z%A%PDYM*`B?aiy#UB?mP%+EBSF9iHk7f}`ZT6@Ebz3RKLY6TQ1j8Ex(baEi49PiX@ ztr9Ql8)wpHOPK6*_Wz1bHYU+sv)oQC+44@;B`~P+mOH?PFjnfZB&n<#uQib-Q%968 zKRghh!%rGjYWl#!S1D`YF&blN^6E?3@oh}!249JviZD(-V2Gr=Dkz?;$`!q&yB{0Y zwy@v24P*CaMBk6#I)t{dlbYGOXXjD#|8zmj%h{xXiO1XS9=M1`H3UHbf|y-2_!q{g zanjqu^TSk*HV_U8Dp_F>i;*CEjltT0d2SMKs%i1NEfsQ^Gt+!<)Q%64uK*;ICDy2X zYNk|yfncxD0ZX9f0UM%~n}GWn)+nk^a)bU28wzibLzRWq^BKPkZChjwHKM_Qm@(6tapLyQ z{lfXf)a+OZo1q!_U9NbKI#fXAh)EsypG z7=%9lT2-LGI3Z?w?o|7 zf-~xnz}+2Sb5F$29)Yq3f&@LFfg7k9}sI65Pc zg3s*^bn!FC&J$Lp;AJs?1cZaAUWH6T2A|JTsfZ%WUIlIQBS$(L{Bw_YyjY4ryE=t# zcgCD4@hgV(k8X-DLb};b<0kZNCMHIx`G1P!(HQ-+%UlDx21|zo(gbYSW(hU$a9^L5 zmu}XYj0UGGA;BG+L&V9NRg{@u{sv;0$mAv12W1XceG{L8yV0@(k^Jr%g`6Fs=7+RM0vhzvgS@6w@Ah(huS8) z{w@>J?-?mw%u2I8eGzXkv-XopcPT}ud7QXNgjEP{;jnGdcu2={hwxIg?VTs}KM9e` z)3a<~)PjsfuN(O4FoME0SGlIyA5tCtPb;Ude}+W&koa)&@J(94;M(C4&b+f!hH+S0 zA>tFU4t#Uv4T`YU`gs8+mRgFWrgMYcqTe<%txTZ7PA)Yz3&uPyBG|45wjO5}twT`c z&jE}f3xJ^D!Fb3QOgj7Nf78L1Jzt$yiq19tQU&$C6x1Bx3ecuqA`iLFZ3lM!bLC9} zxtESrBBC=j)K}z7bkO0{!A$w{!#zV|wYWyH{Mmx$!PL#NS80qUk&_Lbk5CADQ|Pgl z)gJ17zybG8JhKH*)5oEBYW;#)?4tN!ben_^oVUyl!Np{GjD6q(2XB{5dbPQik=DP8 zM-o2r>i}`1N|m(Ppf)vlJc2pC534^<3$M3l`>#crR2@)p-oit{zyJ$Wer7c5`+qe@ zBScGRc|a?_bn-#04j1TTY`__?IXXJN)ho*p`b1)*fn%(JX_#J1j z0=xt@`vL;ljQQ6+9dKs8-7P~zM&n^NCe|A9^%3!?PI!nUMt>!-3A@!qcf4|qQ0rng z>xBo6d0LT}3D8m`pm&=4hJ$?`<2oXuf z;oiQ3E%+cUDg)r=?|9^+FH}IQ#%DmM9LvvuUP^LkJo9$6{iCUhBnP1m0nNxSFArI!L9ks6etEno* zC|D_7Q6?PB7GWI=w1Ln^vOOZ0`Cff@kD{7RQS38Am>z6(rU?Lx=A7^efNKK@lhU8^ zj-Bk?eh(l*j>eM~k~q6zbF(#J`vh3UzQfaO9ZZ9$a{Juq`Br7%pVvR}p$3F?#PDE& z0F*+^2(*hcuWGl(i*Wv-= zR;keP00e3=UI}wd9>8t#B9BZ;Sa(3e7Z>Jg0}8>_t}TAyvvJO`>U*@o$(-+jIKtQV z?vkk-b^k`-)pkDb%s}*?0{Bf3bk@5TXtSa|w?@^MrZ<$zLm7A<2ePsVB9vJWVg0Gx zOnc;(HK8=Ri>BrJB)>JdbLf-IX!`6&Ry@eTI#{X{)aY`}u$#}(wE1ra7(Vuw0=I)@ zEHp}m&J>`gQ>t8ZD#Bg-zJ_exn-gNAhAP^8&^Uy7#vnzCw^N_QKAMOy4j$Bo2Zl1w z`o3+%b%qU(HYd)|-^FLko&oj~hKVabctCQh)a$2NFvQCFhwe`{GO&0v4zVz~f~?o_ z;N`ySZ@k6~U*^QL)$G0AS;=LSKS;D`$zv`4SN<3lm18tkcpUdtW5CTNgyH@s9zR9Xz zlaMsY9-~#m?jgIgep6B#{OS`mGEbwRQ-(i?_dsoEWW@rVPw$jKD_(HaWL7^45u%6$ z`Y1yo2|(tow3KV2wz%_~#V_bg8+tml@e;J`EqE}2$&4K2Ubf_gx@sjK-SnLJ0!+`$;&;2Q}VM@!bVOS&iLM{gjt-c#btY^w-v` zg>H(PAJh^PHiUn5PnwbY%;sW_%cd6Lnw(fOxXD&1SeEMHy9q^5j!-Qu7V){wAlnNL zSuq*v6UKY1eC{>2$5Ik%@f?KTjnlt{G~FKgV+R6~4hy1jyk6_n%<(=NSB1?ryEbtd z^UtFP92GcLFLrV-AJU-zbccC^D9xm zcQ;0~+Mq+QBac7ptA{GJ?J$21Q{L(lsia9YiDV)z)@-s%KYzGXkmu)mh$21`Gn}|{ z#(inGsPj$FE_GF?fo2+x{dQjnlNV%>#syS6rkKDtGTR^k`2K2|lp)ChInoB7bgJ~NEEYE;J* zK`u>PCG?y9O4##_G#tDgzGuef*;q3a>Lues)4`@#(F$%(W^C%D$iP*m$ig1bW-p{j zfWi#}qrOv{etw|BRQ>(rLXeq)AZbl1f(|V2L%U=J*gh>_O%Bi+{#jymVg4RaRj$<` zP&3VfuZ~`gltHXv>fS}so&!k6QS1F9fH>)MOIL%X=N55v+C5c$=VmOT>()X*S9h7D zsP3VDfmkk#SNHqRO3~8;mk<4OJ~EHV?QO2rzDr&Z)g`x3;Sbnl3B?+k$`7~Y3=b+g zlM<~uA?3Ih_WRqsmt!s3z9rJ!yD-D%BN2F79XIL7YYpFosiKE_1#-LfBq~+(Eyj~z z;?%nDNx3cq)-8f6i2sQQ1$MfY_aj+kc={iwjxY4&EZu!?auYL#WDGfbQa+tgOvt+2 zy64^NKUy$nLegY4EVzJkjbI=8VA37fT7jB7!td0yL$V4=KUTLXG)9eZCr?$zt)l%a zYJyLWrDE_qf^hAdOdh~n+YbB3i?-T*xP!qAY6aur5U*A-3c*VFLZc|wopZ0;V9^c* zZO1gZKjJ2b+p!?WRAv?_9In-c_ua3=ibtUK&;f@q|MVT_btOTjI$0Wt$c&=X1-DYx zhli;^sTUP72-a_fH2T4F5Lj%)qxZeMNUXUDlPl*IpY3Y?)W(E`wOdq>n%hQ<@JQe_ zhq<rUoL$;8jDp@ZaZY6?*Jk{zYWl(iBDjcQX5ns8q_%W4ujJap zMY#j+mPTt@56qi{BXVogmY{v)gI&)DIu4j`G&V)NFWM_}kL?A(y>&~9B*TZ2Snpb| zeFkK%5}whCAUxVj6}8hy>-+C!$YZ;Aa5l>F%_gYHr(v`+bzTRl2sr}YRyh);OHe>r z+?QYk-2r>PN>LJNq=B|io5@T1TV0Uey4;mOrwNwGb#E6hEaQ3$j-N>H!-;uklX$}L zav4dO3#q;0sO{vop z#;S=3MG`K2qBN{y?e7r>{eybSW_?aJ&ggN09l$!sK2sb%WgM7%n{4K%(mu)gh+g;S zmdy5I58xB@+Pm~$_k}J0$KLS?V2Sy+o3^Az;A%`_B=2~s0l}GOA=}q0YsD1JVF=w8 zMZL6x>!nF(AO{y*UfLLB(BTmQOqvR9TN9HOUkpN}4hYD8+b9EOErI2^=E7u@fD}?t zY2>-)g3(s7!%Ul&x%@mNRn*z02J@i??m`3`{)(j#s9(n+ZW9=0T-J4fLrSSzCYTHo zkdL7fJm$q@djzFj&!xcfqDPxaN90T$W5hOi{l)Q84jQj&Fp0WE4Mdkfol7*pYz`CD zXFGGcRn@kUcQeap6iD=IH5<12yvBkG&+3b*wyE1lD~&DAJ;aPnDk7Z|m-vcu(i{$L zS=jFko=2Ulz3(|%GohFR2{pQO3b=Y$Z^>jPF3@*4r*sSTNr3X+g8ssS=Rmm#|9buR zC(T><6NYux^Qld;yQ8jD#Eon<%QM-6dy>uW9yWGnX=dQD+aOy4ahi2X2t*U8C5KX8 zM+%Th^7N)%WoQFO$-|zix6e1LDNNZ+T_p`r_oOkvBV$|lv>|1#1l=RDKSoRjR2UBa z^>y4(3KlZm=WTZ>jkX7y@PA9}wD?UCG-ytA^HYvDPhJnWp(JCq-0?KZX7E zb4HSVYVn41;;S7?ExM9^A1Orn;87jAnoCGuF`$m65L>yyN|~0xko4avCZj|rQB)W^ zvrY&6CwI6g%MJ@qd`bVV)R*0Bdlgb z*cR`DYCp#ueKI#&zR4tYDB#?}?%|SF)gXkI@KluLm0r$a;YZF-c#vkhw$yD~Y$bRD zOH0W|p>PDn%$hmcJ4>F5HXY&f+mexwC45;6Hz4s;WZ?X^C%`s)v?vlm?RsklRC|~v zV#_uV5@Lz+HR_^MIe{lAidwGAY;8s|XN#0ruK+~6>!AzN(qH_U6Ba;KMQ_Jzc{_Y!N#C4JSZ0-^TkVjw>pZQ0e!TV4 z=?p)03wnYFCyQSJCtLKBfdL9!px9I&%IFVRifR0ey6ab6n2We}4$Wq}5ACe-X?o_e zK~=>TV2v8>7YtbW2|5R)gyw{+8+@iHB--wrV)6j?z{JYXBL>AJwlSeX?B9q~1GUt& zWSSf>cld=3zei#S5O8TFDZa>bQAY+1O>VK$|L8qHXoTrNXP1DM>|{B;zm9&qU#4C( z$!#)0(VUAQO)tMr1O!IiWL?Kx8?vhMjHxDrF#Oj-DX%OAbmP8&*pLKtQp3iW2`P>b z4)3|Iw>Ot!ZF7P_{I|K{JX(}O+4+rgOdH%9pZQ#xQZ>JJGz>Sr4!Jk-h zO3Odb3{Asip6ofu2J_K&&B`yWLd0vpdzRB3LO)^EseUCENGD&4<+Sf55)k2(vFN^FAZvhD22`v`J0nU1<8z2@U$!p(z z2O4;dMvmbgJlmzw&&|Uk>mr-a+EblKO%&;0$GvKq%e9on>ODwqM5Nweo6g_enlzls zJ`@t@*2|TCvO^c_qwwO*pnjwWfK1dVZo{=w(qL^IQ%5Q~M^V?XA1DA;{3$%iO{?zH zYAA9s_ucPE{NJM)h>?vOw}*krd3<{X;&1GB(CwVTuxVxdVqle8Yr?kwxY3yQao$GW zTZ4unI~tJ}ji2$la!Xl)~I6bQHZ^ImT@BDVs@ zUPlh{#k~%BG&G@x8;+9By4eWoGvu~@vCwY@d{`tjRhrm^^|(z}U#dyd)lR+>kgVI+48{~)TONTYE+eqpKHF0u0;Ab zAia+Jg#cBsoCuK1G;h@{{8q{bj-MyNbZ#6(wYJU;q0VMGJv>pDrEn7=sRcQ z15xG5`sVZLpzqz`oJJxO8&h0V5G9 znm|c4>HL{eiNaO<9DT?Sw3xJlg>kf?tmVJzAu@-ri+{$wsMasBKk^#O&8cul#2-M1 zzCK&U7xSln0d3@4+SEVtom15=-3=7QKaU(6_9~{;D8M>7t0lXiRnoS+aG5n1-{)1%NP556zdBqdG0h$ ziKMy=;JNRr`z@|Yhq1Vrh+U4CftiKWo2TZ|3}MK*9cd@@U_@D`)l5J65yW9SXJID* zrYmim#ZH8gavx|EgkY}2DK&tsI-hXw%IXXa?n!-&7y%n;{PO8~N zXl$_Fa0^tDHE)a$k{c&a>}~9&T6gqbLbhgJ{KBMPbV`rscmr2lAki9h${iH3vu-$3 zFy4jy-#@zYZx*88+|)6~_AT4enyqLc5*mLT(i9Wi0Bq-K66jLm=Li?-Z}J1bs&^9X zi2Fi^KZAmZ%D13oAw^|TA|VpeKFvRbULwcsQ5v=4!cX%kXSV`lGy4)a3dng?TX^CM zV@|~+`*e<1YX+g0teyHeUFhSJfKn#bCQjAzU^cEPQ5S8n{vWb6hVj?3+#RH3piPJR zkT$2q5BYq+6@EZszOE$sfA_TL=zy4BWic&`Hwfu}YsViYNyBfQ`iM1~r-80D)RFi6 zR@?*qC7CC6k{b?N+yfDx-OYC987ceO7r4|O=sxnmdXMkbP@f)yA~|c6(5OlzREUaidSQ>d}&F#Lf?jU?nA`@Oh&I{18^Wz_>&gLS5%~(spvUP)CB5a7wP|L z0sxDaVSs>1*3+nslLF;es39(vKb!=QshweOsXxs8(8qV>nUQYzkv`E<~s|b|qTq6;gACJ+x(@g82lPTHUTfBRHvj zpz|d7q&E-?hAy38eQ0;21bs|}q!{cx;Y#{7nJ0|U{7$8Ye7>1OlVWBby0q(Bv5)%C zlFN6Qa~B6LR#mE@FVJCNfpcuMVeQy2X}J6|z?=T$QH+#f_u{lbx#r_>E}NVQgImJ> zh!ExvjM*+=rR5+)Bol!OB4@tgmPL7|=w$1t?P_~P! z@eo)-EZu+e%L)n~COzegtMFk3?mf6%NsHStgyYPm-7oM2FD?fTtU|{RB2X5Yq^gF=ukBhyDB6KC83xj4t0d|?0y*WVk zbPQAI`?`z+TM$EpaI2OEDa4PMf>}MXlY!F^tkCkRd*d$rf-f4H5$)-TGsHOuxGXZ@ zW|ThUE!PR9{q~|m(tB1A4piH7C5|To$ZM(53-dN7#&Hj=9?ZFQN@f*sj}_)1aLUzLVJfAlp*-J1^Rm^`-w2(J(p2{Q zaY3eCXB~FKu7p_&KxqZombOwoBJCf?CN7vt#EcdU)v=B7{_*IVAnl3m>8Sq!y1<_SY1-$hB<(eR%1O`41Lj$VihWMB&e! zWuMcqd*a`xwF6}gbeuRk1hQwYWHoZ-MiO=+&p2hyJMA4@hHkw<4xOY2`?VmWAUpKE zo2TlJre42vVd?sCuL={tOIOERQ7=N2=*`Gy$yc9fRPb4NAVI;0TQCnq0fWE^1!yn? z%Y76g&5WAI-rks}qjChNv4zc707_Vu;NXA>{5Jk4B~-)fSCcs-c9o;N(e|Tn=iziH z9`?lOG^`>>X%+``yY%;JHRA^bA_!3!*@T2PwsGlVHPF!z*H^3Gg03)YS^NQ9ui!(f zpCnhQbg^!4j=Ee-N~^Qy}#Bjy{@radOhh> z&bOQ>Nb4C!r!62k=_8PfvxFBmD|W^avnQU@C?n_BQ@n35

        2l^fgDg+!%$4BHOcF zOzD@=9=&yl`Rld@Su2g!>~ov_mq(Yjv4m$^XY)t2?HM7zwRD39T&pwK_7LxfL!4KW zmSopiM>mbNDLNTi^y$(4CsHZyR?9Zmpb(V@4GxJa6t!0HT)%zCsBHsQuHc$Uie38guuqpX(~JCe z{&<_~L2F6_)jjqh&N^t3JYWv`i^7Wp2nN zYa`M+zD53Myvcxlajw%i2mY_q9eyvd<6kF+2l${cD#m~hWNgA`txP=f>QA}P<-=C; zf8=dQGd^y>@X1=|V)52nFPL&02tq?DNiy7UpG~l487dg41xihTG4{?_p zOcpg$m@DV`^QlvYc7-vszhg_8KPB@ExO?Oa!Sy%imU@9H(bjGV|7=!YLOiB{81!)w zZ?tpKPqo1k{@E9i;;cCEf0#MigZ(ejt^nJ4L}jzi)Zq_gK6F|hT=3!{FSz!boJxF zktt0P5lq1hWql${;HFm=gE1B^;8uGL`BgYP z41MN@O7ElcyR;c6R;gOnDij4Ga&{{LHe7~8{s*~TW20!YxB8{w&#xuG2;8UH>D+zc zI0~^K?HM&f@G|MF!p>*>KRz0L0?HtcIuFAa)q&7+pUgW_(b}9Jv{jk7f58GzHR(bw z+yMY7K-Rx0aw#g?xtnEQuIEs|=C4+QJ$JRyI|&d^q8QHqabpC##%fB8CdjB7O8ig> zC0OrWC_=^7uV#ciM`k5(23KYI<$(3as#9H^XZR}Fns7pSUTt0Ch*$uwW$B6RW+OcJ zqWYbJ2wE1`ey}7PnHQ>g)X1(GTj25V969MMRX_QQtu}}C#kQ8VEi_zw?2R_J!^bfZ zPs$&}RylXH0v+*$?vas^N=?i`*t3JjjTmqTEcghcyi94Z!_`EACYm3j1foCIZ=+aC zlUZ{NNg^tqF)=tM5>ubjqyt1cNjc)xHGL7BZ&Wl>u69 zEV=5Km3&pxQv6dSx94%^9>Szo!7zD#l%H{815=;R1p@>Su;l!aShpnT0bO@JpNe`W z%O!yY?ttSwKS~rtR9jmw)7VA?O$zGb(X=ryODr6{Bf7Y8*70(S*{l$-}n`2qJIe-`DPze z#^sg>8RPtWSsQ=qeQAo=E4?wu9swd-gVhf-J=;;x>0osq7Dk9YpGCOWMk9#aO}ZXM z+quKO^NA~vZIm-g)1nm;mHwgac1vI1;X}6sd6lgicX^LRDVvQWzCKo0R`E{5cnKE- z2!;i2Qm^Zve+#lkAl7M$Ko2Hk;Uu4_KGjZH_Ny4id5+B5ga!lI?s0Lk=5vne;F=lH z#=)fI&XD}fK(rml+#aNy7*;)@DXZFzQ>c34C<8UqVG~)V67EjHDhBM|_JsT+duCR6 z{$orMV=$plQFT!6AUw9&|17lCs1EGKEor_aU2F-DGAt

        )59E1R+F}yDa?%R5JFo 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 z zCj%xh3}Dd$p7u5!rwiqL3pg)0(#y1m{%FP_nIIj**ab@tsouP2tRM7mv4GQo`xJN1 zAeV;Iy8-eW`Tty0e6BqPf!q)&YST;$-2j5lR7$k~FBdK{P+?z(vU3CUU{}8^tP#v> z7*+Sl&9ja1Z2NxeZ=O1v#bKGbrKj0U$$Zvnx%`)EF3qEACb;0g1Pgxx*_(7`x*bO3 zdd>P(W4R5(R$x4vHeqlAU&@gg-#MjI-Qv_QCT&fMn9UeR@uR3T_}pPD7#cHChNVD? z<0=BdXcsR5p%bU;^QUL3dY)`ELNP`n;MHQ}<0EHwD(E``)L;G3CW`DnaD+>g7R~s6 z4)FK*k+*h0-E9U9e5gp7N%*f>6WdcHzh7$@@%hTM;7b6L(oS6dX1min`#Pxa%J>40 zNWHi!>y)AAAcN%8r(Tgdi?@Ka4JhF-j8{Kw?tdF8T6}wV5j9NhR3S^_aXNNJ+V_4+keG%%IPMXL926fZm6SlIq{z z@7}))Af++GR;I_Hkyq#h5o{$>*@D1_(wRnp{$%m}h6V`meTMXg5tqe;jB`J(i=P@g z5=p;pQE(esYw#(Kd&bvBs^2oxi5z;JhKB3}Bv6&&n|c*a*a_&b?Eep{Y=iEOgSb6< z3i~=G&lhF!2Ihu%_rVKpofT(h~1#WY7=d4$zCCO>tiG`P4qOl;X_@VXciA zl&R>AEwrpMz;st)Y2I_;I9i5l;6Mm!G@f$Zhir6z(+84Agix_`IUa^V?xVd5# zrLHHd5?4gBEps(Om%1MUOEGrku~)xIqYdmNmA2B~b?g~p= zMgke?n!8l(cGs4BgEr$^Md)WUUv7mnc(hU@lYeya-%$JQBTWkpMP^`UM*@p@g?h$g9J|k5m~i)R?w(KxJ0lnNGD5d9a`Mp2PyKzMUa(8l zumcSupNvE1VqUr$Azw2ASq`NXUfQ+_KNc6ND6lsSxX+wSyu4gT>=q;p2OdW6%I(nL z0{7+~Jp>D0$StXXD-Jsx1&yS?LHp|iZ}MpFq`Kly&TaM{*n?wY=-}ViAyc4$?pgor z@A9qsd?V|gfuc1$0n@q+_D=S@*VD5nIoyu2(2+U5yq$F8>Qg!&l~)i3^L9K(2gQ$C zY#m9E!U_=G--h8bf4{$yy`a7V=m<_=%&8>U)>pU!L^1!%82y$G-^B*!e`GYDJx4p6 ze^!m>rYe{vOP>kak~eS?lV#srTu^+ zjkrG5{>@e7tN4Gpc>&n!VX+TL>&&3%p@-yN&+~6EMF8{REqIk08B2SZX_Vs_=%?hX zEeLz(5JP!y!V{2MnsH{$$Bc%|#r)2mJy~Rv?SCoJM9mNIaGPLyP-ys@gZY^R5ZWjW zk$jrgq0YdgR8MN0tr}c5r{Fj*y~nyPJi=qRe&55K#G!c~YM7 zE0@K!D^sG;(^b(dDs#r&R`J@u1c`CuzAiA^t`@9Oh&>YQIu(-I`t}w|hf;#)Qxp@M zf7|ZyHb;2tD)EKA3CsUib$gHG1Mhk*<=_3F(Cl2IrL(QJV1{~|8T0= zSllq-{=}t@6YJ;y@jI@19m=aoQ%o@}33lbc6#S;xZbdpDT;{!ghJ0N`wj;R)<4ZFM zM{;m5J}5#Dc|x#O#~Ye~;yHQgi9+qdEu!f5?Z^!Jo`E1SI8{(9YVU)yl}NbIl}8Vk z<<^AFnnrmYC#82Tcf;|hdtMIlAoyaQeKYgo4~qkH1mFZ7xl)O9WCd9+;Y>v!C#e(z zi0L(Eg$*RMxQ#sm+Fux#T~4tu5KAQH-~l&N<1E}x^Xn|o;&~|^7+jvFf`#gdyHsL* zFAr_AJODqXb6h)EBF&NjV9hMY8yKJDin375mXJ5f+zX(}1~!t3oIYbQbrfDwPpRo| zZ_QM%Val$d0ng7`7&=Gi>yDy4?>Q%6ZBD_3lExg%fQ=arm?x|M;&qvOU4RcE8B4Jf`V$V?N z1+f8#j)D;$Z`x{!-h(;mZe0utmt|FMSH_O$k<;>G#=6P7Dpl`1)2>&A@qifJoNcg3 zae@cLKof_*m+J|-N^~^M*~>ten&XO#y+5{hYj+G3)h#7DdW9)t=wd3C_G(Pn>mq=0 z+T0FlaFZ(;{T@d4u}1aqYc=y4sJdTRd);c-_#I{wJk23jDIAC*eYdqIxQxj4jW~Me zV5-t)It!zplyr>{;{rR-P3j0Pi_$?zyoQxqW~Su?Ij7M$Ud40l6^w11LW~Ll%yox@ zlD?d~rUfgPhAmnuOWkq8{`*3oe}y7r;SETiedRNMt-4=!|Hf3PTI|Y2VJIRMI5T-{ zCHXUk#Y^!}{LSQ_DlhOQuq?W|e3?ua#+|4QWq^^- zd<_dGN40UI_YyYh3h*br;NWc`0gH5n0xz zJjDHUgq;J7S|N3;~WoH!B1?g^G#2BKhCfw13k-9ztA+U)SM) zk_o2z@0p*{QbrIPVK?DI-lL@n8WgDC8_~te5no8$v4PAdid3e&&aAqos=oUX4JR%& z8)a|guQBn7Krut{rN^nG3Br)#;{JJ`OAJ8GYb(-dOwxdhXJR-7qj zIG~RSiI?HHAd+^b+?CzQtWycaFY?H8|CyjS{|B-||CR)6rW)0P7kW(VOZD1_@pg(u zDX@JS~LkWPdXk3*P7;>uGNH`er$_Gb+O;T5Shh-q1p{{Bl$-SY79{>vaPnw}u<%v%0865!NU^(|YuSM=j7L!4x^OguyY|8X}o zkGIh=1B3HG&Mu*}E#BoF6C1GLmCyLu3(*n>T0Zhwhn}i=M)zt+=fEL@y?n|PHr*(; z!@Bp#IyK%+I|;(s4n_TqjUrVJYgnnd2NdO?C?*4(K(qLT5)uAox3+`RApD2h^>)dG zmYaKIna<9L$6{Jr)L_9VKx$;XFTi~G-#vNxBWFBq>v4F&Uu2-cAe%SX)2|pZ)pfC zrVX_LHtSP=%#@jX6-$;NkjpX1G86dRM)TXKTjqABDD63*HiKlWf&bq}g62T3Z& ztW}3MT-1-BE+V;({Gqia{Hiw0u0g8{L3aD*tK2h#SkVv~YL6Q7g_I+#Gy_GYy)v#e zFSDl6(kj(HcJd#~Xhd3V*olo3*Wvmz)cnf)BM9hojAg7x97rDlGaVlA?0SlfP}JO3 zjKx`FQZ#5B&?y+_zHf!&IJ#D-85E06z&=H)X&L;rVxXr0Z+ZnbV6@Oy#k_X}eufV| zZ67_!-41Jt7YmZiNzIZ5>YPHD(9HdPDDU~iRcY&628)mP`A2i6ZO^+jwDSPp`h@>t!p>dIm z&u#|o#X@y3;xtVqs6HvfHfcu%`LcKtI@-tqc#T!g+Ub4AQzCJ)vV#+m>G z`YNYFxDt<(a1Si3_)qJ(a~cRSXnnT!hTB{p0UK?`nuF$t_+d)>h&YA@*nE|13^Ec{ z-LWB@$^vuNd@^dgj|}qo!{8T_=!8~j{Un%$8S5t_g}p4($hjfdAp7tZ-ApNDQDIcu zQE!|f?U#_*Ba<`pLd`#A3Ke)gu!jAXha?8bdt@7bJ5k`GNy<=7wO0wX{jJ*kaFDN{ zCyHOV)*6Mlw5MaoL<>5bj7Te8sqVqlaDwd`W;06~#CM+gycD)Yb-QkOBJ=S+Qi_Jy zepl6I=^7*`z|sd=(ZPP;!M-Y)kQEp~snbA66PUvPTQ1deWeB-2|C#LM6@=07EttYK z;}I`F-UrKHoBq{lfN}QoGg3-fu$SIj4zbgIlG()2k@Pyfmhi9uq~3{?H(WbNz40jA z$NY&JnG?H2EdK-T;yo;as7S|5Nn^9#vw*EUhs^S@km$u*N_!=C8yj&x8YCY}oCkzPm zu(~-B6f1@*|65lK0>0^nBZ< zfDMF_2-9H5ay8!|;9LxQ)%qkT;+BnAO35>Pr-IU-A1~IaSe^v98nELMOR=r$V84BM zaFv^dN+=x$rK~hg<%OKgnFpEa|WsKo#$n8lj`{a`G0`yedky zNLP!j^MGWLIUe3T|Nl|A>sP>HbY7Bxg*nRR0n2Ptv4`e`j(#ncb)|Bp>d%J&PblWE z8Nb1WJ8~T#^3Wg{rPff+V7#$vZQ@b6s*Zz*Yke(o3EyidtK!&Ru7#;Ec-x(llG@3e zbI!CYSQPi&Tp>JYkMuf6;wH02g;Uson%JibqfIjIA4XV37M8WJjE}!aru8b&Rt zUb6c>Z5g5i;e4l{NG;1^ky?IqBjJHT%u7iK6+Uxst?W4USVM44Ye2KeNi(-7s;jk* zk|qCohA}tn`J#{*Ux#pY9f24xjZ`&bmygf`z#z*Bh~y<53=h$>37ue`#y^A2Z5&Te z>{up*WKwG>XyK+t`||*od{5XsDz{-EwJ9FQ8QX(p2(}eXAHQnFO;NdARvuZY%nxWrC$l_$28d?4n%3hW%N>rG zvK>sVW*-n*e;$6=tO{CJ4ZJI7KK;?~P;L(H1!5HI$Wz1^=R&f$^u0>UhIZ@ds5JbO z7n+Q}0>vIt=`pkv&G+E)_%%9iusiFp+dsG;!&6qORECp*y~zBSGO4R?2_-JoF{FOk zeQUz=~2ds zC-T@!Gg$SFeK3^4 zwgOuR`{DCLZr*SCIV8aK+-oA;4mL%gB^{gpc6k-Xk=xfK?C-B1Dl?27Q!exEMd(7) zoL_6krCa))1p?(FxU8N)yK{gvC6MaqsV*Pi-tLilPt_iw5mImb&banp6jxrBI*ypg zQzcB>)Sj>v z`5Zn&+UC;7b__`2$1?Eh7Np@G;<6D})VT zWyIjHH`kxKZhrRcKEY^9Kk->bmDSIrm6NzAg{m}*LYL{@iTsfH?f(OK{i8y;MGK)L z@GJ8VH=(8LxH?t6biy?@wv=wUb3GmrOW^=t_0nj89=gE zRbziHA9TD}UD8b6u~KoLciT{U`HQB=nHo#(DeZu?6?tLe;M1VsVoCCZmtDh&S@KVhZeoOKUyJzUJNi6mi3?OpmBd)xNFQ z2D1YXs;YWIzS!O8o@L!83CU>RFt>KgH^0+b`X|l)) zVOO#xUm!RxnhjO9SLD?~i>yy9ARxcCW`4(dA!|^;@Yl7ijc+FJI)-`7PbB)puCRg^ z?+?KTA(LQnqdFt1up4GB2>$*mPPHm*m;BX6J zXqMH8*>Aa|P7zqoC+8Et+J}lWH@SVDhzBe~NxSliO1xYxi8$ipCx$Mro*rgblVCup zxTpEBwn&L%jr>j-vfZ^m{M^~=4=`FMxnpSh2n15uS@UWCd!OsX_79VCEK6@M!Q9@z z4(mf(>t6IbCbD4=m+}L6J+%bp#&*&p)WdLpLBwd3ja5e8Cw6Xih`+GD97EsTP1vL!l^+BziZ&F0LGu+S95`iEWRN4NjT^^2jHxs%=7fkwNb=@2Wt|QO&iW{K%%v$3 zTx^1$ozrLdcBI#;ubJ8p`nPEVjv#72P7^RP`HuRR8_H_M=HRDNm`%l|%j5t+x9+vl z6JcQ0n2sw4ZjL^7Egu}edgB)nzL7P@lGa-C7>@X$E)UpsoVwE|%qnjBQX?!_SMtS1 z63!I6bJ`%ijLHsIaiWjpIAT<7or4>$gq2G=V-K%Na~}WpgCV zb_6=g-IbKVasPgj%<2X|XT34uoRB1I-B39A%zkEAa3@B@9MN zho^MAZTn?zAMOCYlQXSnLAdeqZN5r$i{AD|g`A78Rc-GpilRViYRI2Slw$KBa{V~h zGhlUR3>(-q#!-$u!U?aU5C&feruEeG7<5L-Rp$kJ4(AA6I&8p{n(g{z8 z&eI>Cak8n(Vk5>p@0~ae+DW*6Wi#Uo5*ghmoN)FYn^;3rg^(Ua(cO%x&5(K(2Q zyuxA4zfsnkLJIXjz~Q*ejICv5ZFSeH5P#~|o5dfw$Alx=KJni@)#uJJuO9vsx0(pg zr^MMg*bh@XH+~xtxATq|uA0Kt!62qUpS1Yd#FaHlott*c(tL@@GzY3F4bS1lt29Nc zY5O6cDIsEYxzuaSVfjlkmRLeq;=rT`Y_xOWihVg%hMO3YNLHIkciTr}Xsh%Km(yoC ze4CKUby-d+Oace%oH~(JQs!E;yY#Dl-d|wt-qeV>l8s2h$Ss1*8C7JqLznb!U=bf{ z?kDo?XZ)f2i)Lcnd^+`d2xfDU`_FKEbk?Q4Qfb@s#FKu!_KM}~hdiCBkC7P@ggckF zKQSBxJk^UP9pb??$?yuC)OIV(eoIhvPzBAHVSaeE-Pv|xMph0^m${4Y79Q`lLh^~* z)?&8&dRf7+=}kxqtB=2YGSy03$B|vcUeM-+#Um@{5o?e~`1$IxrS9`u-oiGcgpHVSgN>uRIY38oort8Nde; zVB?`Mlwj+XKkgi)XBQpJq*zh0%!Qub%1d(bRQW9nXKzv}M{xF+h}pCRBG6!aflK1P zfNu+1gmG{wQs6qBwG-o#pTs(wZ@o#d!+1gBie@xUx5i1ce#NjD%5MYZk8x=al(;9iVC3-}>2$OUBtn8x|4r|*+;5{$T$tjTClN0$ZO z$bb)diI{Bz9GUnyM|x*5ki%;(aohfqneaiKOuug@#l&x$%Gl+e^cv|i{RnRu%b|cOG#3N&iLRFaWWo| z>b*F)ey|w^s`mGBO#L*&a%afr^EX^){&)Swu0*7Cqfh)x9Y(;_ zuGc9!ezJx>4R~*5CdnaE0A~vr+?ijy;NXN2rRnyao8LDO}~r+Tpl zxLLL^e8*1vU_l2-%VvGPKvI7oKD^Vm0n;B)4ag+4VVAv|b>`-s&Bp8jCRw3ZA5uO6 zcaD=VFyf0eJ9$!_@lak9%-B8&wi}$_iI?7o9Afn9NqtJHF(A@lvZS_uXr3&~GI(zg zzISdVbVlHW@N*2)7K&tKuE8ODPSZBVJ@_CurnY%leo*PN3K30eH_U~}Dh~rrj<=A4 zJDOSzMnIYg!(kb)KuFoKZ2xgiruY+HkhkO52TZ;jx11N9u5V-> zToni{?HF(FREi@DGMgab+1|wO3F8oZf zK*cn!u!EmKZf}yCo`UPEvoPVz(^iBNfe+qo(7!FGY2_}hjFe}?VQRPLNi2~l`(C!} zhw|Rp|1MRr&FN7XO5!h*CG{|CvGyZNj7ta1RPeA^3fki02&s=OFsb$jHGkQ(7bg8X ztC}CIYZFFvsO4*}8iJ%h-4559G6f_b^^j`bxg4^9G^98~@tnG<;1oKqwlT}lW$3Q z`$P-m21zbOmfASK27Q3pZ>l_4-DElH|2rlg#Y{{|q;Sz>(F<@|_9|$;Y_4iU{{W^K zL%;XW(^L|MjjM-YuEz`Pbw!fM3$#WotYbpNf8gvfvVB4)5B~_cP$DJYIvP4keFmpD zk6d@ZA=z-(p)$1rsu(b%%|WUYJpWhOa-L2UCyS^KMsH1z+tW~Lk+`KimAQ!MlzAxl zT2(tzWUQZpNKa{~#*wQ8E#ge8n1;JE2h4;U12-@yP!_h*-&HHPv-rl)`X6!pN&65} z$PZY_vKm3|+Vt3&b4rI;iW??~GFW06w+h?WKL;d#BmwXTMlylt$r$v6w*ye?SFV%)i2nO zRNGHM_wT!2qUzxFw6>LJ!79Sh+JT&_B#w{)udq{*$-wvX0bnSf*X58Yl}pYKNEum4 zz%t6d-oW?HRJ!m$N13~h62+=pOdnbM$Ns&U>>>o8ceHX zt;f`<>dyXz0~a5NPN)`bHAZX9Dsw^M^UK9{jLRuxO^&bEDkvlyQur{WJE@0L=jSlq zPNyUKJ*&TR3CA{`k2INDVbky@t zZo<=NoY$7`jg|z01o`JJ$+n*k#v`b!pf&@-8Z?p4Qn%O_X4h@SMd6b)dP75>XXtBm zK_*E#E^opBe!4Ofq2PR&MntrQIo(lkD>V~Bm^5`&4v;6KRU4u-^5cA32!V2DC>=mu zjnpeMXb1>nikt(SOS?+=whU9z*HUT|DTMzbXKMO@xRfnif2n1tS)Vp}C~c*#un=!t zJOGcl@G=a6Oe^l%STk_J0VX6f~|<8?t`bEY8dJE5wzB& zRL{vi@w4zI)Z`+%wJoe-UbCz3T0kM{^xtmp{}jZ9fI4<+?pE5&X%1x{&VI|V3F--f z|D!J%>;twGsh?Hj)nTk_ufwIq3#9fl&OLF>%}|#pDi=KqG715;SQAVhUc9E?WIXw& zXFE%6l;phQJ*g(a1Hu43lebb&+0F9IFnRm~YP5W`uHb>DPKi{fL=I6Ew6KN?LAfz) ze@1c3PGAKi$Te>RU84OtE zEG5BZ5>x7J-V`sJRWn{86*Tq_;j<~{K^LO>mygtNPtnh89`1Y(E**=I>s!+gVm73m zxW{d9rS@xazc-H`CAW}>JmpU2o6aSeY|q;>F({+#zDhRkFvRmy8i%yyi+FiZpl_UF zRIn^w7`dBAj*N@BQR#%{((LQH7d$iFKESpOLR|J)ot220rfHLH4q~(ajl;+$;&p_b zrQd;M96;F>H&N z>T&>po$WAK`u*)O3yCM|+01q;F;Mtw# ztdfWlOb`(uozd}1T}+h^wn0!$hGjD12IE0K2He|R&%(roXGOqO;rf$ERZQ3$AqV`X zmVOw~Z2?&^hk~9c)EPFE^M))2n=xiAO+)<0INjZfooE^Z=a14}Kq33dSG?ND(>6+u z7VNGC;N$qJBffdj@lvHkQ5jsOSHSrpX!F6p$1R)$0@UfQo4$Z^Ko4x%ZsnWFV}cbGJT94lT0KT$M3eg3^+hEa{CHJ!@J7Tw#ljSOox6KolrY*Qyt9; zp2XUNu=#k%1zrn^uhAIIACL%znRX6kYD0>Gp}*$L^&?3}flXn|%U8lobZ(!Ci$#z3 z^J;krGJIZV<$Wj*y_EIM*}Y4#qS1EO!`o}75di}sFtQ!yA9 z{LCqdS1499qfp_Ne!Eqof*#akCXm>2@Kv;`N5>hL zqek^ox-c>dEf9&>784c$T(kdac*5O)v?Q>4ac?)t^64R6Ky~VyjZ)(Yn??5~wHzMC z`3ry_iKoukVXql~C4~!JYru*qwCdc*q2Yqu8}yUd)1-@-2aO2!76c;p)Cju5g@+}U zlYnV-9F%#eYRtN%DmD`oQnVdD9%BrtJ}(z^gXkKVi_8RP55o%wyfntaEx@pP`y?0X z)Ejo^7P3H-c}`4b*Y<|D?6#kD@oHVZf%>>umfc0 z*LtHYX^BD#ZX@M6>Ao(RgeX*!36u_J`_~yTxafI%vHeJ92J6sO7%{jCA0?`{s(r?0 z;(YlR;msamXXu_-i53%_2n6#s#T(MvynxbRmLV{{a5bu*9~Do5b%<rY2pycP9E8*ioHUwBvMzML#K z__0^K`Pv?rHi^FHh43I^m}6d+c{a&T%!B5mrB*1AJ6pC?npePSgFLGVsbqx-7B>=o zS?oGF|2V;AcYW9Agku=#-hC#IFVpIfv?>lV9}O@!#*QbeE0t9Cj$L1E z77hZ2Ll7`;8NBFK3G%zQD-YHueZi+#7_Vz`fz5Qm39rfBCT#ge;m^Y6nSZNwlKlTZ zt23uqR4%Kn$lD-RGBH;=Q<=YRFEfqB;v+2&D?*0Ryj^SPZ!pnN$lAq-V_6oKMm8)N zODrQ!ItdeaI_Y5mfqGOGcMh*Ub+~+B$yjM$YW{zDlgT_+sAfIC5idB7yRdm=C4i^g z!9YOtzvNYF-cNO^a%zdCII^@Rd)LKE!8y zPy9z}U}C7jcYaLUR-Mz02Jz1D)}Ubd^Diu;8(f@oHzVgx7K~~e8+I4pu-xVya7b6` zySsh2;ovgcePrfT-)b=@kdr~g;HfI!@1lR{h9Q735H>}`S({7Fh-(^RoS86_a#G$Z z*bb$YP@nf5m}-+N-eAI+pJjdt{~2arAil0UtDpwL5O@J3t>g5>;IWB%C|xl6Dta}~ zLa~J2f%6O@Jpg1~6laX|LgW&Ov6HwLB8ZfdR|+B)W2BP8S*CQqA$0CNr297kEl(Cu zx@vnw%_$8JiYg(>a6p{T|0|p-miA|q&y-f%P%Bf+?W*}mJ^Ii6cT#$|GOVb#?7@1a z&!jm84c-WjzS!t{&=eA!tx~Qxc>)|A=ta)UJUFRLs!!MAtB1C#nXXSTa8a4SrOVX1 zQwFkbrbbm0Q8ksci1y7Hb!xhse9>y26C`FxnrPd_yEwW6h~A}Bmi^Z)SDnH4$Mg?S z+;DNEtWs_Dst4*DNggRvj~_JY|AUodL%L5RXySERx7}#SDX(YY7v$qrDxomT&of}R zsfZ!+M-*vGaIh7>Y4PKg87un}}qllps2lHc7Pzo`WxI3@m$#v^I}28bJFbXstV(F0kjDfEb7UP!lfQW-rg75 zjH{DYXJ6T58wRH}Ixmm^gJsrM;<*0v#-XV`H+e-w9s?)HzOPapdUF(k+V~5y~X|{#}OfmbN@pYp$x&+voa3T zfhV8Gy1N;Ilo?r_<-*P#BisL8q-%)!FaqzvI7x&8*za~%!YI&a#m8B`#!rMMglEsS zm%+c0*nj-sy+TGY6%A^U$S%}wB(wb6dBU^bWaq*-DZ@0tYMTQ}m!odIRRQD&3x$o~ z#pqYwouSy%f>yz_gE@M|O3Ac4wg>@xX{ioi7R-P?bdh{XU;G;cd3w)y3@fHNZgz5>Ys5yE+k1ytl|TB1Q^teSJmC9|J;US6Pdlscm%Fg4S_^acEzZc2D(ntdXa*j3S1Lm?E z><aKJj&WSsCn>(+8Ma!e1p^r4ZFz&hwg=|4?c>0?vEcE z8~nDfcPpdj&0nx-I|+dc!+&7G<~#*2QKZv{V+NZn57i|0F&^_sMjp99AJdRIQ9!lW z$4>(#4M2#Nd1x6-y0$2;yS=FvzIbSS_MsYBa{v1hw&g}VkfW6W9MPk7Z6cB7s|9Pp!6rg zcn)>SVD~mH7z(R%!ZX9oxexFI5q+f>;5hc&r^c=e8Ak0zEXn&!N1aJG36n?t@<||k zBz@BR6c9?KRD-REqO_UfYxZW`8**5--}}z=Ic<~J2aRsOWppT_cD7)!+{@{Q`UmVz zpv)5V&C!g+%Q-sllNvTh{aAu_PwdUKgLK=T2>_{-sDW!iv?PDS-+%57*mEfF`@+oA zouv+p)eHprn*yk$Dpjnf?T+0d3aI@Ri?`pTBbPNneBUMXnkuB6Dh}2hceIHyhe#US zT>#(V$)hUL4cvRL<; ziu5avSAE8(uBSAjvQ}3YcvM=Qio|CrGBv3|Zk7Y6f~CUjr>Xi(Q>arHfg{&u6;*AZ zlR^$L8+pxXGj#s-kqA%pb_B=2Us+wp+?IEy%~(y0)HwRy1zYQ`e;l!Xq(F?-vr>x` zUC8*Q6Q|*vJV)zjslD}rV^$GoHb)jc34tN?KlxL-6GcOlahD88&MQgH4Oy0%>6aQ~ zUJN{3LJ>#GLr$?}3GHH+m#3Jo?;;xYzyCFD@}*UoDBC zE#QyhOe&$?Z!;Pv3()jG`q?HY%`f(izAdJr!hSk)(Z+2Hv~;F>lS2oDQjC=4N9f&| zT{*lDC1aP9$m6d|9Td_!>B<{boHX*hKm&?$9A4dx-L&ez_Qbx)F*m8O5g>@Ns?RL3 z%~Eje#kq**N;6%>|9cpxa-e<;f=4(fV@2$?%U3tNKH<2rT5s^_2ZYYc*4m9B6yt}m zEsQQe+vDnO%g^=HcseJict?jxdXrf`;}{S|dz@+z)#zx zaX8MPm}le%Fp=?mys>Y_6Xa7d-Eyt#`9&b8Z@=VV@IlXsLsSe~p_P%ZIS4BpEQ46| z!)4CKzDA7g)8WG;>CDSJsYIj=5lTO4@jR!R!olg&_l=7k5s|$j-+@fj1al)=UE)^n z11-^{$L`IbVTe84A5`qisy@S*ULO874{WG-*=nNVrKH=M)*0$r=e?(%RyIiOk)&6? zhoa*-09-5n8*Jwa0BxKox*3+446Bz_4is__<*w)bggENj!y|Ez4Dx5`6CH^?rA~5; zyekTNt%afsvy2WAE93P=^lncKA8_n%x2TAxbG#a4xpho1&agF+qxKgv1#% zP)GDxdsy_Z0B$=X(K}43?UKI#>#;^vUkq$oop(|>8W_|@KNReIskq2{lcD_<_h~^i z**RdlqpLcF$+>?I8#_}o=ru%TG?BH#j49%lw*m^j^+24y)KR9=`RxW0_m8XbA~k!| z%X77*8-hNKDfpO|IUnk8zX)>Z;*VS37sY%&^f}9Eb_gy!kqgQa+|GITc!VRme09Q1 zJ0Y=MU~{c#P)?yYtD~#Yc-mC5#9tuFXv5ac2cO%AQ9oSu8bZt^^vl zoxks>!$h`LmbG4=F~=^rYi7BRGpcwq=&tw_b-^N$m3#M!r0_1T>A$iHyCk$QYlp z_RwOnyl_n|SNYpnBYeR?7*)T6-=_n_*dCMRBrce)rR|p0!W?L=m`E7vt3igkz5*Cl z!A63w-zl8~hf~}&BnPbiKCNB6`*C>vwLc{I8*r6oiCiprmfhAB7K!br%Vx{4(Q2Savfz3y@P^8AeNR>o{V(c(5n`RBmO$ z-_9B^kFCh65u%ZcP<|C)OT_}KzQQ!wyd2N0R}ef&(4>gDUhJ%r#!oGR$>zFMY&z>B zcp-V)N64Cv>7tWk!{q=|K!{NS#_Mwt$9q%P--K@nvX#Q^9%FVV+*Grnnf#tLG`|k1I>3-sK1txxPDT{TU*;`5 zyfriT9R=V%vowgXpgI!eQR`)G3gsUrX#A3=#1>k!Dd=b`SO7JK)ew$fheMlqvh5r; zckq6@Ak)Zn%=HuiO8fTdw8YQoE0X*C^zqr z=y3<`<$KRkCZ8W2`w$?PwFXelx18nb4fAduiV{SP3y4c*y~rcKCc`WE+%dW$#+D9< z8i0-&ksmFyUPS5@Ekg*UfvaI20P)%@=CHgTBd0+o+b96pBQY9=bfwqzU z72(ENCWYQ9JRk! zXrv#Qyw`!>@^^&VdYF|}a4$_FWK>B!HTF;DH?kFeH%u}h%myECTe>$H=kZ|>*-$9c zaKRUc`1)rT(k4H1QRt%%|4;vAS^hs%j}B@|<`*ohZcgAITs74~H$K(et-!*%eiqF1 zhuqv*8#|BIIgmHYGDS?P>@8V`Q7Ux^+Q>0hiNR>lzo|Mu_>W-jwR3Coh+iV4r)?XQ z5Ds5rvA}WH5gKuA(Jl5m8Pzp9hG23VW)z?)o|`QI5NWIVotkZb`;F>Pv(C`jzqw#k zvgM$q)u?KlUPl<|3EEK12;l9vLTJS_wOBj75G_xgz?-8^`I^1Pz)&|0erV#ZuRe$-xqpLR4aBu*q&Dn3lg=B|#5_)w~l zef0gdqZh86`QM7X=K@fd$h1)<(p*9Tg?|KFidV2?#J3`9Wq!Yg=xlIieF3 zv?>Ffd5G*81}uQ13_h#ycZyt{Arl0431+^P8@QjfB5Y!s9|N~dG{jyU{W$jupWrwY zOnV8Dm_9_@?*R#KR)^MiQwTisx8PR#HkDIDpJ#9T<5T!|i|eYkh%+_N-g3rEUIQY# z*8V{Jp0(y!pH^_06wBn^`nSf#89s7V2ZoV2i+O1`PFN6Ot$a~j9R@8_b5i+ZQLA6S z`e?*<+XbNNI6v}_+EP1FqfRZ9;e*7aoD0MNNng)oPnrB_q_LkZr`T*ULykpsl&{Au zGV6(+o3dI*#LGKeFtefnkefl4U4MO1x6(}C;*V^WWA_RANn;2Mbpa{3G#*9IR|SG} z`lp(Sz-<_mB9qyH73R>o8hVEjjU6=b!G6TjnigW|T`{o?Thl{Pp9$DRW1 z1UacKMO!jeJ80G62uFF{Um<{tgCl0$tR{Pk*uwg! zb;TBs*FE|X>DI+}I_RMcQm9$G;LaybVRk)`)$Yn;SsiHxRF_&8RC8eZ+TlNpyL>S; z<|)n8u?kUtv6A9QhfY^%bgBhfff~T7^lqN>mjI$V((TUrvXRzE4Nu3;t@ixFQcc*6q^S_J2dLMch(dcU8SzXwzhs`?-Dm|${7IE#4SV&qsMh1-Oc56*Z z3SUWoXu0g03w~ka2s`VHTi3~bSt1?D*`x}Nam9&_NP72055h;?8D zVejnXFpMOKy1-nqfA2K~xFMiS#-WV=%VoN7r_btcz!Tbg8AC{F3#O2Yq`)R&?*REt zJRc(N6o*+zeW@nV1-MTz=6%h31@D*C>ZN1rwC`fS;d(3B&S@`x)$l92!@NY|B^g%i z_Ix&tM1fJLDzvOeDl z3d8G=sz4Vjo(d~i7P-w1pur=T2!O+YL>;fS#Y?EHe96V`Ok<4?FuzWjxrdB38u?AB zORUTkSy#C9qveMgU`L&btGTL8KOyY(Vykq8TDP|6w%~j*aYT|NoJXM9Xl(+ZO0+h% zt^QNl6Cj83N!{TJNw(O^OPcQyTRj@t0h4!80ufv>I1E2dae3eVf6ULvMi_5HfUv=! zO+klDUoj{nk#KtwI!JgC0zt(&hXX{JLzmk%n(U^RtZ^p}AUD-j=UQ%;&F_VXKSQk9 zDGl=OaV?C46lbsbgCk9A(S!zkN(o%A+mI22Z*y3E{`a;nz}NEQo=1B7#94*c9`yW( z*Nf(0Lg#(Bp|~R_*d)v~7^)_eAdfzBe50uf%4TXqCb_Rr$;lk4I$A$i55}($ zs*g$Nt9pp7tr_eF{A5o~^-(iT%xb9c@tq(bGMcAx332(y(tp}nW~=5S;UE)YH{{67 z^d#(fIJSipBQ!Jg+6d0Q%jjR#)0s4PX{sp1kOPq+Q^=8X=pvyb=EuIf5uGi03(&zs z+ySQ^xinp@U()8mKWTXi#tCOGb>0=pzX-%YpcSnIsuD-0x#rdeXVcXZw*Ei#e~B1DCqGD7@wWd6hs3gWzhjpa z31NkZOn}L#_}NvpFb+~oisq6oaDxgG+SxaRd&$eaEEvAefv&)Jce>L)gGKRF9WOYC z80`I!&UV9&j+`@f-*I%(jb@d6| z3=e-m`bzr*yjy^AVc3H@F%b!Ph@#}SVx>c!PAHkVpxpj7`CC1*L_ zJC1vf5NG04{2W)ZaucbMg#I#1= z@$5beOo!=bV8rbwsC5i$%8u=X3~Aic+L?e`phZY`s)^?cAp)p1FPL&TM;79q0()|xwj+Sw_~@?!V%XusIr=Oes%m8hjcaB_4ipT6ejN0JC>{i|6>N6wi=)@q=SkRtD zaAU2Pi%XQqUZYV4q`mv&Qsx?aZ?Hqc^DJ(#%*WJIZ>q5N`GQ9`e(^wNFd68v*7KGw zT5XGZi!=*VN1inpP= zSxF^hY&1};K+#il`bwb!5mCxo*dmDePQ$nP(qPio@2~Hkuhi+Wtqcd0z7%whj3R!? zhY7Tq-CYnIu1XflAB?h1RhB&4f@C;Q^<#!{P|lvm78`Dqa0e_*^OOlEYu`#XEFMr= z|A-jM;zSRm3ID7>-E{XS?)kaPL9ej5y)9wH6H>DKWvDz07k^#E@()pUxku?UjiVg>QqfJ zJsKY&p4hQ+p>PJ@7qE0*vVM`M&WVN!r2CJRB5U)iZ8E-nxtkw!)>d?*VqeDu(ivPi zRNM-Pz6C-A;A!KhfMO|!N82xaAdjRO+%$0<8vcG4%x^?@{i-Oddwd|ag|Q%o7s~Q# zOt zF~XvilCe_@8!%)dY}$+?Y_+4{Ryqs#!SNSwGz1@8+D$9&)GHnAp;22LRa1%j zYP%z^Cm*NtF&GlR@^0Rr@Fwz41fiCy3Wa>4wDd35To|on89qmYa@BzQvnuj9sQbCU z`N7L5@6HL1%U?>sTwC^Cxtsd2P1sH`Ra~zMCa|ls5_BYQBgws`^7FmZjji(J00AK(0TT@1fT1V= z2nqpIj*z|p00jXV2LJ#7000005g!0-0BHbX0Brzu0B`_d0CE6x0A&Dj0C)f{0AT1_1ydfTV!{03*dvApigX literal 0 HcmV?d00001 diff --git a/src/third-party/win64/lib/muparserx.7z b/src/third-party/win64/lib/muparserx.7z new file mode 100644 index 0000000000000000000000000000000000000000..373b0f3bfd365a7e92dbe00818d0e602de8a11b7 GIT binary patch literal 404454 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%0Ae_R%Dmu%uBR+&o-ymWq0{MyM-VBUl^w=EBXZ- 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⪚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 z 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 Y3IPBB!lWw{xzzy`1_1ydfTV!{07_5w%K!iX literal 0 HcmV?d00001 diff --git a/src/third-party/win64/lib/muparserx.lib b/src/third-party/win64/lib/muparserx.lib deleted file mode 100644 index aad816bc7deb6df77048d819ec9915e7a673cc71..0000000000000000000000000000000000000000 GIT binary patch literal 0 HcmV?d00001 literal 4002360 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 z zd2^tkxY24LagW#axa~mV9yY1~t7E^NmiEyHodgV~(nX2B`|$8xl+$&7$1PH4+`iZ6sPt?*JGT+pBecNd@$Q zo{Xfp+YVPuY%xnvLlEAuvE+;x1e)|vwL|!=m@bgoIMP59UFbVrfERi zxrpT3GMsrl0>q?n5n6rL>SG4kbg}?G3GP}zsnRugO!c*H$+d(Eq(1=cVlJ(nP`AIw zk=5VdkyQyqCWo^^tB)Pd0Ee?Dq8$F5neK{cu+$%+tG;>dUpnh8qtn zvswc^dJIx5&O!agNpFgoTm9m2j)!97q1gD?te8+SiR*>~#*3#O))t)=8yMw$Fv>a3 zAAfK2p;9uoBxhbB%;;FOBuMelkdn# zkJcVf>E6dOe;&p>Yf!5|%izx(PSl|#u!5>SXAhL5NAeX*liYnh;u9@FeQaYalX8Bu z{FpPw((J&a_0sEJu>|&T;AYRG)zYhgXslMn@KqXQ+{wP1#-x?mlt?BC%j^*^{Ua!_ zex{k_J|HoRp^}R))g)UU;E@ddQ7JWj4dY!h{!rVgsO?m^VJg+i7-#Be2gU&m3fcL{ z$g=A|M(zt4H-jvX`=PBl5_26{-1obdE<~~k3j;-`6~iV(T(JaoW1$zmq-0GL&A=?7 z=pjY2P6+B$2R}7C+NH*(x7}_9q2_hx$?HuNe&c!W7pwBjg>JnC?LqR|wR>IIXP zTs^&4EE5zAgxENU4ZWk-6W+we6<|If>gwse=+md}Qso0@c0(Pp2Pa!Xd1iwd8{C-a z{u`k&gh+E}1tj%811PvWb;0w1HlYhPn@C4#B7XwWijF+N(1W$FiDtHv+8<~)$ED$y zmMMJsVf-DILJ#Ac8POy7dyL-D(Rv`E+oZ>B(a|v2bQ zMDtvsJE5afI?4xnmwB}oTx#>T!U|~qGI~)X8_q+AH2)I4gm*HBYcEzq2RRm8%pqx* zJB7+(Xk4JfnGE+Ri)fRh)n12lQ3(08Wh=EfYL;QGesNvJj5s7~U?C7jEL>=vH zW$a{u<7}C;;*Eevb!P^A35NC6TbGol1t50Aw&F6#>puo0j!ZLe zLC1AE+VsoApRXwrzh5zW7{AltGFXswEeQi@sV)SaxFSPjURfz4Dde^z zD@IHz^t3%C+0s}m*~3A@1^Ppt8K67v5vL6+7y@{};DLhr zUa^T4NE-&&O=Z!3!NsG9FX5_|2T~4rao5n_B3*^F&?`QRsjJ;}JpzxTA@;1ny5I6N z)ng)R&+1cbc0g`sSwtR4obH;Zr3f2JwIyUe(%^Eyi+G-E^f`>2`wSyy;iCb{3)B2H zG$z8ilN~Y|*Eb-`;E)k;$Oz{=f4gPlua3my#eI`&v%nnX!Y0P7IQGl{w|+DciEz#u zO_S-tCpHc0Fs)S2_!zcN>9b%NzF%TkwKhg z@c$(rb?rs>hOM4byvE^7vBGmsc=MbqjzojsT(i5bMNscx&l;rr4NaHP-*t$_Gy{Kl zfJu$DXZ7~tH_JdsobGy|^{@Yy-)zzRW{aoaa7TtUwPJml?k~4X_m@=o3#L!rJ2lN; zv`#HG+~_kS^JqL5hlv9chlvMrkL=S;Z0u+pjjQ}fV~{lu5m?g)+?@9`}W;57PH(jG-I;L49eLHbLd{l=tl9# zRb4lYRX2@cvg=+0x%(#?eIzwJ&0r)hHlk`PHL_(Ri#2{&tif`mS}al{97;5vrpu}S z;31|PiXwHp07zT!kyVFMha@U~sSh!{3>oWQ^23OeLMsb1jO`VpGp|c<505#+fRJ$S z&wlhoz!UeZ-rAf4)9)~vJz$MiUo9g8ph~;J0Q|g=O3w@276xOT?^fW{CXOOJcU#no z9U}MKAMLW=h-!Smk!8QZi@t56^tHF?n9=m$8O^?OC@E$Mn4_pE0zCw!(4yQ7xJB&9 zJZ(Xb23cuBbjnSdP?bJFG}V)r7J4d(IZzqrYWq@pXWIIsA{J9E?wa^^m<3_#Z8(z`_vZeHrB+ z3DO%oRa&VcX=Ns#S7z8Eb60y(V9O=)G!{iC! zYzM9?TA7xGD7Up8u9={%;pp)F9XEu&ProP<*{G`AeKDiQsyRC`c9h}AYHy4jm>k*Y z#PxJ1-rp?{s$kO9O&r;bbp^7q=B^!(CeAkmNL)^`yk<{vuhjY=^Rz(@mmTfZpN>dW z#Ex8?BQelnK2}f}IF_)hTe!na7wGEmXngFBDn{ulf}U2_U>orBC6<4!a)WkHNpVj9 zjKma-d+3KK5 zkXT7XN<`K|iitqVXrj-^oiB|lt5>E`2^tkFoO@TG@;s;S2PBKM>=V#K^9j9D<5Z=# zaJZsuhFY!drB*GEZ-oTiZ2P;#;+ASQj#l#bb+e(#_lFO{N3a*)3rod!c9QW1QDK^> za1muCQNhaHD*T4=_?B<^=0t=Cia;RA#Fv-RjOovf{riu1Wrl^vI7 zB1)MOWsgevJB^#W%bqbG%oND2_GgeNF+z$o70zAru`WmyUB>|Va4k;&(zM1PXVrR; zhhuf0LgTqf+ucKSn}#`DMw@!C?3W?et)(<$>DaZl41M>RP2!DsnupNIagN2mq+#20 zc%ZD}qf5iqS$c33y0IGB9^DussjC5PRt)He2eT+`ZBiDoqS33_q-%2>p?xQ0LhHxW zH5u(fr^KYg9|R;8nx>;%An6Q0)#EM!$*6S|NV8wY#c=nG!G+UGa=ynE9aQ{SN5va$l_k{=16I9*PM90gBJNyv&3ZtzOoa_u*?U7r zgYC@bw9jd$eNG=*e#R!J6Z@Z7>7~Rf+LAP{Piteh8o=5?p0>8EKfG&mCvZ06s>7D0 zCCF?E>=S4S>P2%Gt?Ms7hoQ%M9$M~&$Q313tf6)&czXgW1>yjlc$reB0XSujs28p{ zK>!GDifC`!4}6dSzKQOS*86E`e=NHBu?`H8IDuD`*3aS6r)-$789Fj=Q?`D3GjUGV zr);*&=Grt!+swwU0eVHWkdM<_7*?V%k+ji7vYK%w9iUe@tzN|yw5Ah*&0XEO?)*@9 z-TkTFu%V#WUCDiFdVHrTIIPBvhE4-eTZ)7E!$#(fg^i@8EY{KUKr%mk2S}DeX)Q_G z$8{j_ff8$kHnBhIwb)W(|G|7#(rO9Bk+O$lv4(=a$P$EM9Q_f-bFGgLyPN(f7r84# zV?`p+voDIs?7&LU`W-e`reiN~9!{xUOB)#F8iD==o7PdTNmwXMLkH5~+q9ZvvOPK^ z#M0595rI)zy|Ixq!q6e9!#rd^cnM@t*A$C28{`s)9g04*fpOr`2h&6822bZrat#l4 z2Oh1IUSZSNf=XIHzG+MW_Az7&1B)}GsX^FBjvSgd5QUUVnW7^qxM%lO4bCl^rpkmjGVie@~VAqx{|knz+QF`cHTKt38U6Ki2J z(Y~VS9CZ2sETmesj=hjJybzm{)+X9H1HG&)^+#leYYP*~zhr5`%u5s4G(N!mw8VKG zD_XGy_h{rG>mJ^*O!{?AzD!*rXtF|65}L5wC#O@3KYO_+Ets&-#D)2bPg=w~Q`vrU zV2O<%Pn}0Hb-s42kdDl=!$CaPJYGhejBKZYq}BflBz=Or+qEJN57@Dyy+^kj?K)*V zs2;Vy+cw&oiE<7Nj&hE-7GD7gXY*fh{%!!^(`ha|D1BX&eH2{u%7uQkS6jlVfq1EEHR%-k1BkZ-f+Y`= zUmD1VV!q|$D0=A)7DQ;1j&gu(IC_F3(>VBw$x+t&5Gy^`FStnCw}!o`=R?BqcxP;@ zi$yccSZ}(@&?_L%vDhJjS+Uq0h$-Y&img<7%fJ-voLI=4n2}+!nG|E==ADGD=yNx< z-SvA!yZh&Mx4TZcdiXBRnfuU~?2LK-ru1@_jr+`b1?5}-dFFkNRgUooaOAj8AeAj^ zU|~^qHgYM-16PL=vkw>T>(F-g4qfhrU!i+OJCkMcm!wP9lt7%Q*7jNdouV}N?cwXH z?6epU(_Bfb&huWYewaoMVY@6S*y4}p#?YHDdfD2^;&tiei!x&^$xHD*;o`mTE}jL& zYiIYhEN%sG*X7z589NP?5aCQ35baEg!}%arIcH>!GiEQM4p=rGa3mhn_KhP8k=aqH zQ9av8*Po~?%MEqks^ zPgW6!n}fRat<=YnDv!J01IaE}8DuHT{{cX_2}fi2 zx9qRA0TR0LKtgu`=ws0On#y5$Oj2z?l1DE+?r9*&?K2=58_xmBIOyk#&-(b26bsN& zmRARePSp6C8Uj7Usm+1(Bb9|HD6aq^Ny{1MzyC>Wj#0uM&I=M^jj>W9#Kt4JWNyVI zXd5FQI>-`}r)GDGwP~knQjn#4F$(8jU!sU&r)o$m3|aibjgK5jYm&G-3MJ_1XL+1f zoGrU@ENk{#GF}75!!E`&MMf0a28u-niUYt`?3TbWHu@dmu!LT`VtF{!5{jdE58M2& zScaVk2*zJLZsJaXDrkg*ekakv89WG|c(h6SgLusNNKHWycV3=>?U~)Pezx(&D1xVNc$I?{zv8gB;0od*Qppty`jeSIv8|G-^Fdw?rU z(hozA3uOZd|Kt?b^=mi4m{WHy9~9 z{M~4xkCy1PiVv5Ecs$u&fISGeHk^C1mV3NWFR}w(F)6MP_l2rxhVC$m2$zPiZx}iv z_MQcM$*cGzQHd@l+I3(@H5efxt7}2Aa=SImTokee6gYJ99xfC2FACX)EBXL*WGJH} zYiURhZn!>l`G&Z|R-{TVMzi2t{P~&&;aB<#S_?eRaSil-r3H|r;?)4Ho%aEfo?{$P zA@8820ZGrX1gMCmKA+iY>Qe(AgN8qr^ zlwvL3Sf%-*vEIZK!`KR6fKgEE+-|wCW+B2@{p=XCG{;C)Dcndg??khU>p=|_hoi9c zH>XSh1w+GeFV`a0qK=5ylYD@-e%`Rv5pfh zi#K^FNO81ss8pl28SN^J!Wx{batD9Q;+u%Te8S!VbBe_manq`3@yC`Ywi2SIG=!hD zdESBP=6;@c`q8{oANzX;+GSc|=XnW{_}g7VgIBC+if}X~$~-90E>jFlEV|Rg^sS=( z9Xii`wxD;hGT;E=YUHi-%?Iv?I9dl)aYq>+b!5y4=2vq9qg^)iBz zIJN^(CnC*M8tgILON0FmNNcdJB@R&P!>~T!QknEvt!ZX0N%lhff4{+^5mGZ9M$MKQ zEHz38?z!0p{j&yp1SQlO>|TP>U}?F&n6smC`ocoWvGb8m4Ym+h6<4CczJx@*!9Ix_ zYOr$?xUmlWZ?)4*$SvMZU;O{CUA=>f^whihaY9e>0b8`%l6)5+~h+FGx+ ztB0MnFn;u#E&D>@w8(3tg4jpo^@W!5v@;q=*8kk+ap;XWyy%6KHFtZgrlVSo!zyMV zB+}svb*#pAZ9gezrC7t#73&9W^aEmc5QrwUb}48UkhT)3Z|?Gko>;*)OTPcgc_gMq}K;(^4UrUQA_l-k6nZ@T!vFxbgASSA=8 zSjpBh*ZhGkQwb?@W~2_#eD>EcFY-NYol>eqvb8*wde~ZyeQ3v4{&(s5zsU}++&o?r z<@L}BA)Bxm8Vg%F_D6=veERtintI49qz>o6@W@ttpxWxlqW8T}`x$(}gegp^2yDah z$^mf|nipBoF_`GJUd+BQufo!bmPRX6VGexAB|1wxl|8#6+O!s_-tVp0gm|=X;23hj z$?fz_5zh2&_^^ezK;lt{>#5I0G4)c3VIF7G9OZx(r@ZN=KdUl+c)~aJ_`e<+R z9IipJO2uLl3)++*FQ||8fI+Aes4hGOfp}i&ZH(E0T1GW%cGTW|73CJ?IPkJGb9>m& zdlB$*aIxdFl^~LG@YH%OzPCvgFQB533 zQx|i6&2qYv@-U*g`hvaG0(hSg%Z2TrxV+P51ETl9%_bTPbur~&)1X* zB)uJN;ylZ7v>+r06!!zsyJ@~A+M)U#PsV2cGSa&Clye>emaq2+)*5lNXdg?f!>a0r| zP#sR4si#su8p3f)^f<~>=r-zc^roHYM`N(09@1040J@*0e5c110*O{Mae5thSd#>L zpAl)^lsV{&CSi=40!fM50zJrav{E5)-GEwgT#O#~A&~47768e(c@0R$AykB#*JKrc zA?qH{;4qguV(p5wX5?cRh~D70{)L_{?9OlSi!_W}IF{KERcLsFzqm|)$P9$c>sZaE zmvGJ#G0kU&=hX$$p1L|5v@EKGRIjJ2a4<%WhFJo;+Gy|5vbAe`raj)(b+pqy8e287 zt*+4?KQ+Eyw9)^7@mM{dhQdC~U;i+17M&>*;mE^k$3u^nqaq-B57bcG+O)3N>vVM1 zPbMmQ1!_~%(#Yr|84E6^K(u?Us>FhF6fH2|Kn7l3k*|W_0}cIEF9+O1Jv6?7{4pYF zZy(cLw5xK23tw$R4{k47{t{vwE{~N+S%IW4TF@GYRn|CY(E`M*l^g&@l0FVVByWoC zpe+*`0AvX!Tg`HDMABb$D!>3(j?NTh=Yuq}*lOk2yIi8I4o+=}66iy&hAujq2Q-Zv z;=4f7z0o}Aoqawy7$b>**U z!HN8wnmI31};d;cNO3NZKfEQcD${1Coj> z0FsKk3M3V00-uX{X`B-dI_V@F&47f1`c18>J@$k2MK1k$^>hQkt>Gi0xC`z4Wp}j|DTCkUdVHMJQBa@beN2j6)`r=4*NQ%@A z*7lD=L+WEJTf4=hEqwuK%iI}q99Px!usRxu|20Ox^;l9YNZ5hljA|aQ0z*GwRrAHgyvAjbf{l%2Be5i6YJvj~MDF&`}sNJWP)X;t1V<#1R$(Nfo{cBrdT{M+bnG z!E(N)d>}t=^Ou3Pahw^y{v1c`JB#CJ(OgEy#y~P$cLEaUhyW7j=nJGfM+!uGx1NEh23k%chZQXda$-_(~6{GBh;>qREeOcp*_ZPUaAC zJlGqC7d}9~c_LOTB%NNp0nO07ieS4TqJ(CYqQT6*8@}_=tSl%@j|QasZ^AKoVrfbG z6l1LcidyAa9~MF(uC;gL7EWtrP74xV2d=N7C_?o-GHPC^#qb8 zMBB&zstMhVcg&v|KQ$Dpp(}5J+614v@G)7?8L^TOe@->R11jEAUeA-SsqD z?;{J|n^RREhnE8B@t{~|X4z_wr*4RjI~)2j-oj177Ovjc;Mqa?G8%IDSXQ&#N4url zC7O?*7iDiknidg?6L)kAzr+EHNeA#j41AWP*=2r9T<>7f;d2MeS9F*5WIC{0!QncF zVSz^!XvI%Rj-vSRK*%f0qnPIzQk=qu^Ycpt|KjBPtB|W!s{hfO8Uwta8!hqX*gror zs=YCQ4`mo$wvYvw!-Jr%JV;H|Q7+IvxR$TU{mR%4#LeM2@dWxpAl@9;KOspUPoCx2 z?*0tzvFTIg^OfUor8pK8@h3;|mBv2quQVRH+pjbh(N`L^C1!k~(TNXK!hf~}WIkMYia(u& zv+8HzkZXyL*0T-|`GHe#;Y9301FClMCY2=z|o;&7G%zp?OxQ zBJM!XvSKV6#wCvGnw8AB!mG z$f}Kx6ywN|jA8qHTcO9o;RybkFuf~9>nC~9Pzjk>vBb?E)>NA%IzbO8L)(dclc;Jo_lWcr*_eowsSb~31O{~?DK7FxN z2=g2ru3H|zLQ$?y<*UI*w66y5FY(o2>h+Z2UTqRQ(|xk-NypT5080S{8jM zN}Qz^(35Uo#s|6=+~EEUix53;MA4^Z;VBt8H~1SCcn-lgyN_bb(H&9iYg-`~kxgsb zB6~qXaM5q{DtzvOs9@T=&ZC%{dJNhLKJq#&B$&?44-`+p*8$4#yPKB9DNrlpR#AFY z>W_zEg&w_xeWZOjpR;w*BrX&KAwCv>j|2Qg?`RV#kQSdfP3ToVX-A zJ_P$qv@1NSaS>RfED?V>GK#FJe)g=1)`I)csUvhr^>bu3=~7VnLvgdeEE%UzIQqI1 zYUDW9T+_&haG0iUw(* zt6K_rOWYei^s?`MY`&*K8`c9!83!;QI)o3;if!ma(y=g*SHr+k+o;5i#Y!RBR zJ={^`PpRb@yZkeQTIJy05^>bECy&)(M=81SZyy}(nu(k+4YJ$tHQFdwTWwb-AgW!@ zM-WSmIF$xfEZ~vA+zNt{@d1Z11d! zVbS=0c>(=@3iq-k2)UN_4Ko9NoOZNlR&5KX1X4fg7=MY33_XtNze^blRekRKRf0LzkIg_Pj1=jFe z1NVHLTM%*A5^jSfXdbD;0-Zw;anutI4@*QT7F-wVT!M(}{u23&G;l1^IRp_$(-It9 zQ5qMW6_Yv=L>#T$nvE`R3g{V>*{0;%diS_3)@!wl&?GOp1fjEY1_ja(%GZUS&XlsY>herYbEf7gkKE z5KoMc(~lN1^%4uBGSRCqW)qkAoRnB`(4Ejxi3L%Kg@dS?Vsuo&o9wQrNT0uLlAMy@|sUq#e!?L&LxPr z7P#~2C;cqV!cfLB#c>J0DH6u1YOjpVB!5 z5yxug;8v52WCX=QsX|AsMi8|c;UKD1{Hfqg_KPB0BT;gx)wuI_=OA)P=3*sOr!3C1 zmgNRjEknJb-hGn3X()o37XjX38WLn2X`beEk|v0F-eSu7WuK%q@nS*UTeVoaCyp)5 z5e)P`Bbrze3CX>mbBLi^E$jvx##lf1sN7v8;kr`SND#@V9XzwCMyCpXFV;tU&lW6nH7LCUvy1O3y_Q<&wjcRPM@(OuGhZ z*HG=M%Kb5OP`M8?Qsw@;t5SqFrogT46(4CsLEY1tF$xvrqQ?^-IjPie8%EU-H;xh6 zA&OB55WO&IHbnppVH6FNz=+zaAo7ePjvEa$hS3BddSk+DiUT5zXd9aXJztR}eDFi@ z&2a^xiJq~@;@h?O?{OtfA4DRRjI^T?oyV0*^arlgqG%MQ`=@ZF^s~5<+-hL1gnJ6P zESsbVqM8vzwIIlXjtvc3w> z>yibLe@#E5DEH+oQ#R6Nz*1FQpSYhy&j z0PG2ho@CQ2w`P+K$QZ(LLsIH7FU?I!HtpvS?<)L}teW@(JBK_Zm|1T@BwG;aEploE zphs-!7b_f6N_UUwwxv}O=$vFDkwKREnRPbySPvRFUSOSxLlAKkG6#<$X?{$rI4D)< zsJwzmci|wamH1P^o9t^MTO(0&i|6moLFAImSCmj(y~+JkO38DKa{99m?ToANl3r3l zRF*QxSes?yxrBn^pj4rwk_w`d3I|cm!k-G>Wc!P3jYP?%lDhME=OA)P<_;xPr!3A> zndSPFGXHu-FQp(V2lYW1vuXyIYNnMp)g0|_syU#XsU})_&6fA(Q+BFXB)mqKAc!Q? zWC=A|lsDBKP{&lO^?jzwKEbAP`DIgl7*UHK#E7&N)B}iQ zsdOM4bXo+60!6J*s9l|^IgPS~g*+L6YBsJ!&@ zzCQC{jz)?cSJ9m~1QACY;qaJu4>oYE)oVf!adq&@6=&djP3ICsTz28A;A^UYLETTA zuO=I~Ue~z<5myi9suAjEsxjJPs@A%)$!|rO6vfmPfGjEgM0M4l=_&mN{b=D$U9upO z9K)34Pv{tm1tf5=YFDaD;uypnR9_D>Qgy45>Hb9gEjUN&8G0}x-5zGtNh7EIEs{JL ze@NiN;Y#ACy0-|TG76&H1(oI*k_+h|h%_I@`UcfRdv0C9RI#6bO1XIVxIxlo+#oHJ znHIqGHvMQ}9qUd~1(DQIOi30b{f$9c)T%`)3yxst|X7b5#3ILs3d|)vyRB5d<0QBrm!xat75B=qQYCO32_M`uIbEmcQ(ynT9Rh$ zyVvVd1(DP_OzF)lOS9=?%t1DFGV-*kvK10djX6iMt(_6o_W(x9%H0t|Asc^4;BZX0 zvLLdupwg@?(kVwlRI;V4U5)mYOrgmYO(CP}nXCh>rrNFRnk+swP5y;``MxQf9skfs zVa1=c>=2+;%nx8nQ$+%Po3*E$1W`^an9|!wQ5LBbLgm7KL>$jC2ifoiMy1(MW8?XL zbIzG;8Oexj8OMl53PIG9lC0^tQlNPXDSr=sKx&G?Rpmv`b}~W;A}b3by#!fxRGQ^Q z7qW*SD&5OmCL@P&To6r(LlAMi&Kxz`RWjX=x@s_>zNv2OdZsFS`-UuY(_u@<%jOUZ3lAC5Y-u5a}hzsw1Q2jbpgzLi!0Jd+g*g z899t~C7Ke4AmZ4=96`apreLg~s`X+d@Dqph>!jbOOh@sF^rMB1Yz2}ih$J3hN~#k> zqzU5p<&N+jMTlKOCBF(;HN^kvXIbuh!@~^ur`OHDNoMoiSqLJwrB$}FV zj^tNe8IhI)8PRhKaSq3o!a4krs%A~!4!DAl{~Kpq_z;WA={VBFE`q4`1d&#PtU3zS zQJ9X5{$unw(ULS5L>BsyOIaF+l!iD25ywR%2W4uiPCr_BpUY1if{5daaPT}6KC10I zJ*rr6-L7*9BCZ?E#ZQ?7{Fqj8P^!?8?FEsQgoCJ-;!g!{vTuuQ(g-W@WwEYdf$93xg_&9{HfqgZh$VAsFXcQlPmThnYWZs zT)oK+WVtn(l{3{I-4Z=X3sVK3W+vl^JPKY(HjrMPJh3+Okl;>8Q{e->CIwMR?`2AA zh2-Afat{nWQ)eS1sbXh5KFHg%1W3ZDo?||wSWy&6i5(p z(7ApyKP|T?)dC%K3-o5x5`0wRjkr?Sfj_!Gf~!*SB!E~z5S2&}SwN6ad0$icmSqdg zDN_DTsGi233f^S57ui_UsEqy4ve+3m zaut^<{8Tf-MY1m{;kbH}Zxi`QHOeLb66)e55V<6i4%e&TO>TExE>S6alqOf~K{5mX zMs76A^|{B-bPt}R%lGqMOSyV238GT;6OGDZkN6zf&8-!s3LV7@qFNFTqg@cGrBg}V zvg1TH*HQ)4Qa~|l7MChqR7=9;Sxb^$T>c2%nnrDk(+D5sC2}tUl`~k=o7~a5To4zl zC7~{E8Lu9<7KHV%K$B%^$+>fTWgV&*dTL5hP?g^tQ4h;$SV zqFRMN6}-u&H=Hn<8~Pw4S8=JrPu?wDB%3@@1#j|~i+qq6<&sr|x_AjhF3B|ZLEhv( zqsyh-l|4$6EB5g0gS^T856cb0`~G!CS1{E;Yp;f953K2>P(Bo>{O5TmM+k9OP*m87Z$Mxh*+|=YS}76Rs4l;ZIS0r~9rT@(V$w zd928EODC;2bIzU~n~oF}KGw@Bh`6>fm(gPt2c-%f`IaEkOgMkxJT%bFcwX?0j4)yo5hRm9KlPAo2}CrFpH$bW10#f8d;Jv@CD3j_!n& zxQFvY*7&XkN~AU+dPU zig?~En~x`scqD0I6l9WC?q^OMLeOk?N@a}nqrhT2L1eq~OnE2Yvx15Om54a1=(fY; z8uF-wl@XkCB4LEB&m*WvnWzP3!fo#v6&#UK(KBzrJ16pGE=be zuiIwzben|~vzbQ5J$FCOiFAr*L_1()fk!o>6S$IM_ZYPM0az>|h{_>|EF$RcO5ap3 z{V;?4FIW>Ql^`np{r|Z1VS4FXm0J3~dg(_pQY(X5$dN(;{z$P6A1!>XOA|yqw5Vvt`qJI6a}Q?@ zs)Kk&6pm*1cj8x396Q+YCaEY<1<#K zVwHRupTz<+Z<)+Ilv>9y?0%zLKoChE%amjR)xL>~0unfcX$^uM` zA9at+IFQ`ooHNx;A|vW6X=FC@S;n!99!4DT(rl8#oA{$V_u&r&Ch0@4+kqRE$7S8F zf~b`UBK-tebrh;2qy3v9Rt3@1tud8%2A9&v@qi-7Rdgo~LBuiF$ic0%o`Hi#E$MXy z5yzqu9E}Vd-|8HKh+_$J)M!!`dnH|E1W0kS&B zD+wZwH}ulKRjl;N3M9Y1UV8dOo!QhMag;t5R|?DUNB0MDCAr^e_qgzf`Nax1*&b9f zL1YC%Rvj7r)VS{>8n|^K%{Q>VrE!R+#36_{wg`vE+VC`_sBlKNsUYIo!Cc0tT*X1D zLPwqw z(pyiZ20g3BuG;Ev%t7tu8Y60R8VO&>{xnOM^M73!bweD{jnoL2<4W=2_vW0`>_E!}E>`itPk&RTNT(YH57tcZDlFVg)Be$h4 z7ou1;T}zWIwjh~n|3+>&%k>EkFa@XinS!zP5$c^%F%gnPz;nx!OFkVyHQ*cbC9~3=p6gS;rDRe5<2hFwkTHbghU7J1c{GMnzH2lR8ZAj) z5(JT~C-6ghyo@W&<#ymo^bLTepOg;@%UtVTmPvUFqOuFJ>L^r4VLBq6M4vmqo8hiE z;!r_2NlQUg3sbo4ckdB%n4To=q+)B~2A78<3nIzWnev}_#C+x;t7I@Dt2h~vC2_+R zrK`$XT~#`1K!L8ESSPB%5Jn+Dck2<4ajrIS7z5do0s|pKvJnL<|B8*M)Xy;o)fQQc z5`$T8jXSQ&ysB%|gIKh1OV>ycY4n1wkgP4O=yHc$Y$Lq{Nx~*fR^rDiAN7V(Q zSXy~hfgW(BwF~m8fKxwR%jK6nYSvHv80T((>beS|oZsgB>fu{dz4lf#bx*5cs{Fez zpMIcR6gTzR!b3U=qIDYKCMx5JW^ehtEBSzuf|5(+bL%3A{9ojfO!@$k3f|;yXSqIg zDw^s*_d0lzt}~##sSds%P^V?h!r=USbBOydgOuC46$FtLc8e5`akUGvYN1Hy5=2}d zF;@`AqZ-&luGTuhKDYmE3tm$S-4j**IRvo7{QQ`0A`=Ol|9?_`)2($$w-(I= ze0UF+)2Ktr}wbN6KW&nM|Xg<)_j52{}N7aYlGokfLA3lRayIMY`myk;55PeK<0G(j8 z35a%md`#Pbeq@vbM0+7VrUO9d865?>z~}_f&y4bcXcx|hKjlm(#(hkMh`Y$>2GB2z z5N-OEkw1R(B@U^j1!^(A+#gV{`xkpPnDjvDX8+RKQEbB0)TF7A++HW9r~GYuU8Tzv zK+>t3ku#!Z)}wK;@!o^s|KRNq=p}t%AoP+xur8xuXkle!1qxsk3RHnn7||QIe?}xiUpd=C=RF+qj;dojFN#SGD-oO%xDJC1V#WQLb|SR9i3*CMwN-Hb!fuq z(NjBx%`kParc6%lWU3F4HZvuu6M<<76FQkfCnls#9XsOz)3nJG5Ql%0CZ}0V!%O64 zjG#Jv8!jU&PVJzD*-NkM<{t)nsCOiINtmTDb6dD8u9)`STYCQr9cOrMZ8Hf6%t!~`DVJc+Fn$ELzmiOHsE zNr`Ebr*<6B*_t+avUS4bNspLPVZup|xbKav$wM*ymdY<9N+3{Q)|F;lG!DB*Fry^m zz%gP&Dk3-xE)lCnOPfYvytv0P$<>&Lkd&)4R#3`m5@3% zairL0RQecO#K0~giOC65N2X0p7@L-Ai;$5RlvD$-J7xe8wwAV12Wa@X9!Q}?ubC^7 zF`P<{Fjl8iMZJ@Gq?qJ3QcNX}u6N>_z_}3LWIaD4uZK~R5+>fkD5cs!m4GCZ4W@d{ zOG-?%tMErQC@qkT87zY;b`~S5Sn68treaaOD9Qh308@GTLAaC8h~-JDSf1!1 zp2MB^9@n*5!boG$FGgP*JNeFal+zDw!qAYgUx{KM7I+R25PIRD3Zko*U}X;?#@ zBc&z#NNGuyyR^p6k*H(w=NVqqOZ$pf9g3B9GJ0t5J+@bmp}dsE36pkfz2-ux#_$GH zk1!jI{Fol}+TPPOQ*T&knI6W<2Tg*@pUJwKynWDhi-kr>I6N-eZfkQk}ZTfB-= zVx@>wSa%UA4NQ0JDR$_pe&|)cRNcs^$*H4kj#711Mxh)@*Br01@=CYg-~r4+K|cdQL{xU{6B@|4ABBgg4tsVYTX@s=uhsZ8!k zs?z07`n#8OL=VNI9$OZ6s~;tH9H${{7ft)WD! z54cl_L^JX~(d=$Zbd7VS65V7(C8FgLV>u9oKps3OVM2P6t+WSoBM({YPp@)VnBk|0 zsi^E_Fei`&%gT(1=x)j`WuUT48Hi7n|4ue5%efGrzn&lQsz4=}hX)V9F!TGKYJ=|Mle|Rl^nkjw*xpb#+~B+Vq>(K7KPV;n$4V+7qrl8MgjV z?T;FltvN8J+KY>pB=&BZzy9oR7guK1dAoj+1?hi*UEs^+CfSJvKLepylY#(iT#E}nj|AmHKe&Yt=z^V6}fuWxi= z-Q0FnDzd%V!J{IO1Bdc=*(x>Oq7wGw3!nhG<((eEIKAGcT3f44x3W{$ zI=9U$>^$&7*O2#u@992j-K&#ALazV((fNWC_aFOh;_R=6$6a{)%Zc}Ao&MGS%oBSv zrhj_))tIJlM85e*@`(%6KfL^6i<5gQmH+Nrm9DOH%FTZ)?x#OGJ^sPt>z2A^r7fOa zr|yz9i#qrAt@+Tsn^&yacF@03#nX|k+ih!-T(8*|)fQd-tXA$HyDVGtXBOPryfo=z ze6!y|{v4A3D3D_RGt=?)^K)a$A`asJJi}m+3%fEk@uI+ z8T(y?@AZ^dj`i%ZbIXRH4WBICJS^j@?c0Yf*uHbnoNnh^zUi8Grfy-<>pxcOHKg2> zoA3X$>hY>IJ{YjeK73c1@iFZ>^*owRsQ3|lqZ@jOxd(y zK+>Ls3UBP4ceu3l?>7IH70{={Q?Ip}=~s1q+?O||PPlPTOxJ7gwaEP@b)ui|j#Y#D z?w%B}-E{I{*W%6>rtLZX{lcI&ovVL+?)=&JcmMF0x>wgjxmhDRjoD!TWzQd%pP7E$ zxo6(fsrvK!YT-%s z2W?UH*CTe_(CD#0>{oiLau>aJCF1hM1O1eJ)OA{3wVGX?yH#|&=fE3V4mWH zory*3hrRnw+qbS>x%OrD(z2a~e9&rt|I_WCy!k=@W%D<@-8=uC8RxG>6;6)cF`&kG zE3AX(rL_I>vsT^nxA`5LHmk><@1A~Wz>v?M*!1gbXC`~fTl&+VZ}pne{~piyGP$;y z>kg&*E{Sc}=;K)*9Q#lAk!#Jb_gXr&Z`)~SgI+K4In?9mj4g|5%}jncVvJ+qbFPT? z7sB6J;B=Pze8jj`&-SR)@ZCn+y8M}|+S8cfv%Z{=Qn{+SzLqfbhcDJ-tQ~VY|K0VI zHmv(AeRuz$;|rU=_Il@toogw|^HT*4qSi+^_zt?NAeBPwq zHwV`0S>{Z^<2{=W9uz)#>R+1|PTAOITD!<$A<>_I@!cDK9ft1An0%;d<|BonzrApE zz@cN4T5d}ir0y>?u9|o0O#Qx1{(L|5i7sFL{Nj@htE46j=%eI4wxa42Z=9WKQu3}0 zz4*h~W3!K_^cGbc%{wHzqH6>h|f8-;T;pNc**s{ewk=c7?Xd&42vnisxz#IrVFI-zu9bOtMby6s*#_ zT*#Wfu=`_Els-y7RbKz+95wDgerBaAPek^voQRz}|4{V(E|w_@nYhQH(v|)GDjZ#5 zxAXT=9WVaeY{P}F=DVd={B=h4{&d`H1wUnkgGPgH&E{bl^XWhsRPQ(wK+CgNQCj7qg)%RO^`sYT^mZGXk4qiTodv>8-> zPOqf;e~w-~u*QN%3O_mjXQff^CwINlJ?@Y>sKTb;_7$E_ikTMWmw4pp7Xi*Sk9@P> z;_1DElQypZ(PZy_EiJ#(@yhp{3mv)P*-N!|SAKc)%rT!F`EqdfBY9Kz4hf2__(|-T z$G1()ygkzO-3Qyc_Fwa^-{{frRO|lWqP}hVz4X&7!H*qO`i$#P@kl`@%i(oxejQq| z-tdqe&&+(`%ZopMVg3Bs1}Rm2;~r>wdVj0;2W5|)y>n}p?_*!wiqF{7cy!};7Hn9! zw~8(EsrII|m*&0mNV;wDiSzaDeQNJp4RhPCc;Opg&w86t@q_iXvaX(d<7#Bl-hs<} zUwve+Z_By2KACi*@a3KX=E!Gje)7xC+BK&?^F)SIGZ;wsfv-0Yb17=pAR6laEU)RX5j&B;`n_D*a zu*yf}8`1BTwYw@mS>wYc?=JcIn^wJ^XlQ+P#y1}wZ%}vG#eMg#KKS;6dh>5wUA)kf zPwBJw^v&+06BY$3IaB^P@=E{HgIDYvJgj{8W2gJ5{8ulT`$>;^zjXDKv%>Le(YLk# zv(CTLL-zG8r{}(V{EXz!ff&yP<$Qtrhr=hpO&IMFQoo$y*OH}6+=rT;5~P7ii``pAAI z-!ngTul&_IxaYLm=bJtL^KpXC3&12Ud+c5RnIfLuE*}2czI;_$fj48HchPBvq$s2ZC=co(tdw>`+4g( zyuC7F$o3^O`n0W@tIBnAjZgR5duFGqa$OocfAjn(wK_9h&%S+oY59Yp z%8#P*{(5TDsfZHoQR%TVvT27o(zWj{F{{{n7Zu$qzp7wR52}abvsA z!#}7o{cY9WPkjCSYs&-sHdFbl{>t-S`Kvjt{G!g=H#WiX@anF#pX)Ag= zOt*I*n;QJc{i?sp{B~lSxl2BO$^6m}zxlseZ@=HcD{X&yuKm{ZSyw7Qd}P5hYFvpb z(>mSvv8tU^`S#oz7XG+tcN2AQ{j>`H&oSqL=L_oPJhuOIYL&dGBjGO;?DZVK>ON2u zkT`3vP3f)ds^ko=Y;E^Tt+|cH-M(k@@4M#oPMkdDT=|5m4d>r?dHs$(L3Y(%2S(bP zU3jIYuacwet>k=e>zSH1px5lLc71EJ)a&QB+5W(@hySdYUHDtq_Y*%zYqDV4jG|A6 zcly3k#Po#ww!a;7J-qYm9|u12^s(wsAFQ|dy{%mn+i&=y{(@;ijnAE&aeQgPzQ2w- z?wyp7Ib_J;VH@8+dVArp>9sZ|$4894_Uj+7{623}pAQbqZjw3H;%P56uj;$}KYJG+ zd}XK7Pt7~q_^e#s_WLU{4w+7OGEZ#~@I>|ZR&QR`^z^Y8{&VAvr#~Fuu)?~bwQF^` zPtCLD*V%p8vTf-}HP8Bd=-%DWZ@K-hk~5)pLd|~N-@5&Ga?VwMHFx4w(-luSXejx0?xPAIv-7Vdz)SUsCm(a`M5smZNq1whd}=;A-4!o8NmlBOZ?( z**E;U&R7ur`s*hq4B7Hh`Laoonac)tzWUcqWk)sN{w>#a)|GVfT%8Yl9(kwwsp+2c z-;7s>=YD99JNuvPCys30Jm|YR6P|l}z{`$b)&1)=j(->z_E`G2bL@?0S6sK@+Qhdi zt{wM;Mcr3FesxXz_pWVF^yf~@Tw|N_!;JRd{!y*=S0C>^n7PcBcktl+T@!b3`tiaAKCou_qAHT@l&^ZEn~mf^YxD*Q`)X;m$G$!?f(ovvFS!aqd6b_eE-Dv zyU*=)(DLQ_7S4Vtk?;I`G`91Vp0z$*^?O)Wb-!IT?rXcP^YSNGY!17a<{V*fq3c(s zLd}>(4?Vg4nFe*+PY=AH%GLLU{FhJ7O)?cdaJlK&QHA&YzNf-p4PRe4DZBsSu?zdI zI1#inXjqv>EuXJ{vHkat+s|&f=i;ow_sX^0(mD4?w>F!6YpV2wPiuErbJg`u!y!XX zhJ3p2i|=}Tym{`n&rS75d~)gCgvtjLeV^)&{nal%{Vh*>l^o0SNvUMjsb{Z;x8Per}=$$d?-N~2Tq&b;^IhE5~y9qgH(D#!LemtSc= z;OYU-a!%;jZqk?U8anh{U+M|z@q@fptN~aNh zNDH$My>vwA*v;(EO6r5n4iA0GmCy%E^B#GXq@fcn#q}}Lh&~mVh7PMzu8Y4|u*;~A z&`_z(K6E6Wa(#V=rDsW+N=%c2U$W2gMjI;|X~fQm^3bP}pNCBo zyJbF9l7{xf%sxNhm+CZg`nt(R8Y%ldOw$a%l-JN#x}K?K&{=5iWg60oXzu@T-UCJ& zu@7lt_W20ERIXOj*5Qo3yIdkCm}#u|rIZ)WP0OlYA}@MtrMPdDq@hopxM|M)k~`i= zBl^^08hT}cT3X@dp#zQj2n`*NG5ZYAXoj6VwW%b{eN2<6(LC1W7TN__!Po}tFpX-1 zTcW>9zRyrD$%|fCG5hSmFWKk$BRP+jlw)NYCFi5cb@tXZ$PpXXV;a(mv`870{c1^? z`b?wz@QEy)nuukTcp5$Jj>pYX_U^@KW+YV zNC}-AF^$r>{A&-qT$1MgVl+!X$b7>{Bl?6gO*&Md_TJ*zU8q`5eI8&MrBA}LIjcfT z=tHk3n0=H!3m^UIg_1OlnT9l{9I7^dJI6>P`ZQsh!T2Q`9`AAa7o$ExL$7O@eP%-l z^<$Txcor8=ovHP?{h4%bT0-aMOk>o!BuyC87 z!xkm2~5jzn7%x z#x(Eam+JJJwYwrq(nK)LAo|7Mtj7b;m^||W8}cfPU($KQ+Pw`+(sXAU`UD2$wJv9B zUP+oBOhcn8_{Z6jI`?K8vJ%;_)`dgpAU*BehiRyEM6+(t z_Ag4(#4-)_LPS&ki<59(PdR;=hGq*yGc9~bs34<{kq4T6YJ$KI=+>>!fkql>@BNuZ zwVlkYmv{Cvv_WYXJhJ=HheXLg-ijXveJEFBUJ#AE0yUa$S+UlVH0*&s^nqxSb8$dp zOfEd-&?q1}6HV=eob5&$(V1GYd)&D^CwTkd5;{N3H1w%x8sm01OM*CeULt1*)2RN3 z#*2pya)f4RvAq6RGU7QSjo61~v+lAdr>r_)%u8s7GmYxQn^t-d9h+Mpp&7w6_3%q! z(88t{OVUtpVD<@M3Vg2Rr@Eh(q=_#^^Vq7*D1>KT3B_n?hG)UuJZVNTO=~oERFr8& zi!%R3^3d!Z^EsF2jqAR+Bd|Qx!q1xT+rD{zKzV9}=9!$S&je~}g(mN=%qN{1Rh~N1 zTnXhl6!x;So`;TL`?Jc=Ea3;sQx{O4*+PTm3DlrB+kdb;PK_$hT+-lZ#dGBmkFSUG z7Zgs+nHP{o_rr=$CLb24xsWuM!86il_iwu-P;(J!=HoLwR#g2CCr1BR&|RR+sql
      1. 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

          ^H);Oe$@3(27YWTi1r_e*P z#*-{~zm2A%yg7v)vZqWy3icE@M#1}SGh^?-u++h{7NET_;zs7Z=q z5WcchL2cLma-2dB*{;b*$#n?tx6#y*@|;2s$(n+c+?U~%z=|sCgg>XyL$aolEO@_- zrVa;i3Oyw2AEclf(BKubvFcp8w-Tq&L$aokEO`HhrZQIH6naS3bW@hS+O8IXoI(%D znnAKgo$420w4}wAu8R0^t zjiIv*i=NHvy{tfzS!WYbw+1%)0m!evN#v7VE&ub11r z!Zfuxh-aaPP|J~O%?SA9hVM^bztL3B8k|B8p<)E9{jzYqX%y zL#nX@DOnA8-TAx$s zA=Exafg|ht<|)>yY8((0dPp_)BPA<8JU=vV4K)i*vM|5HMO@P&q5EO4kHC?9vZAeP4#cY zDfEzP96?G}1JnsNVr9!+f&6naSI&#Nq08^v3! zNTR7%fWUg6dtlkLWY;uJ6>1Ke#eyDE`Kw6D zS^jk6M3|l(=#GI{q&P3;yGdPvrFlC|g4(Y>0oYr#i|9+GtfDY< (JNS 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%0D*{ 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

          t84JNiQceNVPmQ*tebK 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±eFL3Vs+z(>j1m>E+xz?|% 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

          *O7(zNM)i=Wn6YA=sPm!>zS^_>1H0({ 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 Date: Mon, 6 Jan 2020 17:34:32 -0500 Subject: [PATCH 21/24] Removed `noise_model` and `sim_config` as an argument in the pulse simulator (#503) * removed noise_model from digest args, and also sim_config handling * Changed warnings in digest for persistentValue pulses * multiplying qubit_lo_freq by 1e9 in digest.py, as assemble divides it by 1e9 --- .../providers/aer/backends/pulse_simulator.py | 20 +++---------------- qiskit/providers/aer/openpulse/qobj/digest.py | 16 +++++++-------- 2 files changed, 10 insertions(+), 26 deletions(-) diff --git a/qiskit/providers/aer/backends/pulse_simulator.py b/qiskit/providers/aer/backends/pulse_simulator.py index 12e803522b..8f7cf13b45 100644 --- a/qiskit/providers/aer/backends/pulse_simulator.py +++ b/qiskit/providers/aer/backends/pulse_simulator.py @@ -24,7 +24,6 @@ from qiskit.providers.models import BackendConfiguration, PulseDefaults from .aerbackend import AerBackend from ..aerjob import AerJob -from ..aererror import AerError from ..version import __version__ from ..openpulse.qobj.digest import digest_pulse_obj from ..openpulse.solver.opsolve import opsolve @@ -67,27 +66,25 @@ def __init__(self, configuration=None, provider=None): def run(self, qobj, system_model, backend_options=None, - noise_model=None, validate=False): """Run a qobj on the backend.""" # Submit job job_id = str(uuid.uuid4()) aer_job = AerJob(self, job_id, self._run_job, qobj, system_model, - backend_options, noise_model, validate) + backend_options, validate) aer_job.submit() return aer_job def _run_job(self, job_id, qobj, system_model, backend_options, - noise_model, validate): """Run a qobj job""" start = time.time() if validate: - self._validate(qobj, backend_options, noise_model) + self._validate(qobj, backend_options, noise_model=None) # Send to solver - openpulse_system = digest_pulse_obj(qobj, system_model, backend_options, noise_model) + openpulse_system = digest_pulse_obj(qobj, system_model, backend_options) results = opsolve(openpulse_system) end = time.time() return self._format_results(job_id, results, end - start, qobj.qobj_id) @@ -106,17 +103,6 @@ def _format_results(self, job_id, results, time_taken, qobj_id): output["time_taken"] = time_taken return Result.from_dict(output) - def _validate(self, qobj, backend_options, noise_model): - """Validate the pulse object. Make sure a - config has been attached in the proper location""" - - # Check to make sure a sim_config has been added - if not hasattr(qobj.config, 'sim_config'): - raise AerError('The pulse simulator qobj must have a sim_config ' - 'entry to configure the simulator') - - super()._validate(qobj, backend_options, noise_model) - def defaults(self): """Return defaults. diff --git a/qiskit/providers/aer/openpulse/qobj/digest.py b/qiskit/providers/aer/openpulse/qobj/digest.py index 9bfdf16daa..f8115fc1a4 100644 --- a/qiskit/providers/aer/openpulse/qobj/digest.py +++ b/qiskit/providers/aer/openpulse/qobj/digest.py @@ -20,6 +20,7 @@ from warnings import warn from collections import OrderedDict import numpy as np +from qiskit.providers.aer.aererror import AerError from .op_system import OPSystem from .opparse import NoiseParser from .operators import qubit_occ_oper_dressed @@ -29,7 +30,7 @@ from . import op_qobj as op -def digest_pulse_obj(qobj, system_model, backend_options=None, noise_model=None): +def digest_pulse_obj(qobj, system_model, backend_options=None): """Convert specification of a simulation in the pulse language into the format accepted by the simulator. @@ -37,7 +38,6 @@ def digest_pulse_obj(qobj, system_model, backend_options=None, noise_model=None) qobj (PulseQobj): experiment specification system_model (PulseSystemModel): object representing system model backend_options (dict): dictionary of simulation options - noise_model (dict): noise model specification Returns: out (OPSystem): object understandable by the pulse simulator Raises: @@ -53,11 +53,7 @@ def digest_pulse_obj(qobj, system_model, backend_options=None, noise_model=None) if backend_options is None: backend_options = {} - # Temp backwards compatibility - if 'sim_config' in qobj_config: - for key, val in qobj_config['sim_config'].items(): - backend_options[key] = val - qobj_config.pop('sim_config') + noise_model = backend_options.get('noise_model', None) # post warnings for unsupported features _unsupported_warnings(qobj_dict, noise_model) @@ -76,7 +72,8 @@ def digest_pulse_obj(qobj, system_model, backend_options=None, noise_model=None) if 'qubit_lo_freq' not in qobj_config: raise ValueError('qubit_lo_freq must be specified in qobj.') - qubit_lo_freq = qobj_config['qubit_lo_freq'] + # qobj frequencies are divided by 1e9, so multiply back + qubit_lo_freq = [freq * 1e9 for freq in qobj_config['qubit_lo_freq']] # Build pulse arrays *************************************************************** pulses, pulses_idx, pulse_dict = build_pulse_arrays(qobj_dict['experiments'], @@ -212,6 +209,7 @@ def _unsupported_warnings(qobj_dict, noise_model): noise_model (dict): backend_options for simulation Returns: Raises: + AerError: for unsupported features """ # Warnings that don't stop execution @@ -219,7 +217,7 @@ def _unsupported_warnings(qobj_dict, noise_model): if noise_model is not None: warn(warning_str.format('Noise models')) if _contains_pv_instruction(qobj_dict['experiments']): - warn(warning_str.format('PersistentValue instructions')) + raise AerError(warning_str.format('PersistentValue instructions')) def _contains_pv_instruction(experiments): From 7d6f5e782739aa04c291ea6694521a415546b6a2 Mon Sep 17 00:00:00 2001 From: Daniel Puzzuoli Date: Thu, 23 Jan 2020 11:59:06 -0500 Subject: [PATCH 22/24] Duffing system model generators for pulse simulator (#516) * Created new file for helper functions for creating HamiltonianModel and PulseSystemModel objects for duffing oscillator systems * increased max shots in pulse_simulator * added PulseSystemModel.control_channel_index() along with tests --- example/duffing_model_example.ipynb | 386 +++++++++++++ example/pulse_sim.ipynb | 4 +- .../providers/aer/backends/pulse_simulator.py | 3 +- .../aer/openpulse/duffing_model_generators.py | 429 ++++++++++++++ .../aer/openpulse/pulse_system_model.py | 20 +- .../test_duffing_model_generators.py | 538 ++++++++++++++++++ test/terra/openpulse/test_system_models.py | 37 +- 7 files changed, 1411 insertions(+), 6 deletions(-) create mode 100644 example/duffing_model_example.ipynb create mode 100644 qiskit/providers/aer/openpulse/duffing_model_generators.py create mode 100644 test/terra/openpulse/test_duffing_model_generators.py diff --git a/example/duffing_model_example.ipynb b/example/duffing_model_example.ipynb new file mode 100644 index 0000000000..5facedea5e --- /dev/null +++ b/example/duffing_model_example.ipynb @@ -0,0 +1,386 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Duffing model generator usage example" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Demonstrating transmon model generator usage" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "# general libraries\n", + "import numpy as np\n", + "import matplotlib.pyplot as plt\n", + "from scipy.optimize import curve_fit\n", + "\n", + "# qiskit and pulse stuff\n", + "import qiskit\n", + "import qiskit.pulse as pulse\n", + "import qiskit.pulse.pulse_lib as pulse_lib\n", + "from qiskit.compiler import assemble\n", + "\n", + "# new model generator function\n", + "from qiskit.providers.aer.openpulse.duffing_model_generators import duffing_system_model" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Specify system model\n", + "\n", + "Parameters here are based on `FakeOpenPulse2Q` so that the schedules from that notebook can be used here" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# number of qubits and cutoff dimensions\n", + "dim_oscillators = 3\n", + "\n", + "# frequencies for duffing drift terms, harmonic term and anharmonic term\n", + "oscillator_freqs = [5.0, 5.1]\n", + "anharmonicity_freqs = [-0.33, -0.33]\n", + "\n", + "# oscillator drive strengths\n", + "drive_strengths = [0.02, 0.02]\n", + "\n", + "# specify coupling as a dictionary (it says qubits 0 and 1 are coupled with a coefficient 0.02)\n", + "coupling_dict = {(0,1): 0.01}\n", + "\n", + "# time \n", + "dt = 1.\n", + "\n", + "# create the model\n", + "system_model = duffing_system_model(dim_oscillators=dim_oscillators,\n", + " oscillator_freqs=oscillator_freqs,\n", + " anharm_freqs=anharmonicity_freqs,\n", + " drive_strengths=drive_strengths,\n", + " coupling_dict=coupling_dict,\n", + " dt=dt)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The returned `system_model` is an instance of `PulseSystemModel`, consumable by the simulator representing the specified transmon system model." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Do Rabi experiment from previous example notebook using this model\n", + "\n", + "## First set up schedules" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "#qubit to use for exeperiment\n", + "qubit = 0\n", + "# exp configuration\n", + "exps = 41\n", + "shots = 512\n", + "\n", + "# Rabi pulse\n", + "drive_amps = np.linspace(0, 0.9, exps)\n", + "drive_samples = 128\n", + "drive_sigma = 16\n", + "\n", + "# Measurement pulse\n", + "meas_amp = 0.025\n", + "meas_samples = 1200\n", + "meas_sigma = 4\n", + "meas_risefall = 25\n", + "\n", + "# Measurement pulse (common for all experiment)\n", + "meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp,\n", + " sigma=meas_sigma, risefall=meas_risefall, \n", + " name='meas_pulse')\n", + "acq_cmd=pulse.Acquire(duration=meas_samples)\n", + "\n", + "acquire_channels = [pulse.AcquireChannel(0), pulse.AcquireChannel(1)]\n", + "memoryslots = [pulse.MemorySlot(0), pulse.MemorySlot(1)]\n", + "\n", + "# create measurement schedule\n", + "measure_and_acquire = meas_pulse(pulse.MeasureChannel(0)) | acq_cmd(acquire_channels, memoryslots)\n", + "\n", + "# Create schedule\n", + "schedules = []\n", + "for ii, drive_amp in enumerate(drive_amps):\n", + " # drive pulse\n", + " rabi_pulse = pulse_lib.gaussian(duration=drive_samples, \n", + " amp=drive_amp, \n", + " sigma=drive_sigma, name='rabi_pulse_%d' % ii)\n", + " \n", + " # add commands to schedule\n", + " schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp)\n", + " \n", + " schedule += rabi_pulse(pulse.DriveChannel(0))\n", + " schedule += measure_and_acquire << schedule.duration\n", + " \n", + " schedules.append(schedule)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Set up simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/dpuzzuoli/anaconda3/envs/QiskitDev/lib/python3.7/site-packages/qiskit/providers/models/pulsedefaults.py:166: UserWarning: `qubit_freq_est` and `meas_freq_est` now have units of Hertz(Hz) rather than gigahertz(GHz).\n", + " warnings.warn('`qubit_freq_est` and `meas_freq_est` now have units of '\n" + ] + } + ], + "source": [ + "# import simulator\n", + "backend_sim = qiskit.Aer.get_backend('pulse_simulator')\n", + "\n", + "# construct qobj. In this case we want to use channel frequencies computed directly from the Hamiltonian\n", + "qubit_lo_freq = system_model.hamiltonian.get_qubit_lo_from_drift()\n", + "rabi_qobj = assemble(schedules,\n", + " backend=backend_sim,\n", + " qubit_lo_freq=qubit_lo_freq,\n", + " meas_level=1, \n", + " meas_return='avg', \n", + " memory_slots=2,\n", + " shots=shots)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Run simulation" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "sim_result = backend_sim.run(rabi_qobj, system_model).result()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Extract results and plot" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Pi Amplitude 0.312173\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "

          " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "amp_data_Q0 = []\n", + "amp_data_Q1 = []\n", + "\n", + "for exp_idx in range(len(drive_amps)):\n", + " exp_mem = sim_result.get_memory(exp_idx)\n", + " amp_data_Q0.append(np.abs(exp_mem[0]))\n", + " amp_data_Q1.append(np.abs(exp_mem[1]))\n", + " \n", + "#Fit the data\n", + "fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B)\n", + "fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5])\n", + "\n", + "#get the pi amplitude\n", + "pi_amp = (fitparams[3])*fitparams[2]/2/np.pi\n", + "\n", + "plt.plot(drive_amps, amp_data_Q0, label='Q0')\n", + "plt.plot(drive_amps, amp_data_Q1, label='Q1')\n", + "plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit')\n", + "plt.axvline(pi_amp, color='black', linestyle='dashed')\n", + "plt.legend()\n", + "plt.xlabel('Pulse amplitude, a.u.', fontsize=20)\n", + "plt.ylabel('Signal, a.u.', fontsize=20)\n", + "plt.title('Rabi on Q0', fontsize=20)\n", + "plt.grid(True)\n", + "\n", + "print('Pi Amplitude %f'%(pi_amp))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Cross-Resonance\n", + "\n", + "Run the cross resonance (demonstrate usage of `cr_idx_dict`)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "#qubit to use for experiment\n", + "target_qubit = 0\n", + "driven_qubit = 1\n", + "\n", + "# drive qubit 1 with target 0\n", + "cr_idx = system_model.control_channel_index((driven_qubit, target_qubit))\n", + "\n", + "\n", + "# exp configuration\n", + "exps = 41\n", + "shots = 512\n", + "\n", + "# Rabi pulse\n", + "cr_drive_amps = np.linspace(0, 0.9, exps)\n", + "cr_drive_samples = 128*3\n", + "cr_drive_sigma = 4\n", + "\n", + "\n", + "# Create schedule\n", + "schedules = []\n", + "for ii, cr_drive_amp in enumerate(cr_drive_amps):\n", + " # drive pulse\n", + " cr_rabi_pulse = pulse_lib.gaussian_square(duration=cr_drive_samples, \n", + " amp=cr_drive_amp, \n", + " risefall=cr_drive_sigma*4,\n", + " sigma=cr_drive_sigma, name='rabi_pulse_%d' % ii)\n", + " \n", + " # add commands to schedule\n", + " schedule = pulse.Schedule(name='cr_rabi_exp_amp_%s' % cr_drive_amp)\n", + " \n", + " schedule += cr_rabi_pulse(pulse.ControlChannel(cr_idx))\n", + " schedule += measure_and_acquire << schedule.duration\n", + " \n", + " schedules.append(schedule)" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
          " + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "# assemble, run experiment, plot data\n", + "cr_rabi_qobj = assemble(schedules, \n", + " qubit_lo_freq=qubit_lo_freq,\n", + " backend=backend_sim,\n", + " meas_level=1, \n", + " meas_return='avg', \n", + " memory_slots=2,\n", + " shots=shots)\n", + "sim_result = backend_sim.run(cr_rabi_qobj, system_model).result()\n", + "\n", + "amp_data_Q0 = []\n", + "amp_data_Q1 = []\n", + "\n", + "for exp_idx in range(len(cr_drive_amps)):\n", + " exp_mem = sim_result.get_memory(exp_idx)\n", + " amp_data_Q0.append(np.abs(exp_mem[0]))\n", + " amp_data_Q1.append(np.abs(exp_mem[1]))\n", + " \n", + "\n", + "plt.plot(drive_amps, amp_data_Q0, label='Q0')\n", + "plt.plot(drive_amps, amp_data_Q1, label='Q1')\n", + "plt.legend()\n", + "plt.xlabel('Pulse amplitude, a.u.', fontsize=20)\n", + "plt.ylabel('Signal, a.u.', fontsize=20)\n", + "plt.title('CR (Target Q{0}, driving on Q{1})'.format(str(target_qubit),str(driven_qubit)), fontsize=20)\n", + "plt.grid(True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.5" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/example/pulse_sim.ipynb b/example/pulse_sim.ipynb index 0e7f957add..3d1902c25b 100644 --- a/example/pulse_sim.ipynb +++ b/example/pulse_sim.ipynb @@ -56,9 +56,9 @@ "name": "stderr", "output_type": "stream", "text": [ - "/Users/dpuzzuoli/Documents/projects/qiskit-terra/qiskit/providers/models/pulsedefaults.py:166: UserWarning: `qubit_freq_est` and `meas_freq_est` now have units of Hertz(Hz) rather than gigahertz(GHz).\n", + "/Users/dpuzzuoli/anaconda3/envs/QiskitDev/lib/python3.7/site-packages/qiskit/providers/models/pulsedefaults.py:155: UserWarning: `qubit_freq_est` and `meas_freq_est` now have units of Hertz(Hz) rather than gigahertz(GHz).\n", " warnings.warn('`qubit_freq_est` and `meas_freq_est` now have units of '\n", - "/Users/dpuzzuoli/Documents/projects/qiskit-terra/qiskit/providers/models/backendconfiguration.py:363: UserWarning: `dt` and `dtm` now have units of seconds(s) rather than nanoseconds(ns).\n", + "/Users/dpuzzuoli/anaconda3/envs/QiskitDev/lib/python3.7/site-packages/qiskit/providers/models/backendconfiguration.py:356: UserWarning: `dt` and `dtm` now have units of seconds(s) rather than nanoseconds(ns).\n", " warnings.warn('`dt` and `dtm` now have units of seconds(s) rather '\n" ] } diff --git a/qiskit/providers/aer/backends/pulse_simulator.py b/qiskit/providers/aer/backends/pulse_simulator.py index 8f7cf13b45..aeba95895f 100644 --- a/qiskit/providers/aer/backends/pulse_simulator.py +++ b/qiskit/providers/aer/backends/pulse_simulator.py @@ -41,11 +41,12 @@ class PulseSimulator(AerBackend): 'coupling_map': None, 'url': 'https://github.com/Qiskit/qiskit-aer', 'simulator': True, + 'meas_levels': [0, 1, 2], 'local': True, 'conditional': True, 'open_pulse': True, 'memory': False, - 'max_shots': 50000, + 'max_shots': 10**6, 'description': 'A pulse-based Hamiltonian simulator', 'gates': [], 'basis_gates': [] diff --git a/qiskit/providers/aer/openpulse/duffing_model_generators.py b/qiskit/providers/aer/openpulse/duffing_model_generators.py new file mode 100644 index 0000000000..599136de20 --- /dev/null +++ b/qiskit/providers/aer/openpulse/duffing_model_generators.py @@ -0,0 +1,429 @@ +# -*- coding: utf-8 -*- + +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +# pylint: disable=invalid-name + +"Helper functions for creating HamiltonianModel and PulseSystemModel objects" + +from warnings import warn +from collections.abc import Iterable +from .hamiltonian_model import HamiltonianModel +from .pulse_system_model import PulseSystemModel + + +def duffing_system_model(dim_oscillators, + oscillator_freqs, + anharm_freqs, + drive_strengths, + coupling_dict, + dt): + """Returns a PulseSystemModel for a specified Duffing oscillator system. + + Note: Frequencies are assumed to be in frequency units (as opposed to radial). + + Single oscillators are specified by three parameters: frequency v, anharmonicity alpha, and + drive strength r, which enter into the Hamiltonian model via the terms: + pi*(2*v-alpha)*O + pi*alpha*O*O + 2*pi*r*X*D(t), + where O is the number operator, X is the drive operator, and D(t) is the signal of the + corresponding DriveChannel. + + Couplings between oscillators are specified in the argument coupling_dict, with keys being + edges, and values being the coupling strenghts. Couplings enter the Hamiltonian model via an + exchange coupling term: + 2*pi*j*(A0*C1+C0*A1), + where j is the coupling strength, and A0*C1+C0*A1 is the exchange coupling operator between the + two oscillators, where A is the annihiliation operator, and C is the creation operator. + + For each pair of coupled oscillators, pulse ControlChannels are prepared for doing cross + resonance (CR) drives between oscillators. A CR drive on oscillators 0 with target oscillators + 1 is modeled with the Hamiltonian term: + 2*pi*r0*X0*U(t), + where r0 is the drive strength for oscillators 0, X0 is the drive operator for oscillators 0, + and U(t) is the signal for the CR drive. U(t) is set to have carrier frequency equal to that of + the target oscillators. + + Indices for ControlChannels corresponding to CR drives can be retrieved from the returned + PulseSystemModel using the control_channel_index() method, with keys being tuples. E.g. the + index for the ControlChannel corresponding to a CR drive on oscillator 0 with target 1 is + given by system_model.control_channel_index((0,1)). + + Args: + dim_oscillators (int): Dimension of truncation for each oscillator + oscillator_freqs (list): Oscillator frequencies in frequency units + anharm_freqs (list): Anharmonicity values in frequency units + drive_strengths (list): Drive strength values in frequency units + coupling_dict (dict): Specification of the coupling graph with keys being edges, and values + the coupling strengths in frequency units. + + For example: + + * ``{(0,1): 0.02, (1,3): 0.01}`` specifies a system in which + oscillators (0,1) are coupled with strength 0.02, and (1,3) are + coupled with strength 0.01 + dt (float): Sample width for pulse instructions + + Returns: + PulseSystemModel: The generated Duffing system model + """ + + # set symbols for string generation + freq_symbol = 'v' + anharm_symbol = 'alpha' + drive_symbol = 'r' + coupling_symbol = 'j' + + coupling_edges = coupling_dict.keys() + + # construct coupling graph, and raise warning if coupling_edges contains duplicate edges + coupling_graph = CouplingGraph(coupling_edges) + if len(coupling_graph.graph) < len(coupling_edges): + warn('Warning: The coupling_dict contains diplicate edges, and the second appearance of \ + the same edge will be ignored.') + + # construct the HamiltonianModel + num_oscillators = len(oscillator_freqs) + oscillators = list(range(num_oscillators)) + oscillator_dims = [dim_oscillators] * num_oscillators + freq_symbols = _str_list_generator(freq_symbol + '{0}', oscillators) + anharm_symbols = _str_list_generator(anharm_symbol + '{0}', oscillators) + drive_symbols = _str_list_generator(drive_symbol + '{0}', oscillators) + sorted_coupling_edges = coupling_graph.sorted_graph + # populate coupling strengths in sorted order (vertex indices are now also sorted within edges, + # so this needs to be accounted for when retrieving weights from coupling_dict) + coupling_strengths = [coupling_dict.get(edge) or coupling_dict.get((edge[1], edge[0])) for + edge in sorted_coupling_edges] + coupling_symbols = _str_list_generator(coupling_symbol + '{0}{1}', *zip(*sorted_coupling_edges)) + cr_idx_dict = coupling_graph.two_way_graph_dict + + hamiltonian_dict = _duffing_hamiltonian_dict(oscillators=oscillators, + oscillator_dims=oscillator_dims, + oscillator_freqs=oscillator_freqs, + freq_symbols=freq_symbols, + anharm_freqs=anharm_freqs, + anharm_symbols=anharm_symbols, + drive_strengths=drive_strengths, + drive_symbols=drive_symbols, + ordered_coupling_edges=sorted_coupling_edges, + coupling_strengths=coupling_strengths, + coupling_symbols=coupling_symbols, + cr_idx_dict=cr_idx_dict) + + hamiltonian_model = HamiltonianModel.from_dict(hamiltonian_dict) + + # construct the u_channel_lo list + u_channel_lo = _cr_lo_list(cr_idx_dict) + + # construct and return the PulseSystemModel + return PulseSystemModel(hamiltonian=hamiltonian_model, + u_channel_lo=u_channel_lo, + control_channel_dict=cr_idx_dict, + qubit_list=oscillators, + dt=dt) + + +# Helper functions for creating pieces necessary to construct oscillator system models + + +def _duffing_hamiltonian_dict(oscillators, + oscillator_dims, + oscillator_freqs, + freq_symbols, + anharm_freqs, + anharm_symbols, + drive_strengths, + drive_symbols, + ordered_coupling_edges, + coupling_strengths, + coupling_symbols, + cr_idx_dict): + """Creates a hamiltonian string dict for a duffing oscillator model + + Note, this function makes the following assumptions: + - oscillators, oscillator_dims, oscillator_freqs, freq_symbols, anharm_freqs, + anharm_symbols, drive_strengths, and drive_symbols are all lists of the same length + (i.e. the total oscillator number) + - ordered_coupling_edges, coupling_strengths, and coupling_symbols are lists of the same + length + + Args: + oscillators (list): ints for oscillator labels + oscillator_dims (list): ints for oscillator dimensions + oscillator_freqs (list): oscillator frequencies + freq_symbols (list): symbols to be used for oscillator frequencies + anharm_freqs (list): anharmonicity values + anharm_symbols (list): symbols to be used for anharmonicity terms + drive_strengths (list): drive strength coefficients + drive_symbols (list): symbols for drive coefficients + ordered_coupling_edges (list): tuples of two ints specifying oscillator couplings. Order + corresponds to order of coupling_strengths and + coupling_symbols + coupling_strengths (list): strength of each coupling term (corresponds to ordering of + ordered_coupling_edges) + coupling_symbols (list): symbols for coupling coefficients + cr_idx_dict (dict): A dict with keys given by tuples containing two ints, and value an int, + representing cross resonance drive channels. E.g. an entry {(0,1) : 1} + specifies a CR drive on oscillator 0 with oscillator 1 as target, with + u_channel index 1. + + Returns: + dict: hamiltonian string format + """ + + # single oscillator terms + hamiltonian_str = _single_duffing_drift_terms(freq_symbols, anharm_symbols, oscillators) + hamiltonian_str += _drive_terms(drive_symbols, oscillators) + + # exchange terms + hamiltonian_str += _exchange_coupling_terms(coupling_symbols, ordered_coupling_edges) + + # cr terms + driven_system_indices = [key[0] for key in cr_idx_dict.keys()] + cr_drive_symbols = [drive_symbols[idx] for idx in driven_system_indices] + cr_channel_idx = cr_idx_dict.values() + hamiltonian_str += _cr_terms(cr_drive_symbols, driven_system_indices, cr_channel_idx) + + # construct vars dictionary + var_dict = {} + for idx in oscillators: + var_dict[freq_symbols[idx]] = oscillator_freqs[idx] + var_dict[anharm_symbols[idx]] = anharm_freqs[idx] + var_dict[drive_symbols[idx]] = drive_strengths[idx] + + for symbol, strength in zip(coupling_symbols, coupling_strengths): + var_dict[symbol] = strength + + dim_dict = {str(oscillator): dim for oscillator, dim in zip(oscillators, oscillator_dims)} + + return {'h_str': hamiltonian_str, 'vars': var_dict, 'qub': dim_dict} + + +def _cr_lo_list(cr_idx_dict): + """Generates u_channel_lo list for a PulseSystemModel from a cr_idx_dict. + + Args: + cr_idx_dict (dict): A dictionary with keys given by tuples of ints with int values. A key, + e.g. (0,1), signifies CR drive on system 0 with target 1, and the + value is the u channel index corresponding to that drive. + Note: this function assumes that + cr_idx_dict.values() == range(len(cr_idx_dict)). + + Returns: + list: u_channel_lo format required by the simulator + """ + + # populate list of u channel lo for cr gates + lo_list = [0] * len(cr_idx_dict) + for system_pair, u_idx in cr_idx_dict.items(): + lo_list[u_idx] = [{'scale': [1.0, 0.0], 'q': system_pair[1]}] + + return lo_list + + +# Functions for creating Hamiltonian strings for various types of terms + + +def _single_duffing_drift_terms(freq_symbols, anharm_symbols, system_list): + """Harmonic and anharmonic drift terms + + Args: + freq_symbols (list): coefficients for harmonic part + anharm_symbols (list): coefficients for anharmonic part + system_list (list): list of system indices + Returns: + list: drift term strings + """ + + harm_terms = _str_list_generator('np.pi*(2*{0}-{1})*O{2}', + freq_symbols, + anharm_symbols, + system_list) + anharm_terms = _str_list_generator('np.pi*{0}*O{1}*O{1}', + anharm_symbols, + system_list) + + return harm_terms + anharm_terms + + +def _drive_terms(drive_symbols, system_list): + """Drive terms for single oscillator + + Args: + drive_symbols (list): coefficients of drive terms + system_list (list): list of system indices + Returns: + list: drive term strings + """ + + return _str_list_generator('2*np.pi*{0}*X{1}||D{1}', + drive_symbols, + system_list) + + +def _exchange_coupling_terms(coupling_symbols, ordered_edges): + """Exchange coupling terms between systems + + Args: + coupling_symbols (list): coefficients of exchange couplings + ordered_edges (list): list tuples of system indices for the couplings + Returns: + list: exchange coupling strings + """ + + idx1_list, idx2_list = zip(*list(ordered_edges)) + + return _str_list_generator('2*np.pi*{0}*(Sp{1}*Sm{2}+Sm{1}*Sp{2})', + coupling_symbols, + idx1_list, + idx2_list) + + +def _cr_terms(drive_symbols, driven_system_indices, u_channel_indices): + """Cross resonance drive terms + + Args: + drive_symbols (list): coefficients for drive terms + driven_system_indices (list): list of indices for systems that drive is applied to + u_channel_indices (list): indicies for the u_channels corresponding to each term + Returns: + list: cr term strings + """ + + return _str_list_generator('2*np.pi*{0}*X{1}||U{2}', + drive_symbols, + driven_system_indices, + u_channel_indices) + + +def _str_list_generator(str_template, *args): + """Given a string template, returns a list where each entry is the template formatted by the + zip of args. It is assumed that either args is a tuple of lists each of the same length, or + is a tuple with each entry beign either an str or int. + E.g. + 1. _str_list_generator('First: {0}, Second: {1}', 'a0', 'b0') returns ['First: a0, Second: b0'] + 2. _str_list_generator('First: {0}, Second: {1}', ['a0', 'a1'], ['b0', 'b1']) returns + ['First: a0, Second: b0', 'First: a1, Second: b1'] + + Args: + str_template (str): string template + args (tuple): assumed to be either tuple of iterables of the same length, or a tuple with + entries that are either type str or int + + Returns: + list: list of str_template formated by args lists + """ + + args = [_arg_to_iterable(arg) for arg in args] + return [str_template.format(*zipped_arg) for zipped_arg in zip(*args)] + + +def _arg_to_iterable(arg): + """Check if arg is an iterable, if not put it into a list. The purpose is to allow arguments + of functions to be either lists or singletons, e.g. instead of having to pass ['a'], 'a' can be + passed directly. + + Args: + arg (Iterable): argument to be checked and turned into an interable if necessary + + Returns: + Iterable: either arg, or arg transformed into a list + """ + # catch expected types (issue is str is iterable) + if isinstance(arg, (int, str)): + return [arg] + + if isinstance(arg, Iterable): + return arg + + return [arg] + + +# Helper classes + + +class CouplingGraph: + """ + Helper class containing functionality for representing coupling graphs, with the main goal to + construct different representations for different purposes: + - self.graph: graph as a set of edges stored as frozen sets, e.g. + {frozenset({0,1}), frozenset({1,2}), frozenset({2,3})} + - self.sorted_graph: graph as a list of tuples in lexicographic order, e.g. + [(0,1), (1,2), (2,3)] + Note: these are actively ordered by the object, as the point is to have a canonical + ordering of edges. The integers in the tuples are also ordered. + - self.sorted_two_way_graph: list of tuples where each edge is repeated with the vertices + reversed. The ordering is the same as in sorted_graph, with the duplicate appearing + immediately after the original, e.g. + [(0,1), (1,0), (1,2), (2,1), (2,3), (3,2)] + - self.two_way_graph_dict: same as above, but in dict form, e.g. + {(0,1) : 0, (1,0) : 1, (1,2) : 2, (2,1) : 3, (2,3) : 4, (3,2) : 5} + """ + + def __init__(self, edges): + """returns CouplingGraph object + + Args: + edges (Iterable): An iterable of iterables, where the inner interables are assumed to + contain two elements, e.g. [(0,1), (2,3)], or ((0,1), (2,3)) + + Returns: + CouplingGraph: coupling graph specified by edges + """ + + # create the set representation of the graph + self.graph = {frozenset({idx1, idx2}) for idx1, idx2 in edges} + + # created the sorted list representation + graph_list = [] + for edge in self.graph: + edge_list = list(edge) + edge_list.sort() + graph_list.append(tuple(edge_list)) + + graph_list.sort() + self.sorted_graph = graph_list + + # create the sorted_two_way_graph + two_way_graph_list = [] + for edge in self.sorted_graph: + two_way_graph_list.append(edge) + two_way_graph_list.append((edge[1], edge[0])) + + self.sorted_two_way_graph = two_way_graph_list + + # create the dictionary version + self.two_way_graph_dict = {self.sorted_two_way_graph[k]: k + for k in range(len(self.sorted_two_way_graph))} + + def sorted_edge_index(self, edge): + """Given an edge, returns the index in self.sorted_graph. Order in edge does not matter. + + Args: + edge (Iterable): an iterable containing two integers + + Returns: + int: index of edge + """ + edge_list = list(edge) + edge_list.sort() + return self.sorted_graph.index(tuple(edge_list)) + + def two_way_edge_index(self, directed_edge): + """Given a directed edge, returns the index in self.sorted_two_way_graph + + Args: + directed_edge (Iterable): an iterable containing two integers + + Returns: + int: index of directed_edge + """ + return self.two_way_graph_dict[tuple(directed_edge)] diff --git a/qiskit/providers/aer/openpulse/pulse_system_model.py b/qiskit/providers/aer/openpulse/pulse_system_model.py index 8b26f66069..92dc42bdd0 100644 --- a/qiskit/providers/aer/openpulse/pulse_system_model.py +++ b/qiskit/providers/aer/openpulse/pulse_system_model.py @@ -11,10 +11,11 @@ # Any modifications or derivative works of this code must retain this # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. -# pylint: disable=eval-used, exec-used, invalid-name, missing-return-type-doc +# pylint: disable=eval-used, exec-used, invalid-name "System Model class for system specification for the PulseSimulator" +from warnings import warn from collections import OrderedDict from qiskit.providers import BaseBackend from .hamiltonian_model import HamiltonianModel @@ -29,6 +30,7 @@ def __init__(self, qubit_freq_est=None, meas_freq_est=None, u_channel_lo=None, + control_channel_dict=None, qubit_list=None, dt=None): """Basic constructor. @@ -46,6 +48,7 @@ def __init__(self, raise AerError("hamiltonian must be a HamiltonianModel object") self.hamiltonian = hamiltonian self.u_channel_lo = u_channel_lo + self.control_channel_dict = control_channel_dict or {} self.qubit_list = qubit_list self.dt = dt @@ -92,6 +95,21 @@ def from_backend(cls, backend, qubit_list=None): qubit_list=qubit_list, dt=dt) + def control_channel_index(self, key): + """Return the index of the control channel with identifying key. + + Args: + key (Any): key that identifies a control channel + + Returns: + int or None: index of the control channel + """ + if key not in self.control_channel_dict: + warn('There is no listed ControlChannel matching the provided key.') + return None + else: + return self.control_channel_dict.get(key) + def calculate_channel_frequencies(self, qubit_lo_freq=None): """Calculate frequencies for each channel. diff --git a/test/terra/openpulse/test_duffing_model_generators.py b/test/terra/openpulse/test_duffing_model_generators.py new file mode 100644 index 0000000000..55fdb058eb --- /dev/null +++ b/test/terra/openpulse/test_duffing_model_generators.py @@ -0,0 +1,538 @@ +# This code is part of Qiskit. +# +# (C) Copyright IBM 2018, 2019. +# +# This code is licensed under the Apache License, Version 2.0. You may +# obtain a copy of this license in the LICENSE.txt file in the root directory +# of this source tree or at http://www.apache.org/licenses/LICENSE-2.0. +# +# Any modifications or derivative works of this code must retain this +# copyright notice, and modified files need to carry a notice indicating +# that they have been altered from the originals. +""" +Tests for pulse system generator functions +""" + +import unittest +from numpy import array, array_equal, kron +from test.terra.common import QiskitAerTestCase +from qiskit.providers.aer.openpulse.pulse_system_model import PulseSystemModel +from qiskit.providers.aer.openpulse.hamiltonian_model import HamiltonianModel +from qiskit.providers.aer.openpulse import duffing_model_generators as model_gen +from qiskit.providers.aer.openpulse.qobj.op_qobj import get_oper + +class TestDuffingModelGenerators(QiskitAerTestCase): + """Tests for functions in duffing_model_generators.py""" + + def setUp(self): + pass + + def test_duffing_system_model1(self): + """First test of duffing_system_model, 2 qubits, 2 dimensional""" + + dim_oscillators = 2 + oscillator_freqs = [5.0, 5.1] + anharm_freqs = [-0.33, -0.33] + drive_strengths = [1.1, 1.2] + coupling_dict = {(0,1): 0.02} + dt = 1.3 + + system_model = model_gen.duffing_system_model(dim_oscillators, + oscillator_freqs, + anharm_freqs, + drive_strengths, + coupling_dict, + dt) + cr_idx_dict = system_model.control_channel_dict + + # check basic parameters + self.assertEqual(system_model.qubit_list, [0, 1]) + self.assertEqual(system_model.dt, 1.3) + + # check that cr_idx_dict is correct + self.assertEqual(cr_idx_dict, {(0,1): 0, (1,0): 1}) + self.assertEqual(system_model.control_channel_index((0,1)), 0) + + # check u_channel_lo is correct + self.assertEqual(system_model.u_channel_lo, + [[{'scale': [1.0, 0.0], 'q' : 1}], [{'scale': [1.0, 0.0], 'q' : 0}]]) + + # check consistency of system_model.u_channel_lo with cr_idx_dict + # this should in principle be redundant with the above two checks + for q_pair, idx in cr_idx_dict.items(): + self.assertEqual(system_model.u_channel_lo[idx], + [{'scale': [1.0, 0.0], 'q' : q_pair[1]}]) + + # check correct hamiltonian + ham_model = system_model.hamiltonian + expected_vars = {'v0': 5.0, 'v1': 5.1, + 'alpha0': -0.33, 'alpha1': -0.33, + 'r0': 1.1, 'r1': 1.2, + 'j01': 0.02} + self.assertEqual(ham_model._variables, expected_vars) + self.assertEqual(ham_model._qubit_dims, {0: 2, 1: 2}) + self._compare_str_lists(list(ham_model._channels), ['D0', 'D1', 'U0', 'U1']) + + # check that Hamiltonian terms have been imported correctly + # constructing the expected_terms requires some knowledge of how the strings get generated + # and then parsed + O0 = self._operator_array_from_str(2, ['I', 'O']) + O1 = self._operator_array_from_str(2, ['O', 'I']) + OO0 = O0@O0 + OO1 = O1@O1 + X0 = self._operator_array_from_str(2, ['I', 'X']) + X1 = self._operator_array_from_str(2, ['X', 'I']) + exchange = self._operator_array_from_str(2, ['Sm', 'Sp']) + self._operator_array_from_str(2, ['Sp', 'Sm']) + expected_terms = [('np.pi*(2*v0-alpha0)', O0), + ('np.pi*(2*v1-alpha1)', O1), + ('np.pi*alpha0', OO0), + ('np.pi*alpha1', OO1), + ('2*np.pi*r0*D0', X0), + ('2*np.pi*r1*D1', X1), + ('2*np.pi*j01', exchange), + ('2*np.pi*r0*U0', X0), + ('2*np.pi*r1*U1', X1)] + + # first check the number of terms is correct, then loop through + # each expected term and verify that it is present and consistent + self.assertEqual(len(ham_model._system), len(expected_terms)) + for expected_string, expected_op in expected_terms: + idx = 0 + found = False + while idx < len(ham_model._system) and found is False: + op, string = ham_model._system[idx] + if expected_string == string: + found = True + self.assertTrue(array_equal(expected_op, op)) + idx += 1 + self.assertTrue(found) + + def test_duffing_system_model2(self): + """Second test of duffing_system_model, 3 qubits, 3 dimensional""" + + # do similar tests for different model + dim_oscillators = 3 + oscillator_freqs = [5.0, 5.1, 5.2] + anharm_freqs = [-0.33, -0.33, -0.32] + drive_strengths = [1.1, 1.2, 1.3] + coupling_dict = {(1,2): 0.03, (0,1): 0.02} + dt = 1.3 + + system_model = model_gen.duffing_system_model(dim_oscillators, + oscillator_freqs, + anharm_freqs, + drive_strengths, + coupling_dict, + dt) + cr_idx_dict = system_model.control_channel_dict + + # check basic parameters + self.assertEqual(system_model.qubit_list, [0, 1, 2]) + self.assertEqual(system_model.dt, 1.3) + + # check that cr_idx_dict is correct + self.assertEqual(cr_idx_dict, {(0,1): 0, (1,0): 1, (1,2): 2, (2,1): 3}) + self.assertEqual(system_model.control_channel_index((1,2)), 2) + + # check u_channel_lo is correct + self.assertEqual(system_model.u_channel_lo, + [[{'scale': [1.0, 0.0], 'q' : 1}], + [{'scale': [1.0, 0.0], 'q' : 0}], + [{'scale': [1.0, 0.0], 'q' : 2}], + [{'scale': [1.0, 0.0], 'q' : 1}]]) + + # check consistency of system_model.u_channel_lo with cr_idx_dict + # this should in principle be redundant with the above two checks + for q_pair, idx in cr_idx_dict.items(): + self.assertEqual(system_model.u_channel_lo[idx], + [{'scale': [1.0, 0.0], 'q' : q_pair[1]}]) + + # check correct hamiltonian + ham_model = system_model.hamiltonian + expected_vars = {'v0': 5.0, 'v1': 5.1, 'v2': 5.2, + 'alpha0': -0.33, 'alpha1': -0.33, 'alpha2': -0.32, + 'r0': 1.1, 'r1': 1.2, 'r2': 1.3, + 'j01': 0.02, 'j12': 0.03} + self.assertEqual(ham_model._variables, expected_vars) + self.assertEqual(ham_model._qubit_dims, {0: 3, 1: 3, 2: 3}) + self._compare_str_lists(list(ham_model._channels), ['D0', 'D1', 'D3', 'U0', 'U1', 'U2', 'U3']) + + # check that Hamiltonian terms have been imported correctly + # constructing the expected_terms requires some knowledge of how the strings get generated + # and then parsed + O0 = self._operator_array_from_str(3, ['I', 'I', 'O']) + O1 = self._operator_array_from_str(3, ['I', 'O', 'I']) + O2 = self._operator_array_from_str(3, ['O', 'I', 'I']) + OO0 = O0@O0 + OO1 = O1@O1 + OO2 = O2@O2 + X0 = self._operator_array_from_str(3, ['I', 'I', 'A']) + self._operator_array_from_str(3, ['I', 'I', 'C']) + X1 = self._operator_array_from_str(3, ['I', 'A', 'I']) + self._operator_array_from_str(3, ['I', 'C', 'I']) + X2 = self._operator_array_from_str(3, ['A', 'I', 'I']) + self._operator_array_from_str(3, ['C', 'I', 'I']) + exchange01 = self._operator_array_from_str(3, ['I', 'Sm', 'Sp']) + self._operator_array_from_str(3, ['I', 'Sp', 'Sm']) + exchange12 = self._operator_array_from_str(3, ['Sm', 'Sp', 'I']) + self._operator_array_from_str(3, ['Sp', 'Sm', 'I']) + expected_terms = [('np.pi*(2*v0-alpha0)', O0), + ('np.pi*(2*v1-alpha1)', O1), + ('np.pi*(2*v2-alpha2)', O2), + ('np.pi*alpha0', OO0), + ('np.pi*alpha1', OO1), + ('np.pi*alpha2', OO2), + ('2*np.pi*r0*D0', X0), + ('2*np.pi*r1*D1', X1), + ('2*np.pi*r2*D2', X2), + ('2*np.pi*j01', exchange01), + ('2*np.pi*j12', exchange12), + ('2*np.pi*r0*U0', X0), + ('2*np.pi*r1*U1', X1), + ('2*np.pi*r1*U2', X1), + ('2*np.pi*r2*U3', X2)] + + # first check the number of terms is correct, then loop through + # each expected term and verify that it is present and consistent + self.assertEqual(len(ham_model._system), len(expected_terms)) + for expected_string, expected_op in expected_terms: + idx = 0 + found = False + while idx < len(ham_model._system) and found is False: + op, string = ham_model._system[idx] + if expected_string == string: + found = True + self.assertTrue(array_equal(expected_op, op)) + idx += 1 + self.assertTrue(found) + + def test_duffing_system_model3(self): + """Third test of duffing_system_model, 4 qubits, 2 dimensional""" + + # do similar tests for different model + dim_oscillators = 2 + oscillator_freqs = [5.0, 5.1, 5.2, 5.3] + anharm_freqs = [-0.33, -0.33, -0.32, -0.31] + drive_strengths = [1.1, 1.2, 1.3, 1.4] + coupling_dict = {(0,2): 0.03, (1,0): 0.02, (0,3): 0.14, (3,1): 0.18, (1,2) : 0.33} + dt = 1.3 + + system_model = model_gen.duffing_system_model(dim_oscillators, + oscillator_freqs, + anharm_freqs, + drive_strengths, + coupling_dict, + dt) + cr_idx_dict = system_model.control_channel_dict + + # check basic parameters + self.assertEqual(system_model.qubit_list, [0, 1, 2, 3]) + self.assertEqual(system_model.dt, 1.3) + + # check that cr_idx_dict is correct + self.assertEqual(cr_idx_dict, {(0,1): 0, (1,0): 1, + (0,2): 2, (2,0): 3, + (0,3): 4, (3,0): 5, + (1,2): 6, (2,1): 7, + (1,3): 8, (3,1): 9}) + self.assertEqual(system_model.control_channel_index((1,2)), 6) + + # check u_channel_lo is correct + self.assertEqual(system_model.u_channel_lo, + [[{'scale': [1.0, 0.0], 'q' : 1}], [{'scale': [1.0, 0.0], 'q' : 0}], + [{'scale': [1.0, 0.0], 'q' : 2}], [{'scale': [1.0, 0.0], 'q' : 0}], + [{'scale': [1.0, 0.0], 'q' : 3}], [{'scale': [1.0, 0.0], 'q' : 0}], + [{'scale': [1.0, 0.0], 'q' : 2}], [{'scale': [1.0, 0.0], 'q' : 1}], + [{'scale': [1.0, 0.0], 'q' : 3}], [{'scale': [1.0, 0.0], 'q' : 1}]]) + + # check consistency of system_model.u_channel_lo with cr_idx_dict + # this should in principle be redundant with the above two checks + for q_pair, idx in cr_idx_dict.items(): + self.assertEqual(system_model.u_channel_lo[idx], + [{'scale': [1.0, 0.0], 'q' : q_pair[1]}]) + + # check correct hamiltonian + ham_model = system_model.hamiltonian + expected_vars = {'v0': 5.0, 'v1': 5.1, 'v2': 5.2, 'v3': 5.3, + 'alpha0': -0.33, 'alpha1': -0.33, 'alpha2': -0.32, 'alpha3': -0.31, + 'r0': 1.1, 'r1': 1.2, 'r2': 1.3, 'r3': 1.4, + 'j01': 0.02, 'j02': 0.03, 'j03': 0.14, 'j12': 0.33, 'j13': 0.18} + self.assertEqual(ham_model._variables, expected_vars) + self.assertEqual(ham_model._qubit_dims, {0: 2, 1: 2, 2: 2, 3: 2}) + self._compare_str_lists(list(ham_model._channels), ['D0', 'D1', 'D3', 'D4', + 'U0', 'U1', 'U2', 'U3', 'U4', + 'U5', 'U6', 'U7', 'U8', 'U9']) + + # check that Hamiltonian terms have been imported correctly + # constructing the expected_terms requires some knowledge of how the strings get generated + # and then parsed + O0 = self._operator_array_from_str(2, ['I', 'I', 'I', 'O']) + O1 = self._operator_array_from_str(2, ['I', 'I', 'O', 'I']) + O2 = self._operator_array_from_str(2, ['I', 'O', 'I', 'I']) + O3 = self._operator_array_from_str(2, ['O', 'I', 'I', 'I']) + OO0 = O0@O0 + OO1 = O1@O1 + OO2 = O2@O2 + OO3 = O3@O3 + X0 = self._operator_array_from_str(2, ['I','I', 'I', 'A']) + self._operator_array_from_str(2, ['I', 'I', 'I', 'C']) + X1 = self._operator_array_from_str(2, ['I', 'I', 'A', 'I']) + self._operator_array_from_str(2, ['I', 'I', 'C', 'I']) + X2 = self._operator_array_from_str(2, ['I', 'A', 'I', 'I']) + self._operator_array_from_str(2, ['I', 'C', 'I', 'I']) + X3 = self._operator_array_from_str(2, ['A', 'I', 'I', 'I']) + self._operator_array_from_str(2, ['C', 'I', 'I', 'I']) + exchange01 = self._operator_array_from_str(2, ['I', 'I', 'Sm', 'Sp']) + self._operator_array_from_str(2, ['I', 'I', 'Sp', 'Sm']) + exchange02 = self._operator_array_from_str(2, ['I', 'Sm', 'I', 'Sp']) + self._operator_array_from_str(2, ['I', 'Sp', 'I', 'Sm']) + exchange03 = self._operator_array_from_str(2, ['Sm', 'I', 'I', 'Sp']) + self._operator_array_from_str(2, ['Sp', 'I', 'I', 'Sm']) + exchange12 = self._operator_array_from_str(2, ['I', 'Sm', 'Sp', 'I']) + self._operator_array_from_str(2, ['I', 'Sp', 'Sm', 'I']) + exchange13 = self._operator_array_from_str(2, ['Sm', 'I', 'Sp', 'I']) + self._operator_array_from_str(2, ['Sp', 'I', 'Sm', 'I']) + expected_terms = [('np.pi*(2*v0-alpha0)', O0), + ('np.pi*(2*v1-alpha1)', O1), + ('np.pi*(2*v2-alpha2)', O2), + ('np.pi*(2*v3-alpha3)', O3), + ('np.pi*alpha0', OO0), + ('np.pi*alpha1', OO1), + ('np.pi*alpha2', OO2), + ('np.pi*alpha3', OO3), + ('2*np.pi*r0*D0', X0), + ('2*np.pi*r1*D1', X1), + ('2*np.pi*r2*D2', X2), + ('2*np.pi*r3*D3', X3), + ('2*np.pi*j01', exchange01), + ('2*np.pi*j02', exchange02), + ('2*np.pi*j03', exchange03), + ('2*np.pi*j12', exchange12), + ('2*np.pi*j13', exchange13), + ('2*np.pi*r0*U0', X0), + ('2*np.pi*r1*U1', X1), + ('2*np.pi*r0*U2', X0), + ('2*np.pi*r2*U3', X2), + ('2*np.pi*r0*U4', X0), + ('2*np.pi*r3*U5', X3), + ('2*np.pi*r1*U6', X1), + ('2*np.pi*r2*U7', X2), + ('2*np.pi*r1*U8', X1), + ('2*np.pi*r3*U9', X3)] + + # first check the number of terms is correct, then loop through + # each expected term and verify that it is present and consistent + self.assertEqual(len(ham_model._system), len(expected_terms)) + for expected_string, expected_op in expected_terms: + idx = 0 + found = False + while idx < len(ham_model._system) and found is False: + op, string = ham_model._system[idx] + if expected_string == string: + found = True + self.assertTrue(array_equal(expected_op, op)) + idx += 1 + self.assertTrue(found) + + def test_duffing_hamiltonian_dict(self): + """Test _duffing_hamiltonian_dict""" + + oscillators = [0, 1] + oscillator_dims = [2, 2] + oscillator_freqs = [5.0, 5.1] + freq_symbols = ['v0', 'v1'] + anharm_freqs = [-0.33, -0.33] + anharm_symbols = ['a0', 'a1'] + drive_strengths = [1.1, 1.2] + drive_symbols = ['r0', 'r1'] + ordered_coupling_edges = [(0,1)] + coupling_strengths = [0.02] + coupling_symbols = ['j'] + cr_idx_dict = {(0,1): 0} + + expected = {'h_str': ['np.pi*(2*v0-a0)*O0','np.pi*(2*v1-a1)*O1', + 'np.pi*a0*O0*O0', 'np.pi*a1*O1*O1', + '2*np.pi*r0*X0||D0', '2*np.pi*r1*X1||D1', + '2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)', + '2*np.pi*r0*X0||U0'], + 'vars': {'v0': 5.0, 'v1': 5.1, + 'a0': -0.33, 'a1' : -0.33, + 'r0': 1.1, 'r1' : 1.2, + 'j' : 0.02}, + 'qub': {'0': 2, '1': 2}} + output = model_gen._duffing_hamiltonian_dict(oscillators, + oscillator_dims, + oscillator_freqs, + freq_symbols, + anharm_freqs, + anharm_symbols, + drive_strengths, + drive_symbols, + ordered_coupling_edges, + coupling_strengths, + coupling_symbols, + cr_idx_dict) + self._compare_str_lists(output['h_str'], expected['h_str']) + self.assertEqual(output['vars'], expected['vars']) + self.assertEqual(output['qub'], expected['qub']) + + # test 3 oscillators with mixed up inputs + oscillators = [0, 1, 2] + oscillator_dims = [2, 2, 3] + oscillator_freqs = [5.0, 5.1, 4.9] + freq_symbols = ['v0', 'v1', 'x3'] + anharm_freqs = [-0.33, -0.33, 1.] + anharm_symbols = ['a0', 'a1', 'z4'] + drive_strengths = [1.1, 1.2, 0.98] + drive_symbols = ['r0', 'r1', 'sa'] + ordered_coupling_edges = [(0,1), (1,2), (2,0)] + coupling_strengths = [0.02, 0.1, 0.33] + coupling_symbols = ['j', 's', 'r'] + cr_idx_dict = {(0,1): 0, (2,0): 1, (1,2): 2} + + expected = {'h_str': ['np.pi*(2*v0-a0)*O0','np.pi*(2*v1-a1)*O1', 'np.pi*(2*x3-z4)*O2', + 'np.pi*a0*O0*O0', 'np.pi*a1*O1*O1', 'np.pi*z4*O2*O2', + '2*np.pi*r0*X0||D0', '2*np.pi*r1*X1||D1', '2*np.pi*sa*X2||D2', + '2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)','2*np.pi*s*(Sp1*Sm2+Sm1*Sp2)', + '2*np.pi*r*(Sp0*Sm2+Sm0*Sp2)', + '2*np.pi*r0*X0||U0', '2*np.pi*sa*X2||U1', '2*np.pi*r1*X1||U2'], + 'vars': {'v0': 5.0, 'v1': 5.1, 'x3': 4.9, + 'a0': -0.33, 'a1' : -0.33, 'z4': 1., + 'r0': 1.1, 'r1' : 1.2, 'sa': 0.98, + 'j' : 0.02, 's': 0.1, 'r': 0.33}, + 'qub': {'0': 2, '1': 2, '2': 3}} + output = model_gen._duffing_hamiltonian_dict(oscillators, + oscillator_dims, + oscillator_freqs, + freq_symbols, + anharm_freqs, + anharm_symbols, + drive_strengths, + drive_symbols, + ordered_coupling_edges, + coupling_strengths, + coupling_symbols, + cr_idx_dict) + self._compare_str_lists(output['h_str'], expected['h_str']) + self.assertEqual(output['vars'], expected['vars']) + self.assertEqual(output['qub'], expected['qub']) + + + + def test_cr_lo_list(self): + """Test _cr_lo_list""" + + cr_dict = {(0,1): 0, (1,0) : 1, (3,4) : 2} + expected = [[{'scale' : [1.0, 0], 'q' : 1}], + [{'scale' : [1.0, 0], 'q' : 0}], + [{'scale' : [1.0, 0], 'q' : 4}]] + self.assertEqual(model_gen._cr_lo_list(cr_dict), expected) + + cr_dict = {(0,1): 0, (3,4) : 2, (1,0) : 1} + expected = [[{'scale' : [1.0, 0], 'q' : 1}], + [{'scale' : [1.0, 0], 'q' : 0}], + [{'scale' : [1.0, 0], 'q' : 4}]] + self.assertEqual(model_gen._cr_lo_list(cr_dict), expected) + + def test_single_term_generators(self): + """Test various functions for individual terms: + _single_duffing_drift_terms, _drive_terms, _exchange_coupling_terms, _cr_terms + """ + + # single duffing terms + self.assertEqual(model_gen._single_duffing_drift_terms(freq_symbols='v', + anharm_symbols='a', + system_list=0), + ['np.pi*(2*v-a)*O0', 'np.pi*a*O0*O0']) + self.assertEqual(model_gen._single_duffing_drift_terms(freq_symbols=['v0','v1'], + anharm_symbols=['a0','a1'], + system_list=[2, 3]), + ['np.pi*(2*v0-a0)*O2', + 'np.pi*(2*v1-a1)*O3', + 'np.pi*a0*O2*O2', + 'np.pi*a1*O3*O3']) + + # drive terms + self.assertEqual(model_gen._drive_terms(drive_symbols='r', system_list=0), + ['2*np.pi*r*X0||D0']) + self.assertEqual(model_gen._drive_terms(drive_symbols=['r0', 'r1'], system_list=[1, 2]), + ['2*np.pi*r0*X1||D1', '2*np.pi*r1*X2||D2']) + + # exchange coupling + symbols = 'j' + edges = [(0,1)] + expected = ['2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)'] + self.assertEqual(model_gen._exchange_coupling_terms(symbols, edges), expected) + symbols = ['j','k'] + edges = [(0,1), (3,2)] + expected = ['2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)', '2*np.pi*k*(Sp3*Sm2+Sm3*Sp2)'] + self.assertEqual(model_gen._exchange_coupling_terms(symbols, edges), expected) + + # cross resonance terms + symbols = 'r' + driven_indices = 0 + u_channel_indices = [1] + expected = ['2*np.pi*r*X0||U1'] + self.assertEqual(model_gen._cr_terms(symbols, driven_indices, u_channel_indices), expected) + symbols = ['r','s'] + driven_indices = [0,3] + u_channel_indices = [1,1] + expected = ['2*np.pi*r*X0||U1', '2*np.pi*s*X3||U1'] + self.assertEqual(model_gen._cr_terms(symbols, driven_indices, u_channel_indices), expected) + + def test_str_list_generator(self): + """Test _str_list_generator""" + + # test one argument + template = 'First: {0}' + self.assertEqual(model_gen._str_list_generator(template, 'a'), ['First: a']) + self.assertEqual(model_gen._str_list_generator(template, ['a1', 'a2']), + ['First: a1', 'First: a2']) + + # test multiple arguments + template = 'First: {0}, Second: {1}' + self.assertEqual(model_gen._str_list_generator(template, 'a', 'b'), + ['First: a, Second: b']) + self.assertEqual(model_gen._str_list_generator(template, ['a1', 'a2'], ['b1', 'b2']), + ['First: a1, Second: b1', 'First: a2, Second: b2']) + + + def test_arg_to_iterable(self): + """Test _arg_to_iterable.""" + + self.assertEqual(model_gen._arg_to_iterable('a'), ['a']) + self.assertEqual(model_gen._arg_to_iterable(['a']), ['a']) + self.assertEqual(model_gen._arg_to_iterable(('a','b')), ('a','b')) + self.assertEqual(model_gen._arg_to_iterable({'a','b'}), {'a','b'}) + + def test_CouplingGraph(self): + """Test CouplingGraph class.""" + + coupling_graph = model_gen.CouplingGraph([(0,1), (1,0), (3,2), (1,2)]) + + # test constructor, including catching of duplicate entries + self.assertEqual(len(coupling_graph.graph), 3) + self.assertEqual(coupling_graph.sorted_graph, [(0,1), (1,2), (2,3)]) + self.assertEqual(coupling_graph.sorted_two_way_graph, + [(0,1), (1,0), (1,2), (2,1), (2,3), (3,2)]) + self.assertEqual(coupling_graph.two_way_graph_dict, + {(0,1): 0, (1,0) : 1, (1,2) : 2, (2,1) : 3, (2,3) : 4, (3,2) : 5}) + + # test sorted_edge_index, and that it treats (1,2) and (2,1) as the same edge + self.assertEqual(coupling_graph.sorted_edge_index((1,2)), 1) + self.assertEqual(coupling_graph.sorted_edge_index((2,1)), 1) + + # test two_way_edge_index, and that it treats (1,2) and (2,1) as different + self.assertEqual(coupling_graph.two_way_edge_index((1,2)), 2) + self.assertEqual(coupling_graph.two_way_edge_index((2,1)), 3) + + def _compare_str_lists(self, list1, list2): + """Helper function for checking that the contents of string lists are the same when order + doesn't matter. + + Args: + list1 (list): A list of strings + list2 (list): A list of strings + """ + + list1_copy = list1.copy() + list2_copy = list1.copy() + self.assertEqual(len(list1_copy), len(list2_copy)) + list1_copy.sort() + list2_copy.sort() + for str1, str2 in zip(list1_copy, list2_copy): + self.assertEqual(str1, str2) + + def _operator_array_from_str(self, dim, op_str_list): + + op = array([[1.]]) + for c in op_str_list: + op = kron(op, get_oper(c, dim)) + + return op diff --git a/test/terra/openpulse/test_system_models.py b/test/terra/openpulse/test_system_models.py index e1298afb58..f47e305b7a 100644 --- a/test/terra/openpulse/test_system_models.py +++ b/test/terra/openpulse/test_system_models.py @@ -10,10 +10,11 @@ # copyright notice, and modified files need to carry a notice indicating # that they have been altered from the originals. """ -Tests for option handling in digest.py +Tests for PulseSystemModel and HamiltonianModel functionality """ import unittest +import warnings from test.terra.common import QiskitAerTestCase import qiskit import qiskit.pulse as pulse @@ -24,7 +25,7 @@ class BaseTestPulseSystemModel(QiskitAerTestCase): - """Testing of functions in providers.aer.openpulse.qobj.digest.""" + """Tests for PulseSystemModel""" def setUp(self): self._default_qubit_lo_freq = [4.9, 5.0] @@ -64,6 +65,38 @@ def _simple_system_model(self, v0=5.0, v1=5.1, j=0.01, r=0.02, alpha0=-0.33, alp class TestPulseSystemModel(BaseTestPulseSystemModel): r"""Tests for Hamiltonian options and processing.""" + def test_control_channel_index(self): + """Test PulseSystemModel.control_channel_index().""" + + # get the model with no control channel dict yet + test_model = self._simple_system_model() + + # test that it gives a warning when a key has no corresponding control channel + with warnings.catch_warnings(record=True) as w: + # Cause all warnings to always be triggered. + warnings.simplefilter("always") + + ctrl_idx = test_model.control_channel_index('no_key') + + self.assertEqual(len(w), 1) + self.assertTrue('ControlChannel' in str(w[-1].message)) + + # add a control channel dict + test_model.control_channel_dict = {(0,1): 0} + + self.assertEqual(test_model.control_channel_index((0,1)), 0) + + # test that it still correctly gives a warning for nonexistant indices + with warnings.catch_warnings(record=True) as w: + # Cause all warnings to always be triggered. + warnings.simplefilter("always") + + ctrl_idx = test_model.control_channel_index((1,0)) + + self.assertEqual(len(w), 1) + self.assertTrue('ControlChannel' in str(w[-1].message)) + + def test_qubit_lo_default_from_backend(self): """Test drawing of defaults form a backend.""" test_model = self._simple_system_model() From e0aa05defd738e25c4be2c0d4b3b8903036a5202 Mon Sep 17 00:00:00 2001 From: Christopher Wood Date: Thu, 23 Jan 2020 12:06:19 -0500 Subject: [PATCH 23/24] Remove example dir --- example/duffing_model_example.ipynb | 386 ------------- example/pulse_sim.ipynb | 817 ---------------------------- example/pulse_sim_cy_fast.py | 272 --------- example/pulse_sim_fast.py | 271 --------- 4 files changed, 1746 deletions(-) delete mode 100644 example/duffing_model_example.ipynb delete mode 100644 example/pulse_sim.ipynb delete mode 100644 example/pulse_sim_cy_fast.py delete mode 100644 example/pulse_sim_fast.py diff --git a/example/duffing_model_example.ipynb b/example/duffing_model_example.ipynb deleted file mode 100644 index 5facedea5e..0000000000 --- a/example/duffing_model_example.ipynb +++ /dev/null @@ -1,386 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Duffing model generator usage example" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Demonstrating transmon model generator usage" - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# general libraries\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from scipy.optimize import curve_fit\n", - "\n", - "# qiskit and pulse stuff\n", - "import qiskit\n", - "import qiskit.pulse as pulse\n", - "import qiskit.pulse.pulse_lib as pulse_lib\n", - "from qiskit.compiler import assemble\n", - "\n", - "# new model generator function\n", - "from qiskit.providers.aer.openpulse.duffing_model_generators import duffing_system_model" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Specify system model\n", - "\n", - "Parameters here are based on `FakeOpenPulse2Q` so that the schedules from that notebook can be used here" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "# number of qubits and cutoff dimensions\n", - "dim_oscillators = 3\n", - "\n", - "# frequencies for duffing drift terms, harmonic term and anharmonic term\n", - "oscillator_freqs = [5.0, 5.1]\n", - "anharmonicity_freqs = [-0.33, -0.33]\n", - "\n", - "# oscillator drive strengths\n", - "drive_strengths = [0.02, 0.02]\n", - "\n", - "# specify coupling as a dictionary (it says qubits 0 and 1 are coupled with a coefficient 0.02)\n", - "coupling_dict = {(0,1): 0.01}\n", - "\n", - "# time \n", - "dt = 1.\n", - "\n", - "# create the model\n", - "system_model = duffing_system_model(dim_oscillators=dim_oscillators,\n", - " oscillator_freqs=oscillator_freqs,\n", - " anharm_freqs=anharmonicity_freqs,\n", - " drive_strengths=drive_strengths,\n", - " coupling_dict=coupling_dict,\n", - " dt=dt)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "The returned `system_model` is an instance of `PulseSystemModel`, consumable by the simulator representing the specified transmon system model." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Do Rabi experiment from previous example notebook using this model\n", - "\n", - "## First set up schedules" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [], - "source": [ - "#qubit to use for exeperiment\n", - "qubit = 0\n", - "# exp configuration\n", - "exps = 41\n", - "shots = 512\n", - "\n", - "# Rabi pulse\n", - "drive_amps = np.linspace(0, 0.9, exps)\n", - "drive_samples = 128\n", - "drive_sigma = 16\n", - "\n", - "# Measurement pulse\n", - "meas_amp = 0.025\n", - "meas_samples = 1200\n", - "meas_sigma = 4\n", - "meas_risefall = 25\n", - "\n", - "# Measurement pulse (common for all experiment)\n", - "meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp,\n", - " sigma=meas_sigma, risefall=meas_risefall, \n", - " name='meas_pulse')\n", - "acq_cmd=pulse.Acquire(duration=meas_samples)\n", - "\n", - "acquire_channels = [pulse.AcquireChannel(0), pulse.AcquireChannel(1)]\n", - "memoryslots = [pulse.MemorySlot(0), pulse.MemorySlot(1)]\n", - "\n", - "# create measurement schedule\n", - "measure_and_acquire = meas_pulse(pulse.MeasureChannel(0)) | acq_cmd(acquire_channels, memoryslots)\n", - "\n", - "# Create schedule\n", - "schedules = []\n", - "for ii, drive_amp in enumerate(drive_amps):\n", - " # drive pulse\n", - " rabi_pulse = pulse_lib.gaussian(duration=drive_samples, \n", - " amp=drive_amp, \n", - " sigma=drive_sigma, name='rabi_pulse_%d' % ii)\n", - " \n", - " # add commands to schedule\n", - " schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp)\n", - " \n", - " schedule += rabi_pulse(pulse.DriveChannel(0))\n", - " schedule += measure_and_acquire << schedule.duration\n", - " \n", - " schedules.append(schedule)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Set up simulation" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/dpuzzuoli/anaconda3/envs/QiskitDev/lib/python3.7/site-packages/qiskit/providers/models/pulsedefaults.py:166: UserWarning: `qubit_freq_est` and `meas_freq_est` now have units of Hertz(Hz) rather than gigahertz(GHz).\n", - " warnings.warn('`qubit_freq_est` and `meas_freq_est` now have units of '\n" - ] - } - ], - "source": [ - "# import simulator\n", - "backend_sim = qiskit.Aer.get_backend('pulse_simulator')\n", - "\n", - "# construct qobj. In this case we want to use channel frequencies computed directly from the Hamiltonian\n", - "qubit_lo_freq = system_model.hamiltonian.get_qubit_lo_from_drift()\n", - "rabi_qobj = assemble(schedules,\n", - " backend=backend_sim,\n", - " qubit_lo_freq=qubit_lo_freq,\n", - " meas_level=1, \n", - " meas_return='avg', \n", - " memory_slots=2,\n", - " shots=shots)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Run simulation" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "sim_result = backend_sim.run(rabi_qobj, system_model).result()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Extract results and plot" - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pi Amplitude 0.312173\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
          " - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "amp_data_Q0 = []\n", - "amp_data_Q1 = []\n", - "\n", - "for exp_idx in range(len(drive_amps)):\n", - " exp_mem = sim_result.get_memory(exp_idx)\n", - " amp_data_Q0.append(np.abs(exp_mem[0]))\n", - " amp_data_Q1.append(np.abs(exp_mem[1]))\n", - " \n", - "#Fit the data\n", - "fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B)\n", - "fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5])\n", - "\n", - "#get the pi amplitude\n", - "pi_amp = (fitparams[3])*fitparams[2]/2/np.pi\n", - "\n", - "plt.plot(drive_amps, amp_data_Q0, label='Q0')\n", - "plt.plot(drive_amps, amp_data_Q1, label='Q1')\n", - "plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit')\n", - "plt.axvline(pi_amp, color='black', linestyle='dashed')\n", - "plt.legend()\n", - "plt.xlabel('Pulse amplitude, a.u.', fontsize=20)\n", - "plt.ylabel('Signal, a.u.', fontsize=20)\n", - "plt.title('Rabi on Q0', fontsize=20)\n", - "plt.grid(True)\n", - "\n", - "print('Pi Amplitude %f'%(pi_amp))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Cross-Resonance\n", - "\n", - "Run the cross resonance (demonstrate usage of `cr_idx_dict`)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "#qubit to use for experiment\n", - "target_qubit = 0\n", - "driven_qubit = 1\n", - "\n", - "# drive qubit 1 with target 0\n", - "cr_idx = system_model.control_channel_index((driven_qubit, target_qubit))\n", - "\n", - "\n", - "# exp configuration\n", - "exps = 41\n", - "shots = 512\n", - "\n", - "# Rabi pulse\n", - "cr_drive_amps = np.linspace(0, 0.9, exps)\n", - "cr_drive_samples = 128*3\n", - "cr_drive_sigma = 4\n", - "\n", - "\n", - "# Create schedule\n", - "schedules = []\n", - "for ii, cr_drive_amp in enumerate(cr_drive_amps):\n", - " # drive pulse\n", - " cr_rabi_pulse = pulse_lib.gaussian_square(duration=cr_drive_samples, \n", - " amp=cr_drive_amp, \n", - " risefall=cr_drive_sigma*4,\n", - " sigma=cr_drive_sigma, name='rabi_pulse_%d' % ii)\n", - " \n", - " # add commands to schedule\n", - " schedule = pulse.Schedule(name='cr_rabi_exp_amp_%s' % cr_drive_amp)\n", - " \n", - " schedule += cr_rabi_pulse(pulse.ControlChannel(cr_idx))\n", - " schedule += measure_and_acquire << schedule.duration\n", - " \n", - " schedules.append(schedule)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
          " - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "# assemble, run experiment, plot data\n", - "cr_rabi_qobj = assemble(schedules, \n", - " qubit_lo_freq=qubit_lo_freq,\n", - " backend=backend_sim,\n", - " meas_level=1, \n", - " meas_return='avg', \n", - " memory_slots=2,\n", - " shots=shots)\n", - "sim_result = backend_sim.run(cr_rabi_qobj, system_model).result()\n", - "\n", - "amp_data_Q0 = []\n", - "amp_data_Q1 = []\n", - "\n", - "for exp_idx in range(len(cr_drive_amps)):\n", - " exp_mem = sim_result.get_memory(exp_idx)\n", - " amp_data_Q0.append(np.abs(exp_mem[0]))\n", - " amp_data_Q1.append(np.abs(exp_mem[1]))\n", - " \n", - "\n", - "plt.plot(drive_amps, amp_data_Q0, label='Q0')\n", - "plt.plot(drive_amps, amp_data_Q1, label='Q1')\n", - "plt.legend()\n", - "plt.xlabel('Pulse amplitude, a.u.', fontsize=20)\n", - "plt.ylabel('Signal, a.u.', fontsize=20)\n", - "plt.title('CR (Target Q{0}, driving on Q{1})'.format(str(target_qubit),str(driven_qubit)), fontsize=20)\n", - "plt.grid(True)" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/example/pulse_sim.ipynb b/example/pulse_sim.ipynb deleted file mode 100644 index 3d1902c25b..0000000000 --- a/example/pulse_sim.ipynb +++ /dev/null @@ -1,817 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Open Pulse Simulator - Rabi Example" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "If running the openpulse branch from source, may need to add a symbolic link in site-packages. Also run `python setup.py build_ext --inplace` in openpulse first." - ] - }, - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "# Import general libraries (needed for functions)\n", - "import numpy as np\n", - "import matplotlib.pyplot as plt\n", - "from scipy.optimize import curve_fit\n", - "\n", - "# Import Qiskit classes classes\n", - "import qiskit\n", - "#from qiskit.providers.aer.noise import NoiseModel\n", - "#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error\n", - "\n", - "import qiskit.pulse as pulse\n", - "import qiskit.pulse.pulse_lib as pulse_lib\n", - "from qiskit.compiler import assemble\n", - "import random\n", - "from qiskit.test.mock import FakeOpenPulse2Q" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "#Get a pulse configuration from the fake backend\n", - "backend_real = FakeOpenPulse2Q()" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/dpuzzuoli/anaconda3/envs/QiskitDev/lib/python3.7/site-packages/qiskit/providers/models/pulsedefaults.py:155: UserWarning: `qubit_freq_est` and `meas_freq_est` now have units of Hertz(Hz) rather than gigahertz(GHz).\n", - " warnings.warn('`qubit_freq_est` and `meas_freq_est` now have units of '\n", - "/Users/dpuzzuoli/anaconda3/envs/QiskitDev/lib/python3.7/site-packages/qiskit/providers/models/backendconfiguration.py:356: UserWarning: `dt` and `dtm` now have units of seconds(s) rather than nanoseconds(ns).\n", - " warnings.warn('`dt` and `dtm` now have units of seconds(s) rather '\n" - ] - } - ], - "source": [ - "# create a PulseSystemModel from the backend\n", - "# the PulseSystemModel stores model information for simulation of pulse schedules\n", - "from qiskit.providers.aer.openpulse.pulse_system_model import PulseSystemModel\n", - "system_model = PulseSystemModel.from_backend(backend_real)\n", - "\n", - "# set dt = 1 (this will need to be removed once backend has correct units)\n", - "system_model.dt = 1.\n", - "\n", - "# Get pulse simulator backend\n", - "backend_sim = qiskit.Aer.get_backend('pulse_simulator')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Simulations\n", - "\n", - "### These need to be run in sequential order\n", - "\n", - "[Rabi Oscillation](#rabi)\n", - "Apply a pulse to Q0 and measure the population evoluation versus pulse amplitude\n", - "\n", - "[Measurement Level 1 for the Readout Test](#readout_test)\n", - "
          Prepare the |0> and |1> states and look at the measurement level 1 output \n", - "\n", - "[CR Oscillation](#cr)\n", - "
          Look at the Q1 State when we drive Q0 at the frequency of Q1\n", - "\n", - "[T1](#t1)\n", - "
          Demonstrating noise with pulse" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
          \n", - "# Simulate a Rabi Oscillation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "First, we are going to simulate a rabi oscillation, i.e., meausure the qubit state population versus the amplitude of a drive pulse. This is the same example that is in the tutorials." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Build Pulse Schedule " - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Build on qubit 0" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "#qubit to use for exeperiment\n", - "qubit = 0\n", - "# exp configuration\n", - "exps = 41\n", - "shots = 512\n", - "\n", - "# Rabi pulse\n", - "drive_amps = np.linspace(0, 0.9, exps)\n", - "drive_samples = 128\n", - "drive_sigma = 16\n", - "\n", - "# Measurement pulse\n", - "meas_amp = 0.025\n", - "meas_samples = 1200\n", - "meas_sigma = 4\n", - "meas_risefall = 25\n", - "\n", - "# Measurement pulse (common for all experiment)\n", - "meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp,\n", - " sigma=meas_sigma, risefall=meas_risefall, \n", - " name='meas_pulse')\n", - "acq_cmd=pulse.Acquire(duration=meas_samples)\n", - "\n", - "acquire_channels = [pulse.AcquireChannel(0), pulse.AcquireChannel(1)]\n", - "memoryslots = [pulse.MemorySlot(0), pulse.MemorySlot(1)]\n", - "\n", - "# create measurement schedule\n", - "measure_and_acquire = meas_pulse(pulse.MeasureChannel(0)) | acq_cmd(acquire_channels, memoryslots)\n", - "\n", - "# Create schedule\n", - "schedules = []\n", - "for ii, drive_amp in enumerate(drive_amps):\n", - " # drive pulse\n", - " rabi_pulse = pulse_lib.gaussian(duration=drive_samples, \n", - " amp=drive_amp, \n", - " sigma=drive_sigma, name='rabi_pulse_%d' % ii)\n", - " \n", - " # add commands to schedule\n", - " schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp)\n", - " \n", - " schedule += rabi_pulse(pulse.DriveChannel(0))\n", - " schedule += measure_and_acquire << schedule.duration\n", - " \n", - " schedules.append(schedule)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Assemble qobj, using qubit_lo_freq as computed from the Hamiltonian\n", - "\n", - "Note: the one thing below not being used by the simulator is `meas_lo_freq`. This is normally drawn from the backend, but we could change it to be drawn from the `PulseSystemModel`." - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [], - "source": [ - "qubit_lo_freq = system_model.hamiltonian.get_qubit_lo_from_drift()\n", - "\n", - "rabi_qobj = assemble(schedules,\n", - " backend=backend_sim,\n", - " qubit_lo_freq=qubit_lo_freq,\n", - " meas_level=1, \n", - " meas_return='avg', \n", - " memory_slots=2,\n", - " shots=shots)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Note: The above command can now be called without the arguments `meas_level`, `meas_return`, `memory_slots`, and `shots`, as they will be populated with defaults." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Setup backend_options for simulation" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "These are additional solver options, which for now we don't need." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [], - "source": [ - "backend_options = {}" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Simulate" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "#Note: this is how to run bypassing the backend\n", - "#opsys = qiskit.providers.aer.openpulse.qobj.digest.digest_pulse_obj(rabi_qobj.to_dict())\n", - "#simdata = qiskit.providers.aer.openpulse.solver.opsolve.opsolve(opsys)" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [], - "source": [ - "sim_result = backend_sim.run(rabi_qobj, system_model).result()" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "128.0" - ] - }, - "execution_count": 9, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#get the end time of the simulation in dt\n", - "sim_result.results[0].header.ode_t" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "array([1.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j, 0.+0.j,\n", - " 0.+0.j])" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "#get the statevector IN THE FRAME OF THE ORIGINAL HAMILTONIAN\n", - "sim_result.get_statevector(0)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Extract the qubit populations " - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [], - "source": [ - "amp_data_Q0 = []\n", - "amp_data_Q1 = []\n", - "\n", - "for exp_idx in range(len(drive_amps)):\n", - " exp_mem = sim_result.get_memory(exp_idx)\n", - " amp_data_Q0.append(np.abs(exp_mem[0]))\n", - " amp_data_Q1.append(np.abs(exp_mem[1]))" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Pi Amplitude 0.312279\n" - ] - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
          " - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#Fit the data\n", - "fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B)\n", - "fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5])\n", - "\n", - "#get the pi amplitude\n", - "pi_amp = (fitparams[3])*fitparams[2]/2/np.pi\n", - "\n", - "plt.plot(drive_amps, amp_data_Q0, label='Q0')\n", - "plt.plot(drive_amps, amp_data_Q1, label='Q1')\n", - "plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit')\n", - "plt.axvline(pi_amp, color='black', linestyle='dashed')\n", - "plt.legend()\n", - "plt.xlabel('Pulse amplitude, a.u.', fontsize=20)\n", - "plt.ylabel('Signal, a.u.', fontsize=20)\n", - "plt.title('Rabi on Q0', fontsize=20)\n", - "plt.grid(True)\n", - "\n", - "print('Pi Amplitude %f'%(pi_amp))" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "# Look at the Shots Distribution" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Using the pulse amplitude calibrated above, do an experiment with no pulse and an experiment with a pi pulse and look at the measurement outcomes. " - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "# Create schedule\n", - "pi_pulse = pulse_lib.gaussian(duration=drive_samples,\n", - " amp=pi_amp, \n", - " sigma=drive_sigma,\n", - " name='pi_pulse')\n", - "\n", - "pi_2_pulse = pulse_lib.gaussian(duration=drive_samples,\n", - " amp=pi_amp/2, \n", - " sigma=drive_sigma,\n", - " name='pi_2_pulse')\n", - " \n", - "# excited\n", - "excited_exp = pulse.Schedule(name='pi_exp')\n", - "excited_exp += pi_pulse(pulse.DriveChannel(0))\n", - "measure_time = excited_exp.duration\n", - "excited_exp |= measure_and_acquire << measure_time\n", - "\n", - "# superposition\n", - "sup_exp = pulse.Schedule(name='pi_2_exp')\n", - "sup_exp += pi_2_pulse(pulse.DriveChannel(0))\n", - "measure_time = sup_exp.duration\n", - "sup_exp |= measure_and_acquire << measure_time\n", - "\n", - "# ground\n", - "ground_exp = pulse.Schedule(name='no_pi_exp')\n", - "ground_exp |= pulse.Schedule(name='ground_exp')\n", - "ground_exp |= measure_and_acquire << measure_time \n", - "\n", - "excited_exp_schedules = [ground_exp, sup_exp, excited_exp]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Change the `meas_return=single` which will return each individual measurement" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "readout_qobj = assemble(excited_exp_schedules, \n", - " qubit_lo_freq=qubit_lo_freq,\n", - " meas_lo_freq = [0.,0.], \n", - " meas_level=1, \n", - " meas_return='single', \n", - " memory_slots=2,\n", - " shots=shots)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "sim_result = backend_sim.run(readout_qobj, system_model, backend_options).result()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Plot the data, there is no measurement error in the simulator data so the histographs will be all centered at the average point." - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "ground_data = sim_result.get_memory(0)[:, qubit]\n", - "excited_data = sim_result.get_memory(2)[:, qubit]\n", - "sup_data = sim_result.get_memory(1)[:, qubit]" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Add some random noise to the data to better approximate the experiment" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "for idx in range(len(ground_data)):\n", - " ground_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1)\n", - " excited_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1)\n", - " sup_data[idx] += random.gauss(0,0.1)+1j*random.gauss(0,0.1)" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "Text(0, 0.5, 'Q (a.u.)')" - ] - }, - "execution_count": 18, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
          " - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "\n", - "plt.scatter(np.real(ground_data), np.imag(ground_data), s=5, cmap='viridis',c='blue',alpha=0.5, label='|0>')\n", - "plt.scatter(np.real(excited_data), np.imag(excited_data), s=5, cmap='viridis',c='green',alpha=0.5, label='|1>')\n", - "plt.scatter(np.real(sup_data), np.imag(sup_data), s=5, cmap='viridis',c='red',alpha=0.5, label='|0>+|1>')\n", - "ground_center = np.mean(ground_data)\n", - "excited_center = np.mean(excited_data)\n", - "sup_center = np.mean(sup_data)\n", - "\n", - "plt.scatter(np.real(ground_center), np.imag(ground_center), c='blue', s=200, alpha=1.0)\n", - "plt.scatter(np.real(excited_center), np.imag(excited_center), c='green', s=200, alpha=1.0)\n", - "plt.scatter(np.real(sup_center), np.imag(sup_center), c='red', s=200, alpha=1.0)\n", - "\n", - "plt.title('Kernel integrated I-Q scatter plot', fontsize=20)\n", - "plt.legend(loc='upper right')\n", - "plt.xlabel('I (a.u.)', fontsize=16)\n", - "plt.ylabel('Q (a.u.)', fontsize=16)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "# Cross-Resonance" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Simulate cross-resonance by driving on U0. Note you need to run Rabi first to setup the hamiltonian." - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "#qubit to use for experiment\n", - "qubit = 0\n", - "# exp configuration\n", - "exps = 41\n", - "shots = 512\n", - "\n", - "# Rabi pulse\n", - "cr_drive_amps = np.linspace(0, 0.9, exps)\n", - "cr_drive_samples = 128*3\n", - "cr_drive_sigma = 4\n", - "\n", - "\n", - "# Create schedule\n", - "schedules = []\n", - "for ii, cr_drive_amp in enumerate(cr_drive_amps):\n", - " # drive pulse\n", - " cr_rabi_pulse = pulse_lib.gaussian_square(duration=cr_drive_samples, \n", - " amp=cr_drive_amp, \n", - " risefall=cr_drive_sigma*4,\n", - " sigma=cr_drive_sigma, name='rabi_pulse_%d' % ii)\n", - " \n", - " # add commands to schedule\n", - " schedule = pulse.Schedule(name='cr_rabi_exp_amp_%s' % cr_drive_amp)\n", - " \n", - " schedule += cr_rabi_pulse(pulse.ControlChannel(0))\n", - " schedule += measure_and_acquire << schedule.duration\n", - " \n", - " schedules.append(schedule)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "cr_rabi_qobj = assemble(schedules, \n", - " qubit_lo_freq=qubit_lo_freq,\n", - " meas_lo_freq=[0.,0.],\n", - " meas_level=1, \n", - " meas_return='avg', \n", - " memory_slots=2,\n", - " shots=shots)" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "sim_result = backend_sim.run(cr_rabi_qobj, system_model, backend_options).result()" - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "amp_data_Q0 = []\n", - "amp_data_Q1 = []\n", - "\n", - "for exp_idx in range(len(cr_drive_amps)):\n", - " exp_mem = sim_result.get_memory(exp_idx)\n", - " amp_data_Q0.append(np.abs(exp_mem[0]))\n", - " amp_data_Q1.append(np.abs(exp_mem[1]))" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
          " - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "plt.plot(drive_amps, amp_data_Q0, label='Q0')\n", - "plt.plot(drive_amps, amp_data_Q1, label='Q1')\n", - "plt.legend()\n", - "plt.xlabel('Pulse amplitude, a.u.', fontsize=20)\n", - "plt.ylabel('Signal, a.u.', fontsize=20)\n", - "plt.title('CR (Target Q1, driving on Q0)', fontsize=20)\n", - "plt.grid(True)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "\n", - "# T1" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Using the calibrated Pi pulse add a T1 decay channel and simulate a t1 experiment. This can take a while to run. The noise operators in pulse are still a work in progress." - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "\n", - "t1_times = np.linspace(0,500,10)\n", - "t1_times = np.array(t1_times, dtype=int)\n", - "\n", - "T1_exps = []\n", - "for kk in range(len(t1_times)):\n", - " schedule = pulse.Schedule(name='T1_{}'.format(kk))\n", - " schedule |= pi_pulse(pulse.DriveChannel(0)) << schedule.duration\n", - " schedule |= measure_and_acquire << int(t1_times[kk]) + schedule.duration\n", - " T1_exps.append(schedule)" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "# Add noise to the Hamiltonian on qubit '0'\n", - "noise_model = {\"qubit\": {\"0\": {\"Sm\": 0.006}}}" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "t1_qobj = assemble(T1_exps, \n", - " qubit_lo_freq=qubit_lo_freq,\n", - " meas_lo_freq=[0.,0.],\n", - " meas_level=1, \n", - " meas_return='avg', \n", - " memory_slots=2,\n", - " shots=100)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/dpuzzuoli/Documents/projects/qiskit-aer/qiskit/providers/aer/openpulse/qobj/digest.py:215: UserWarning: Noise models are an untested feature, and therefore may not behave as expected.\n", - " warn(warning_str.format('Noise models'))\n" - ] - } - ], - "source": [ - "sim_result_t1 = backend_sim.run(t1_qobj, system_model, backend_options, noise_model).result()" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "t1_data_Q0 = []\n", - "t1_data_Q1 = []\n", - "\n", - "\n", - "for exp_idx in range(len(t1_times)):\n", - " exp_mem = sim_result_t1.get_memory(exp_idx)\n", - " t1_data_Q0.append(np.abs(exp_mem[0]))\n", - " t1_data_Q1.append(np.abs(exp_mem[1]))\n" - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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\n", - "text/plain": [ - "
          " - ] - }, - "metadata": { - "needs_background": "light" - }, - "output_type": "display_data" - } - ], - "source": [ - "#Fit the data\n", - "fit_func_t1 = lambda x,A,B,T: (A*np.exp(-x/T)+B)\n", - "fitparams, conv = curve_fit(fit_func_t1, t1_times, t1_data_Q0, [0.5,0.5,100])\n", - "\n", - "\n", - "plt.plot(t1_times, t1_data_Q0, label='Q0')\n", - "plt.plot(t1_times, t1_data_Q1, label='Q1')\n", - "plt.plot(t1_times, fit_func_t1(t1_times, *fitparams), color='black', linestyle='dashed', label='Fit')\n", - "\n", - "plt.legend()\n", - "plt.xlabel('Wait Time (dt)', fontsize=20)\n", - "plt.ylabel('Signal, a.u.', fontsize=20)\n", - "plt.ylim([0,1.05])\n", - "plt.title('T1 on Q0', fontsize=20)\n", - "plt.grid(True)\n" - ] - }, - { - "cell_type": "code", - "execution_count": null, - "metadata": {}, - "outputs": [], - "source": [] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.7.5" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/example/pulse_sim_cy_fast.py b/example/pulse_sim_cy_fast.py deleted file mode 100644 index 0b60aaffec..0000000000 --- a/example/pulse_sim_cy_fast.py +++ /dev/null @@ -1,272 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Open Pulse Simulator - Rabi Example - -# If running the openpulse branch from source, may need to add a symbolic link in site-packages. Also run `python setup.py build_ext --inplace` in openpulse first. - -# In[1]: - - -#Import general libraries (needed for functions) -import numpy as np -import matplotlib.pyplot as plt -from scipy.optimize import curve_fit - -#Import Qiskit classes classes -import qiskit -#from qiskit.providers.aer.noise import NoiseModel -#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error - -import qiskit.pulse as pulse -import qiskit.pulse.pulse_lib as pulse_lib -from qiskit.compiler import assemble -import random -from qiskit.test.mock import FakeOpenPulse2Q - - -# In[2]: - - -#Get a pulse configuration from the fake backend -backend_real = FakeOpenPulse2Q() -configuration = backend_real.configuration() -system = pulse.PulseChannelSpec.from_backend(backend_real) - - -# In[3]: - - -#Get pulse simulator backend -backend_sim = qiskit.Aer.get_backend('pulse_simulator') - - -# ## Simulations -# -# ### These need to be run in sequential order -# -# [Rabi Oscillation](#rabi) -# Apply a pulse to Q0 and measure the population evoluation versus pulse amplitude -# -# [Measurement Level 1 for the Readout Test](#readout_test) -#
          Prepare the |0> and |1> states and look at the measurement level 1 output -# -# [CR Oscillation](#cr) -#
          Look at the Q1 State when we drive Q0 at the frequency of Q1 -# -# [T1](#t1) -#
          Demonstrating noise with pulse - -# -# # Simulate a Rabi Oscillation - -# First, we are going to simulate a rabi oscillation, i.e., meausure the qubit state population versus the amplitude of a drive pulse. This is the same example that is in the tutorials. - -# ### Build Pulse Schedule - -# Build on qubit 0 - -# In[4]: - - -#qubit to use for exeperiment -qubit = 0 -# exp configuration -exps = 41 -shots = 512 - -# Rabi pulse -drive_amps = np.linspace(0, 0.9, exps) -drive_samples = 128 -drive_sigma = 16 - -# Measurement pulse -meas_amp = 0.025 -meas_samples = 1200 -meas_sigma = 4 -meas_risefall = 25 - -# Measurement pulse (common for all experiment) -meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp, - sigma=meas_sigma, risefall=meas_risefall, - name='meas_pulse') -acq_cmd=pulse.Acquire(duration=meas_samples) - -# create measurement schedule -measure_and_acquire = meas_pulse(system.qubits[qubit].measure) | acq_cmd(system.acquires, system.memoryslots) - -# Create schedule -schedules = [] -for ii, drive_amp in enumerate(drive_amps): - # drive pulse - rabi_pulse = pulse_lib.gaussian(duration=drive_samples, - amp=drive_amp, - sigma=drive_sigma, name='rabi_pulse_%d' % ii) - - # add commands to schedule - schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp) - - schedule += rabi_pulse(system.qubits[qubit].drive) - schedule += measure_and_acquire << schedule.duration - - schedules.append(schedule) - - -# ### Design the Hamiltonian - -# Let's build a transmon Hamiltonian with anharmonicity to test the Rabi oscillation and CR - -# In[5]: - - -hamiltonian = {} -hamiltonian['h_str'] = [] -#Q0 terms -hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0') -hamiltonian['h_str'].append('np.pi*alpha0*O0*O0') -hamiltonian['h_str'].append('2*np.pi*r*X0||D0') -hamiltonian['h_str'].append('2*np.pi*r*X0||U1') -hamiltonian['h_str'].append('2*np.pi*r*X1||U0') - -#Q1 terms -hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1') -hamiltonian['h_str'].append('np.pi*alpha1*O1*O1') -hamiltonian['h_str'].append('2*np.pi*r*X1||D1') - -#Exchange coupling betwene Q0 and Q1 -hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)') -hamiltonian['vars'] = {'v0': 5.00, 'v1': 5.1, 'j': 0.01, - 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33} - -#set the qubit dimensions to 3 -hamiltonian['qub'] = {'0': 3, '1': 3} - - -# ### Setup backend_options for simulation - -# First copy the real-device configuration to our backend options, then override the Hamiltonian with our custom Hamiltonian, and add any additional solver options. - -# In[6]: - - -backend_options = configuration.to_dict() -backend_options['hamiltonian'] = hamiltonian -backend_options['dt'] = 1.0 -backend_options['ode_options'] = {} -backend_options['use_cpp_ode_func'] = False - - -# ### Restrict the Qubits Used in the Simulation - -# We can use a qubit whitelist (`qubit_list`) to restrict the set of qubits used in the solution. The pulse simulator will appropriately alter the Hamiltonian. To start let's assume the list contains the first 2 qubits. - -# In[7]: - - -backend_options['qubit_list'] = [0, 1] -#backend_options['qubit_list'] = None - - -# ### Assemble the qobj with the backend config file and the qubit_list - -# We have to do this step twice to get the dressed frequencies for setting the LO's. Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state. - -# In[8]: - - -rabi_qobj_no_lo = assemble(schedules, backend_real, - meas_level=1, meas_return='avg', - memory_slots=2, - shots=shots) - - -# In[9]: - - -evals, estates = backend_sim.get_dressed_energies(rabi_qobj_no_lo, - backend_options=backend_options) - - -# In[10]: - - -evals/2/np.pi - - -# In[11]: - - -qubit_lo_freq = [evals[1]/2/np.pi, evals[3]/2/np.pi] - -rabi_qobj = assemble(schedules, backend_real, - meas_level=1, meas_return='avg', - memory_slots=2, qubit_lo_freq=qubit_lo_freq, - shots=shots) - - -# ### Simulate - -# In[12]: - - -#Note: this is how to run bypassing the backend -#opsys = qiskit.providers.aer.openpulse.qobj.digest.digest_pulse_obj(rabi_qobj.to_dict()) -#simdata = qiskit.providers.aer.openpulse.solver.opsolve.opsolve(opsys) - - -# In[13]: - - -sim_result = backend_sim.run(rabi_qobj, backend_options=backend_options).result() - - -# In[14]: - - -#get the end time of the simulation in dt -sim_result.results[0].header.ode_t - - -# In[15]: - - -#get the statevector IN THE FRAME OF THE ORIGINAL HAMILTONIAN -sim_result.get_statevector(0) - - -# Extract the qubit populations - -# In[16]: - - -amp_data_Q0 = [] -amp_data_Q1 = [] - -for exp_idx in range(len(drive_amps)): - exp_mem = sim_result.get_memory(exp_idx) - amp_data_Q0.append(np.abs(exp_mem[0])) - amp_data_Q1.append(np.abs(exp_mem[1])) - - -# In[17]: - - -#Fit the data -fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B) -fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5]) - -#get the pi amplitude -pi_amp = (fitparams[3])*fitparams[2]/2/np.pi - -plt.plot(drive_amps, amp_data_Q0, label='Q0') -plt.plot(drive_amps, amp_data_Q1, label='Q1') -plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit') -plt.axvline(pi_amp, color='black', linestyle='dashed') -plt.legend() -plt.xlabel('Pulse amplitude, a.u.', fontsize=20) -plt.ylabel('Signal, a.u.', fontsize=20) -plt.title('Rabi on Q0', fontsize=20) -plt.grid(True) - -print('Pi Amplitude %f'%(pi_amp)) - diff --git a/example/pulse_sim_fast.py b/example/pulse_sim_fast.py deleted file mode 100644 index 16ed207a79..0000000000 --- a/example/pulse_sim_fast.py +++ /dev/null @@ -1,271 +0,0 @@ -#!/usr/bin/env python -# coding: utf-8 - -# ## Open Pulse Simulator - Rabi Example - -# If running the openpulse branch from source, may need to add a symbolic link in site-packages. Also run `python setup.py build_ext --inplace` in openpulse first. - -# In[1]: - - -#Import general libraries (needed for functions) -import numpy as np -import matplotlib.pyplot as plt -from scipy.optimize import curve_fit - -#Import Qiskit classes classes -import qiskit -#from qiskit.providers.aer.noise import NoiseModel -#from qiskit.providers.aer.noise.errors.standard_errors import depolarizing_error, thermal_relaxation_error - -import qiskit.pulse as pulse -import qiskit.pulse.pulse_lib as pulse_lib -from qiskit.compiler import assemble -import random -from qiskit.test.mock import FakeOpenPulse2Q - - -# In[2]: - - -#Get a pulse configuration from the fake backend -backend_real = FakeOpenPulse2Q() -configuration = backend_real.configuration() -system = pulse.PulseChannelSpec.from_backend(backend_real) - - -# In[3]: - - -#Get pulse simulator backend -backend_sim = qiskit.Aer.get_backend('pulse_simulator') - - -# ## Simulations -# -# ### These need to be run in sequential order -# -# [Rabi Oscillation](#rabi) -# Apply a pulse to Q0 and measure the population evoluation versus pulse amplitude -# -# [Measurement Level 1 for the Readout Test](#readout_test) -#
          Prepare the |0> and |1> states and look at the measurement level 1 output -# -# [CR Oscillation](#cr) -#
          Look at the Q1 State when we drive Q0 at the frequency of Q1 -# -# [T1](#t1) -#
          Demonstrating noise with pulse - -# -# # Simulate a Rabi Oscillation - -# First, we are going to simulate a rabi oscillation, i.e., meausure the qubit state population versus the amplitude of a drive pulse. This is the same example that is in the tutorials. - -# ### Build Pulse Schedule - -# Build on qubit 0 - -# In[4]: - - -#qubit to use for exeperiment -qubit = 0 -# exp configuration -exps = 41 -shots = 512 - -# Rabi pulse -drive_amps = np.linspace(0, 0.9, exps) -drive_samples = 128 -drive_sigma = 16 - -# Measurement pulse -meas_amp = 0.025 -meas_samples = 1200 -meas_sigma = 4 -meas_risefall = 25 - -# Measurement pulse (common for all experiment) -meas_pulse = pulse_lib.gaussian_square(duration=meas_samples, amp=meas_amp, - sigma=meas_sigma, risefall=meas_risefall, - name='meas_pulse') -acq_cmd=pulse.Acquire(duration=meas_samples) - -# create measurement schedule -measure_and_acquire = meas_pulse(system.qubits[qubit].measure) | acq_cmd(system.acquires, system.memoryslots) - -# Create schedule -schedules = [] -for ii, drive_amp in enumerate(drive_amps): - # drive pulse - rabi_pulse = pulse_lib.gaussian(duration=drive_samples, - amp=drive_amp, - sigma=drive_sigma, name='rabi_pulse_%d' % ii) - - # add commands to schedule - schedule = pulse.Schedule(name='rabi_exp_amp_%s' % drive_amp) - - schedule += rabi_pulse(system.qubits[qubit].drive) - schedule += measure_and_acquire << schedule.duration - - schedules.append(schedule) - - -# ### Design the Hamiltonian - -# Let's build a transmon Hamiltonian with anharmonicity to test the Rabi oscillation and CR - -# In[5]: - - -hamiltonian = {} -hamiltonian['h_str'] = [] -#Q0 terms -hamiltonian['h_str'].append('np.pi*(2*v0-alpha0)*O0') -hamiltonian['h_str'].append('np.pi*alpha0*O0*O0') -hamiltonian['h_str'].append('2*np.pi*r*X0||D0') -hamiltonian['h_str'].append('2*np.pi*r*X0||U1') -hamiltonian['h_str'].append('2*np.pi*r*X1||U0') - -#Q1 terms -hamiltonian['h_str'].append('np.pi*(2*v1-alpha1)*O1') -hamiltonian['h_str'].append('np.pi*alpha1*O1*O1') -hamiltonian['h_str'].append('2*np.pi*r*X1||D1') - -#Exchange coupling betwene Q0 and Q1 -hamiltonian['h_str'].append('2*np.pi*j*(Sp0*Sm1+Sm0*Sp1)') -hamiltonian['vars'] = {'v0': 5.00, 'v1': 5.1, 'j': 0.01, - 'r': 0.02, 'alpha0': -0.33, 'alpha1': -0.33} - -#set the qubit dimensions to 3 -hamiltonian['qub'] = {'0': 3, '1': 3} - - -# ### Setup backend_options for simulation - -# First copy the real-device configuration to our backend options, then override the Hamiltonian with our custom Hamiltonian, and add any additional solver options. - -# In[6]: - - -backend_options = configuration.to_dict() -backend_options['hamiltonian'] = hamiltonian -backend_options['dt'] = 1.0 -backend_options['ode_options'] = {} - - -# ### Restrict the Qubits Used in the Simulation - -# We can use a qubit whitelist (`qubit_list`) to restrict the set of qubits used in the solution. The pulse simulator will appropriately alter the Hamiltonian. To start let's assume the list contains the first 2 qubits. - -# In[7]: - - -backend_options['qubit_list'] = [0, 1] -#backend_options['qubit_list'] = None - - -# ### Assemble the qobj with the backend config file and the qubit_list - -# We have to do this step twice to get the dressed frequencies for setting the LO's. Note here that we set `meas_level=1` and `meas_return=avg` which will return the average probability for the qubit to be in the |1> state. - -# In[8]: - - -rabi_qobj_no_lo = assemble(schedules, backend_real, - meas_level=1, meas_return='avg', - memory_slots=2, - shots=shots) - - -# In[9]: - - -evals, estates = backend_sim.get_dressed_energies(rabi_qobj_no_lo, - backend_options=backend_options) - - -# In[10]: - - -evals/2/np.pi - - -# In[11]: - - -qubit_lo_freq = [evals[1]/2/np.pi, evals[3]/2/np.pi] - -rabi_qobj = assemble(schedules, backend_real, - meas_level=1, meas_return='avg', - memory_slots=2, qubit_lo_freq=qubit_lo_freq, - shots=shots) - - -# ### Simulate - -# In[12]: - - -#Note: this is how to run bypassing the backend -#opsys = qiskit.providers.aer.openpulse.qobj.digest.digest_pulse_obj(rabi_qobj.to_dict()) -#simdata = qiskit.providers.aer.openpulse.solver.opsolve.opsolve(opsys) - - -# In[13]: - - -sim_result = backend_sim.run(rabi_qobj, backend_options=backend_options).result() - - -# In[14]: - - -#get the end time of the simulation in dt -sim_result.results[0].header.ode_t - - -# In[15]: - - -#get the statevector IN THE FRAME OF THE ORIGINAL HAMILTONIAN -sim_result.get_statevector(0) - - -# Extract the qubit populations - -# In[16]: - - -amp_data_Q0 = [] -amp_data_Q1 = [] - -for exp_idx in range(len(drive_amps)): - exp_mem = sim_result.get_memory(exp_idx) - amp_data_Q0.append(np.abs(exp_mem[0])) - amp_data_Q1.append(np.abs(exp_mem[1])) - - -# In[17]: - - -#Fit the data -fit_func = lambda x,A,B,T,phi: (A*np.cos(2*np.pi*x/T+phi)+B) -fitparams, conv = curve_fit(fit_func, drive_amps, amp_data_Q0, [0.5,0.5,0.6,1.5]) - -#get the pi amplitude -pi_amp = (fitparams[3])*fitparams[2]/2/np.pi - -plt.plot(drive_amps, amp_data_Q0, label='Q0') -plt.plot(drive_amps, amp_data_Q1, label='Q1') -plt.plot(drive_amps, fit_func(drive_amps, *fitparams), color='black', linestyle='dashed', label='Fit') -plt.axvline(pi_amp, color='black', linestyle='dashed') -plt.legend() -plt.xlabel('Pulse amplitude, a.u.', fontsize=20) -plt.ylabel('Signal, a.u.', fontsize=20) -plt.title('Rabi on Q0', fontsize=20) -plt.grid(True) - -print('Pi Amplitude %f'%(pi_amp)) - From afb13af22130057c5a08f9e9398b30c6f9930551 Mon Sep 17 00:00:00 2001 From: Juan Gomez Date: Thu, 23 Jan 2020 19:14:07 +0100 Subject: [PATCH 24/24] Cleanup build system for pulse simulator * Add muparserx submodule needed by the pulse simulator solver * Moved muparserx library to tag v4.0.8 * Fix git submodules in Azure Pipelines CI * Integrate muparserx source code dependency into the build system This way there's no need for anyone to explicitly initialize submodules, and installations without git presence like `pip install https://....zip` will clone from muparserx repo and checkout the correct commit --- .gitmodules | 3 + CMakeLists.txt | 3 +- azure-pipelines.yml | 3 + cmake/compiler_utils.cmake | 38 + setup.py | 59 - .../open_pulse/eval_hamiltonian.hpp | 2 +- src/simulators/open_pulse/python_to_cpp.hpp | 1 - src/third-party/headers/muparserx | 1 + src/third-party/headers/muparserx/mpError.cpp | 266 --- .../headers/muparserx/mpFuncCmplx.cpp | 635 ------ .../headers/muparserx/mpFuncCommon.cpp | 272 --- .../headers/muparserx/mpFuncMatrix.cpp | 249 --- .../headers/muparserx/mpFuncNonCmplx.cpp | 126 -- .../headers/muparserx/mpFuncStr.cpp | 180 -- .../headers/muparserx/mpICallback.cpp | 141 -- src/third-party/headers/muparserx/mpIOprt.cpp | 170 -- .../headers/muparserx/mpIPackage.cpp | 51 - .../headers/muparserx/mpIToken.cpp | 325 --- .../headers/muparserx/mpIValReader.cpp | 72 - .../headers/muparserx/mpIValue.cpp | 449 ---- .../headers/muparserx/mpIfThenElse.cpp | 100 - .../headers/muparserx/mpOprtBinAssign.cpp | 249 --- .../headers/muparserx/mpOprtBinCommon.cpp | 589 ------ .../headers/muparserx/mpOprtCmplx.cpp | 321 --- .../headers/muparserx/mpOprtIndex.cpp | 117 -- .../headers/muparserx/mpOprtMatrix.cpp | 182 -- .../headers/muparserx/mpOprtNonCmplx.cpp | 423 ---- .../headers/muparserx/mpOprtPostfixCommon.cpp | 112 - .../headers/muparserx/mpPackageCmplx.cpp | 102 - .../headers/muparserx/mpPackageCommon.cpp | 141 -- .../headers/muparserx/mpPackageMatrix.cpp | 82 - .../headers/muparserx/mpPackageNonCmplx.cpp | 108 - .../headers/muparserx/mpPackageStr.cpp | 81 - .../headers/muparserx/mpPackageUnit.cpp | 119 -- .../headers/muparserx/mpParser.cpp | 91 - .../headers/muparserx/mpParserBase.cpp | 1301 ------------ .../muparserx/mpParserMessageProvider.cpp | 181 -- src/third-party/headers/muparserx/mpRPN.cpp | 186 -- .../headers/muparserx/mpScriptTokens.cpp | 74 - src/third-party/headers/muparserx/mpTest.cpp | 1809 ----------------- .../headers/muparserx/mpTokenReader.cpp | 1013 --------- .../headers/muparserx/mpValReader.cpp | 347 ---- src/third-party/headers/muparserx/mpValue.cpp | 804 -------- .../headers/muparserx/mpValueCache.cpp | 105 - .../headers/muparserx/mpVariable.cpp | 395 ---- 45 files changed, 48 insertions(+), 12030 deletions(-) create mode 100644 .gitmodules create mode 160000 src/third-party/headers/muparserx delete mode 100644 src/third-party/headers/muparserx/mpError.cpp delete mode 100644 src/third-party/headers/muparserx/mpFuncCmplx.cpp delete mode 100644 src/third-party/headers/muparserx/mpFuncCommon.cpp delete mode 100644 src/third-party/headers/muparserx/mpFuncMatrix.cpp delete mode 100644 src/third-party/headers/muparserx/mpFuncNonCmplx.cpp delete mode 100644 src/third-party/headers/muparserx/mpFuncStr.cpp delete mode 100644 src/third-party/headers/muparserx/mpICallback.cpp delete mode 100644 src/third-party/headers/muparserx/mpIOprt.cpp delete mode 100644 src/third-party/headers/muparserx/mpIPackage.cpp delete mode 100644 src/third-party/headers/muparserx/mpIToken.cpp delete mode 100644 src/third-party/headers/muparserx/mpIValReader.cpp delete mode 100644 src/third-party/headers/muparserx/mpIValue.cpp delete mode 100644 src/third-party/headers/muparserx/mpIfThenElse.cpp delete mode 100644 src/third-party/headers/muparserx/mpOprtBinAssign.cpp delete mode 100644 src/third-party/headers/muparserx/mpOprtBinCommon.cpp delete mode 100644 src/third-party/headers/muparserx/mpOprtCmplx.cpp delete mode 100644 src/third-party/headers/muparserx/mpOprtIndex.cpp delete mode 100644 src/third-party/headers/muparserx/mpOprtMatrix.cpp delete mode 100644 src/third-party/headers/muparserx/mpOprtNonCmplx.cpp delete mode 100755 src/third-party/headers/muparserx/mpOprtPostfixCommon.cpp delete mode 100644 src/third-party/headers/muparserx/mpPackageCmplx.cpp delete mode 100644 src/third-party/headers/muparserx/mpPackageCommon.cpp delete mode 100644 src/third-party/headers/muparserx/mpPackageMatrix.cpp delete mode 100644 src/third-party/headers/muparserx/mpPackageNonCmplx.cpp delete mode 100644 src/third-party/headers/muparserx/mpPackageStr.cpp delete mode 100644 src/third-party/headers/muparserx/mpPackageUnit.cpp delete mode 100644 src/third-party/headers/muparserx/mpParser.cpp delete mode 100644 src/third-party/headers/muparserx/mpParserBase.cpp delete mode 100644 src/third-party/headers/muparserx/mpParserMessageProvider.cpp delete mode 100644 src/third-party/headers/muparserx/mpRPN.cpp delete mode 100644 src/third-party/headers/muparserx/mpScriptTokens.cpp delete mode 100644 src/third-party/headers/muparserx/mpTest.cpp delete mode 100644 src/third-party/headers/muparserx/mpTokenReader.cpp delete mode 100644 src/third-party/headers/muparserx/mpValReader.cpp delete mode 100644 src/third-party/headers/muparserx/mpValue.cpp delete mode 100644 src/third-party/headers/muparserx/mpValueCache.cpp delete mode 100644 src/third-party/headers/muparserx/mpVariable.cpp diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000000..5c9bcc7d7c --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "src/third-party/headers/muparserx"] + path = src/third-party/headers/muparserx + url = https://github.com/beltoforion/muparserx diff --git a/CMakeLists.txt b/CMakeLists.txt index eeb660bba7..b5dde407c5 100755 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -206,8 +206,9 @@ if(${MUPARSERX_LIB} MATCHES "MUPARSERX_LIB-NOTFOUND") message(FATAL_ERROR "No muparserx library found") endif() message(STATUS "Muparserx library found: ${MUPARSERX_LIB}") +get_muparserx_source_code() # I keep this disabled on purpose, just in case I need to debug muparserx related problems -# file(GLOB MUPARSERX_SOURCES "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/headers/muparserx/*.cpp") +# file(GLOB MUPARSERX_SOURCES "${AER_SIMULATOR_CPP_SRC_DIR}/third-party/headers/muparserx/parser/*.cpp") # Set dependent libraries diff --git a/azure-pipelines.yml b/azure-pipelines.yml index b69805bce7..03a9874d93 100644 --- a/azure-pipelines.yml +++ b/azure-pipelines.yml @@ -16,6 +16,7 @@ jobs: python.version: '3.7' steps: - checkout: self + submodules: true - task: UsePythonVersion@0 inputs: versionSpec: '$(python.version)' @@ -48,6 +49,8 @@ jobs: Python38: python.version: '3.8' steps: + - checkout: self + submodules: true - powershell: Write-Host "##vso[task.prependpath]$env:CONDA\Scripts" displayName: Add conda to PATH - script: conda create --yes --quiet --name qiskit-aer-$(Build.BuildNumber) python=%PYTHON_VERSION% diff --git a/cmake/compiler_utils.cmake b/cmake/compiler_utils.cmake index a45caaf30a..1e495036f0 100644 --- a/cmake/compiler_utils.cmake +++ b/cmake/compiler_utils.cmake @@ -10,6 +10,7 @@ function(enable_cxx_compiler_flag_if_supported flag) endif() endfunction() + function(get_version version_str) string(REPLACE "." ";" VERSION_LIST ${version_str}) list(GET VERSION_LIST 0 TMP_MAJOR_VERSION) @@ -19,3 +20,40 @@ function(get_version version_str) set(MINOR_VERSION ${TMP_MINOR_VERSION} PARENT_SCOPE) set(PATCH_VERSION ${TMP_PATCH_VERSION} PARENT_SCOPE) endfunction() + + +function(get_muparserx_source_code) + find_package(Git QUIET) + if(GIT_FOUND AND EXISTS "${PROJECT_SOURCE_DIR}/.git") + # if we have cloned the sources, muparserx is a submodule, so we need + # to initialize it + if(EXISTS "${PROJECT_SOURCE_DIR}/.gitmodules") + # Update submodules as needed + message(STATUS "Submodule update") + execute_process(COMMAND ${GIT_EXECUTABLE} submodule update --init --recursive + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + RESULT_VARIABLE GIT_SUBMOD_RESULT) + if(NOT GIT_SUBMOD_RESULT EQUAL "0") + message(FATAL_ERROR "git submodule update --init failed with ${GIT_SUBMOD_RESULT}, please checkout submodules") + endif() + endif() + # Not comming from git, so probably: pip install https://...zip or similar. + # This time, we want to clone muparserx and change the latests stable release + elseif(GIT_FOUND) + execute_process(COMMAND ${GIT_EXECUTABLE} clone --branch v4.0.8 https://github.com/beltoforion/muparserx.git ${PROJECT_SOURCE_DIR}/src/third-party/headers/muparserx + WORKING_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR} + RESULT_VARIABLE GIT_SUBMOD_RESULT) + if(NOT GIT_SUBMOD_RESULT EQUAL "0") + message(FATAL_ERROR "git clone failed with ${GIT_SUBMOD_RESULT},\ + please checkout muparserx manually from https://github.com/beltoforion/muparserx.git and \ + checkout latest stable relase") + endif() + # TODO: If there's no git, we have to get muparserx using other method (curl) + endif() + + if(NOT EXISTS "${PROJECT_SOURCE_DIR}/src/third-party/headers/muparserx/CMakeLists.txt") + message(FATAL_ERROR "MuparserX doesn't exist! GIT_SUBMODULE was turned off or download failed.\ + Please download MuparserX library from https://github.com/beltoforion/muparserx.git \ + and checkout latest stable release") + endif() +endfunction() \ No newline at end of file diff --git a/setup.py b/setup.py index 5681d25557..a8421f4819 100644 --- a/setup.py +++ b/setup.py @@ -43,71 +43,12 @@ def find_qiskit_aer_packages(): ) return pkg_list -EXT_MODULES = [] -# OpenPulse setup -if "--with-openpulse" in sys.argv: - sys.argv.remove("--with-openpulse") - # pylint: disable=ungrouped-imports - import numpy as np - import distutils.sysconfig - from setuptools import Extension - from Cython.Build import cythonize - from Cython.Distutils import build_ext # pylint: disable=unused-import - - INCLUDE_DIRS = [np.get_include()] - # Add Cython OP extensions here - OP_EXTS = ['channel_value', 'measure', 'memory', 'utils'] - # Add qutip_lite extensions here - Q_EXTS = ['spmatfuncs', 'sparse_utils', 'spmath', 'spconvert'] - - # Extra link args - link_flags = [] - # If on Win and Python version >= 3.5 and not in MSYS2 (i.e. Visual studio compile) - if (sys.platform == 'win32' and int(str(sys.version_info[0])+str(sys.version_info[1])) >= 35 - and os.environ.get('MSYSTEM') is None): - compiler_flags = [] - # Everything else - else: - compiler_flags = ['-O2', '-funroll-loops'] - if sys.platform == 'darwin': - # These are needed for compiling on OSX 10.14+ - compiler_flags.append('-mmacosx-version-min=10.9') - link_flags.append('-mmacosx-version-min=10.9') - - # Remove -Wstrict-prototypes from cflags - CFG_VARS = distutils.sysconfig.get_config_vars() - if "CFLAGS" in CFG_VARS: - CFG_VARS["CFLAGS"] = CFG_VARS["CFLAGS"].replace("-Wstrict-prototypes", "") - - # Add Cython files from cy - for ext in OP_EXTS: - _mod = Extension("qiskit.providers.aer.openpulse.cy."+ext, - sources=['qiskit/providers/aer/openpulse/cy/'+ext+'.pyx'], - include_dirs=[np.get_include()], - extra_compile_args=compiler_flags, - extra_link_args=link_flags, - language='c++') - EXT_MODULES.append(_mod) - - for ext in Q_EXTS: - _mod = Extension('qiskit.providers.aer.openpulse.qutip_lite.cy.'+ext, - sources=['qiskit/providers/aer/openpulse/qutip_lite/cy/'+ext+'.pyx', - 'qiskit/providers/aer/openpulse/qutip_lite/cy/src/zspmv.cpp'], - include_dirs=[np.get_include()], - extra_compile_args=compiler_flags, - extra_link_args=link_flags, - language='c++') - EXT_MODULES.append(_mod) - - # Cythonize - EXT_MODULES = cythonize(EXT_MODULES) setup( name='qiskit-aer', version=VERSION, packages=find_qiskit_aer_packages(), cmake_source_dir='.', - ext_modules=EXT_MODULES, description="Qiskit Aer - High performance simulators for Qiskit", url="https://github.com/Qiskit/qiskit-aer", author="AER Development Team", diff --git a/src/simulators/open_pulse/eval_hamiltonian.hpp b/src/simulators/open_pulse/eval_hamiltonian.hpp index 2753db7405..2b89fb443d 100644 --- a/src/simulators/open_pulse/eval_hamiltonian.hpp +++ b/src/simulators/open_pulse/eval_hamiltonian.hpp @@ -20,7 +20,7 @@ #include #include #include -#include +#include struct ParserValues { ParserValues(std::unique_ptr parser, const std::string& expr): diff --git a/src/simulators/open_pulse/python_to_cpp.hpp b/src/simulators/open_pulse/python_to_cpp.hpp index cb3563271a..be1df8df7a 100644 --- a/src/simulators/open_pulse/python_to_cpp.hpp +++ b/src/simulators/open_pulse/python_to_cpp.hpp @@ -27,7 +27,6 @@ #include #endif #include -#include #include "ordered_map.hpp" #include "types.hpp" #include "iterators.hpp" diff --git a/src/third-party/headers/muparserx b/src/third-party/headers/muparserx new file mode 160000 index 0000000000..08cbfc3e90 --- /dev/null +++ b/src/third-party/headers/muparserx @@ -0,0 +1 @@ +Subproject commit 08cbfc3e9087e8fceafc85c8fdb7e034e1c35943 diff --git a/src/third-party/headers/muparserx/mpError.cpp b/src/third-party/headers/muparserx/mpError.cpp deleted file mode 100644 index 67f7d53fec..0000000000 --- a/src/third-party/headers/muparserx/mpError.cpp +++ /dev/null @@ -1,266 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. - */ -#include "mpError.h" -#include "mpIToken.h" -#include "mpParserMessageProvider.h" - - -MUP_NAMESPACE_START - -std::unique_ptr ParserErrorMsg::m_pInstance; - -//------------------------------------------------------------------------------ -const ParserMessageProviderBase& ParserErrorMsg::Instance() -{ - if (!m_pInstance.get()) - { - m_pInstance.reset(new ParserMessageProviderEnglish); - m_pInstance->Init(); - } - - return *m_pInstance; -} - -//------------------------------------------------------------------------------ -void ParserErrorMsg::Reset(ParserMessageProviderBase *pProvider) -{ - if (pProvider != nullptr) - { - m_pInstance.reset(pProvider); - m_pInstance->Init(); - } -} - -//------------------------------------------------------------------------------ -string_type ParserErrorMsg::GetErrorMsg(EErrorCodes eError) const -{ - if (!m_pInstance.get()) - return string_type(); - else - return m_pInstance->GetErrorMsg(eError); -} - - -//--------------------------------------------------------------------------- -ParserErrorMsg::~ParserErrorMsg() -{} - -//--------------------------------------------------------------------------- -ParserErrorMsg::ParserErrorMsg() -{} - -//--------------------------------------------------------------------------- -// -// Error context -// -//--------------------------------------------------------------------------- - -/** \brief Constructs an empty Error context structure. */ -ErrorContext::ErrorContext(EErrorCodes a_iErrc, - int a_iPos, - string_type a_sIdent) - :Expr() - , Ident(a_sIdent) - , Hint() - , Errc(a_iErrc) - , Type1(0) - , Type2(0) - , Arg(-1) - , Pos(a_iPos) -{} - -//--------------------------------------------------------------------------- -ErrorContext::ErrorContext(EErrorCodes iErrc, - int iPos, - string_type sIdent, - char_type cType1, - char_type cType2, - int nArg) - :Expr() - , Ident(sIdent) - , Hint() - , Errc(iErrc) - , Type1(cType1) - , Type2(cType2) - , Arg(nArg) - , Pos(iPos) -{} - -//--------------------------------------------------------------------------- -// -// ParserError class -// -//--------------------------------------------------------------------------- - -ParserError::ParserError() - :m_Err() - , m_sMsg() - , m_ErrMsg(ParserErrorMsg::Instance()) -{} - -//------------------------------------------------------------------------------ -ParserError::ParserError(const string_type &sMsg) - :m_Err() - , m_sMsg(sMsg) - , m_ErrMsg(ParserErrorMsg::Instance()) -{} - -//------------------------------------------------------------------------------ -ParserError::ParserError(const ErrorContext &a_Err) - :m_Err(a_Err) - , m_sMsg() - , m_ErrMsg(ParserErrorMsg::Instance()) -{ - m_sMsg = m_ErrMsg.GetErrorMsg(a_Err.Errc); -} - -//------------------------------------------------------------------------------ -ParserError::ParserError(const ParserError &a_Obj) - :m_Err(a_Obj.m_Err) - , m_sMsg(a_Obj.m_sMsg) - , m_ErrMsg(ParserErrorMsg::Instance()) -{} - -//------------------------------------------------------------------------------ -ParserError& ParserError::operator=(const ParserError &a_Obj) -{ - if (this == &a_Obj) - return *this; - - m_sMsg = a_Obj.m_sMsg; - m_Err = a_Obj.m_Err; - return *this; -} - -//------------------------------------------------------------------------------ -/** \brief Replace all occurences of a substring with another string. */ -void ParserError::ReplaceSubString(string_type &sSource, - const string_type &sFind, - const string_type &sReplaceWith) const -{ - string_type sResult; - string_type::size_type iPos(0), iNext(0); - - for (;;) - { - iNext = sSource.find(sFind, iPos); - sResult.append(sSource, iPos, iNext - iPos); - - if (iNext == string_type::npos) - break; - - sResult.append(sReplaceWith); - iPos = iNext + sFind.length(); - } - - sSource.swap(sResult); -} - - -//------------------------------------------------------------------------------ -/** \brief Replace all occurences of a substring with another string. */ -void ParserError::ReplaceSubString(string_type &sSource, - const string_type &sFind, - int iReplaceWith) const -{ - stringstream_type stream; - stream << iReplaceWith; - ReplaceSubString(sSource, sFind, stream.str()); -} - -//------------------------------------------------------------------------------ -/** \brief Replace all occurences of a substring with another string. */ -void ParserError::ReplaceSubString(string_type &sSource, - const string_type &sFind, - char_type cReplaceWith) const -{ - stringstream_type stream; - stream << cReplaceWith; - ReplaceSubString(sSource, sFind, stream.str()); -} - -//------------------------------------------------------------------------------ -void ParserError::Reset() -{ - m_sMsg = _T(""); - m_Err = ErrorContext(); -} - -//------------------------------------------------------------------------------ -const string_type& ParserError::GetExpr() const -{ - return m_Err.Expr; -} - -//------------------------------------------------------------------------------ -string_type ParserError::GetMsg() const -{ - string_type sMsg(m_sMsg); - ReplaceSubString(sMsg, _T("$EXPR$"), m_Err.Expr); - ReplaceSubString(sMsg, _T("$IDENT$"), m_Err.Ident); - ReplaceSubString(sMsg, _T("$POS$"), m_Err.Pos); - ReplaceSubString(sMsg, _T("$ARG$"), m_Err.Arg); - ReplaceSubString(sMsg, _T("$TYPE1$"), m_Err.Type1); - ReplaceSubString(sMsg, _T("$TYPE2$"), m_Err.Type2); - ReplaceSubString(sMsg, _T("$HINT$"), m_Err.Hint); - return sMsg; -} - -//------------------------------------------------------------------------------ -ErrorContext& ParserError::GetContext() -{ - return m_Err; -} - -//------------------------------------------------------------------------------ -/** \brief Return the expression position related to the error. - - If the error is not related to a distinct position this will return -1 - */ -int ParserError::GetPos() const -{ - return m_Err.Pos; -} - -//------------------------------------------------------------------------------ -/** \brief Return string related with this token (if available). */ -const string_type& ParserError::GetToken() const -{ - return m_Err.Ident; -} - -//------------------------------------------------------------------------------ -/** \brief Return the error code. */ -EErrorCodes ParserError::GetCode() const -{ - return m_Err.Errc; -} -} // namespace mu diff --git a/src/third-party/headers/muparserx/mpFuncCmplx.cpp b/src/third-party/headers/muparserx/mpFuncCmplx.cpp deleted file mode 100644 index 9f97b23439..0000000000 --- a/src/third-party/headers/muparserx/mpFuncCmplx.cpp +++ /dev/null @@ -1,635 +0,0 @@ -/** \file - \brief Definition of functions for complex valued operations. - -
          -               __________                                 ____  ___
          -    _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
          -  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
          -  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -        \/                     \/           \/     \/           \_/
          -                                       Copyright (C) 2016 Ingo Berg
          -                                       All rights reserved.
          -
          -  muParserX - A C++ math parser library with array and string support
          -  Copyright (c) 2016, Ingo Berg
          -  All rights reserved.
          -
          -  Redistribution and use in source and binary forms, with or without 
          -  modification, are permitted provided that the following conditions are met:
          -
          -   * Redistributions of source code must retain the above copyright notice, 
          -     this list of conditions and the following disclaimer.
          -   * Redistributions in binary form must reproduce the above copyright notice, 
          -     this list of conditions and the following disclaimer in the documentation 
          -     and/or other materials provided with the distribution.
          -
          -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
          -  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
          -  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
          -  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
          -  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
          -  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
          -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
          -  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
          -  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
          -  POSSIBILITY OF SUCH DAMAGE.
          -
          -*/ -#include "mpFuncCmplx.h" - -//--- Standard includes ---------------------------------------------------- -#include -#include -#include -#include - -//--- Parser framework ----------------------------------------------------- -#include "mpValue.h" -#include "mpError.h" - - -MUP_NAMESPACE_START - - //----------------------------------------------------------------------- - // - // class FunCmplxReal - // - //----------------------------------------------------------------------- - - FunCmplxReal::FunCmplxReal() - :ICallback(cmFUNC, _T("real"), 1) - {} - - //----------------------------------------------------------------------- - FunCmplxReal::~FunCmplxReal() - {} - - //----------------------------------------------------------------------- - void FunCmplxReal::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - float_type v = a_pArg[0]->GetFloat(); - *ret = v; - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxReal::GetDesc() const - { - return _T("real(x) - Returns the real part of the complex number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxReal::Clone() const - { - return new FunCmplxReal(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxImag - // - //----------------------------------------------------------------------- - - FunCmplxImag::FunCmplxImag() - :ICallback(cmFUNC, _T("imag"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxImag::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - float_type v = a_pArg[0]->GetImag(); - *ret = v; - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxImag::GetDesc() const - { - return _T("imag(x) - Returns the imaginary part of the complex number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxImag::Clone() const - { - return new FunCmplxImag(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxConj - // - //----------------------------------------------------------------------- - - FunCmplxConj::FunCmplxConj() - :ICallback(cmFUNC, _T("conj"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxConj::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - *ret = cmplx_type(a_pArg[0]->GetFloat(), -a_pArg[0]->GetImag()); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxConj::GetDesc() const - { - return _T("conj(x) - Returns the complex conjugate of the complex number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxConj::Clone() const - { - return new FunCmplxConj(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxArg - // - //----------------------------------------------------------------------- - - FunCmplxArg::FunCmplxArg() - :ICallback(cmFUNC, _T("arg"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxArg::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = std::arg(v); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxArg::GetDesc() const - { - return _T("arg(x) - Returns the phase angle (or angular component) of the complex number x, expressed in radians."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxArg::Clone() const - { - return new FunCmplxArg(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxNorm - // - //----------------------------------------------------------------------- - - FunCmplxNorm::FunCmplxNorm() - :ICallback(cmFUNC, _T("norm"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxNorm::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = std::norm(v); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxNorm::GetDesc() const - { - return _T("norm(x) - Returns the norm value of the complex number x.") - _T(" The norm value of a complex number is the squared magnitude,") - _T(" defined as the addition of the square of both the real part") - _T(" and the imaginary part (without the imaginary unit). This is") - _T(" the square of abs (x)."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxNorm::Clone() const - { - return new FunCmplxNorm(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxCos - // - //----------------------------------------------------------------------- - - FunCmplxCos::FunCmplxCos() - :ICallback(cmFUNC, _T("cos"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxCos::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - if (a_pArg[0]->IsNonComplexScalar()) - { - *ret = std::cos(a_pArg[0]->GetFloat()); - } - else - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = std::cos(v); - } - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxCos::GetDesc() const - { - return _T("cos(x) - Returns the cosine of the number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxCos::Clone() const - { - return new FunCmplxCos(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxSin - // - //----------------------------------------------------------------------- - - FunCmplxSin::FunCmplxSin() - :ICallback(cmFUNC, _T("sin"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxSin::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - if (a_pArg[0]->IsNonComplexScalar()) - { - *ret = std::sin(a_pArg[0]->GetFloat()); - } - else - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = std::sin(v); - } - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxSin::GetDesc() const - { - return _T("sin(x) - Returns the sine of the number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxSin::Clone() const - { - return new FunCmplxSin(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxCosH - // - //----------------------------------------------------------------------- - - FunCmplxCosH::FunCmplxCosH() - :ICallback(cmFUNC, _T("cosh"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxCosH::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = cosh(v); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxCosH::GetDesc() const - { - return _T("cosh(x) - Returns the hyperbolic cosine of the number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxCosH::Clone() const - { - return new FunCmplxCosH(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxSinH - // - //----------------------------------------------------------------------- - - FunCmplxSinH::FunCmplxSinH() - :ICallback(cmFUNC, _T("sinh"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxSinH::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = sinh(v); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxSinH::GetDesc() const - { - return _T("sinh(x) - Returns the hyperbolic sine of the complex number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxSinH::Clone() const - { - return new FunCmplxSinH(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxTan - // - //----------------------------------------------------------------------- - - FunCmplxTan::FunCmplxTan() - :ICallback(cmFUNC, _T("tan"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxTan::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - if (a_pArg[0]->IsNonComplexScalar()) - { - *ret = std::tan(a_pArg[0]->GetFloat()); - } - else - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = std::tan(v); - } - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxTan::GetDesc() const - { - return _T("tan(x) - Returns the tangens of the number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxTan::Clone() const - { - return new FunCmplxTan(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxTanH - // - //----------------------------------------------------------------------- - - FunCmplxTanH::FunCmplxTanH() - :ICallback(cmFUNC, _T("tanh"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxTanH::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = tanh(v); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxTanH::GetDesc() const - { - return _T("tanh(x) - Returns the hyperbolic tangent of the complex number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxTanH::Clone() const - { - return new FunCmplxTanH(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxSqrt - // - //----------------------------------------------------------------------- - - FunCmplxSqrt::FunCmplxSqrt() - :ICallback(cmFUNC, _T("sqrt"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxSqrt::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - *ret = sqrt((*a_pArg[0]).GetComplex()); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxSqrt::GetDesc() const - { - return _T("sqrt(x) - Returns the square root of x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxSqrt::Clone() const - { - return new FunCmplxSqrt(*this); - } - - - //----------------------------------------------------------------------- - // - // class FunCmplxExp - // - //----------------------------------------------------------------------- - - FunCmplxExp::FunCmplxExp() - :ICallback(cmFUNC, _T("exp"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxExp::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = exp(v); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxExp::GetDesc() const - { - return _T("exp(x) - Returns the base-e exponential of the complex number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxExp::Clone() const - { - return new FunCmplxExp(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxLn - // - //----------------------------------------------------------------------- - - FunCmplxLn::FunCmplxLn() - :ICallback(cmFUNC, _T("ln"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxLn::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = log(v); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxLn::GetDesc() const - { - return _T("ln(x) - Returns the natural (base-e) logarithm of the complex number x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxLn::Clone() const - { - return new FunCmplxLn(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxLog - // - //----------------------------------------------------------------------- - - FunCmplxLog::FunCmplxLog() - :ICallback(cmFUNC, _T("log"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxLog::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = log(v); - } - - - //----------------------------------------------------------------------- - const char_type* FunCmplxLog::GetDesc() const - { - return _T("log(x) - Common logarithm of x, for values of x greater than zero."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxLog::Clone() const - { - return new FunCmplxLog(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxLog10 - // - //----------------------------------------------------------------------- - - FunCmplxLog10::FunCmplxLog10() - :ICallback(cmFUNC, _T("log10"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxLog10::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - cmplx_type v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = log10(v); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxLog10::GetDesc() const - { - return _T("log10(x) - Common logarithm of x, for values of x greater than zero."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxLog10::Clone() const - { - return new FunCmplxLog10(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxLog2 - // - //----------------------------------------------------------------------- - - FunCmplxLog2::FunCmplxLog2() - :ICallback(cmFUNC, _T("log2"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxLog2::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - std::complex v(a_pArg[0]->GetFloat(), a_pArg[0]->GetImag()); - *ret = std::log(v) * (float_type)1.0/std::log((float_type)2.0); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxLog2::GetDesc() const - { - return _T("log2(x) - Logarithm to base 2 of x, for values of x greater than zero."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxLog2::Clone() const - { - return new FunCmplxLog2(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxAbs - // - //----------------------------------------------------------------------- - - FunCmplxAbs::FunCmplxAbs() - :ICallback(cmFUNC, _T("abs"), 1) - {} - - //----------------------------------------------------------------------- - void FunCmplxAbs::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - float_type v = sqrt(a_pArg[0]->GetFloat()*a_pArg[0]->GetFloat() + - a_pArg[0]->GetImag()*a_pArg[0]->GetImag()); - *ret = v; - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxAbs::GetDesc() const - { - return _T("abs(x) - Returns the absolute value of x."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxAbs::Clone() const - { - return new FunCmplxAbs(*this); - } - - //----------------------------------------------------------------------- - // - // class FunCmplxPow - // - //----------------------------------------------------------------------- - - FunCmplxPow::FunCmplxPow() - :ICallback(cmFUNC, _T("pow"), 2) - {} - - //----------------------------------------------------------------------- - void FunCmplxPow::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - *ret = std::pow(a_pArg[0]->GetComplex(), a_pArg[1]->GetComplex()); - } - - //----------------------------------------------------------------------- - const char_type* FunCmplxPow::GetDesc() const - { - return _T("pox(x, y) - Raise x to the power of y."); - } - - //----------------------------------------------------------------------- - IToken* FunCmplxPow::Clone() const - { - return new FunCmplxPow(*this); - } - - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpFuncCommon.cpp b/src/third-party/headers/muparserx/mpFuncCommon.cpp deleted file mode 100644 index 71797ad8a5..0000000000 --- a/src/third-party/headers/muparserx/mpFuncCommon.cpp +++ /dev/null @@ -1,272 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - muParserX - A C++ math parser library with array and string support - Copyright (c) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpFuncCommon.h" - -#include -#include -#include - -#include "mpValue.h" -#include "mpParserBase.h" - - -MUP_NAMESPACE_START - - //------------------------------------------------------------------------------ - // - // FunParserID - // - //------------------------------------------------------------------------------ - - FunParserID::FunParserID() - :ICallback(cmFUNC, _T("parserid"), 0) - {} - - //------------------------------------------------------------------------------ - void FunParserID::Eval(ptr_val_type &ret, const ptr_val_type * /*a_pArg*/, int /*a_iArgc*/) - { - string_type sVer = _T("muParserX V") + GetParent()->GetVersion(); - *ret = sVer; - } - - //------------------------------------------------------------------------------ - const char_type* FunParserID::GetDesc() const - { - return _T("parserid() - muParserX version information"); - } - - //------------------------------------------------------------------------------ - IToken* FunParserID::Clone() const - { - return new FunParserID(*this); - } - - //------------------------------------------------------------------------------ - // - // Max Function - // - //------------------------------------------------------------------------------ - - FunMax::FunMax() : ICallback(cmFUNC, _T("max"), -1) - {} - - //------------------------------------------------------------------------------ - void FunMax::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) - { - if (a_iArgc < 1) - throw ParserError(ErrorContext(ecTOO_FEW_PARAMS, GetExprPos(), GetIdent())); - - float_type max(-1e30), val(0); - for (int i=0; iGetType()) - { - case 'f': - case 'i': val = a_pArg[i]->GetFloat(); break; - case 'n': break; // ignore not in list entries (missing parameter) - case 'c': - default: - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT_FUN; - err.Arg = i+1; - err.Type1 = a_pArg[i]->GetType(); - err.Type2 = 'f'; - throw ParserError(err); - } - } - max = std::max(max, val); - } - - *ret = max; - } - - //------------------------------------------------------------------------------ - const char_type* FunMax::GetDesc() const - { - return _T("max(x,y,...,z) - Returns the maximum value from all of its function arguments."); - } - - //------------------------------------------------------------------------------ - IToken* FunMax::Clone() const - { - return new FunMax(*this); - } - - //------------------------------------------------------------------------------ - // - // Min Function - // - //------------------------------------------------------------------------------ - - FunMin::FunMin() : ICallback(cmFUNC, _T("min"), -1) - {} - - //------------------------------------------------------------------------------ - /** \brief Returns the minimum value of all values. - \param a_pArg Pointer to an array of Values - \param a_iArgc Number of values stored in a_pArg - */ - void FunMin::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) - { - if (a_iArgc < 1) - throw ParserError(ErrorContext(ecTOO_FEW_PARAMS, GetExprPos(), GetIdent())); - - float_type min(1e30), val(min); - - for (int i=0; iGetType()) - { - case 'f': - case 'i': val = a_pArg[i]->GetFloat(); break; - default: - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT_FUN; - err.Arg = i+1; - err.Type1 = a_pArg[i]->GetType(); - err.Type2 = 'f'; - throw ParserError(err); - } - } - min = std::min(min, val); - } - - *ret = min; - } - - //------------------------------------------------------------------------------ - const char_type* FunMin::GetDesc() const - { - return _T("min(x,y,...,z) - Returns the minimum value from all of its function arguments."); - } - - //------------------------------------------------------------------------------ - IToken* FunMin::Clone() const - { - return new FunMin(*this); - } - - //------------------------------------------------------------------------------ - // - // class FunSum - // - //------------------------------------------------------------------------------ - - FunSum::FunSum() - :ICallback(cmFUNC, _T("sum"), -1) - {} - - //------------------------------------------------------------------------------ - /** \brief Returns the minimum value of all values. - \param a_pArg Pointer to an array of Values - \param a_iArgc Number of values stored in a_pArg - */ - void FunSum::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) - { - if (a_iArgc < 1) - throw ParserError(ErrorContext(ecTOO_FEW_PARAMS, GetExprPos(), GetIdent())); - - float_type sum(0); - - for (int i=0; iGetType()) - { - case 'f': - case 'i': sum += a_pArg[i]->GetFloat(); break; - default: - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT_FUN; - err.Arg = i+1; - err.Type1 = a_pArg[i]->GetType(); - err.Type2 = 'f'; - throw ParserError(err); - } - } - } - - *ret = sum; - } - - //------------------------------------------------------------------------------ - const char_type* FunSum::GetDesc() const - { - return _T("sum(x,y,...,z) - Returns the sum of all arguments."); - } - - //------------------------------------------------------------------------------ - IToken* FunSum::Clone() const - { - return new FunSum(*this); - } - - //------------------------------------------------------------------------------ - // - // SizeOf - // - //------------------------------------------------------------------------------ - - FunSizeOf::FunSizeOf() - :ICallback(cmFUNC, _T("sizeof"), 1) - {} - - //------------------------------------------------------------------------------ - FunSizeOf::~FunSizeOf() - {} - - //------------------------------------------------------------------------------ - /** \brief Returns the number of elements stored in the first parameter. */ - void FunSizeOf::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) - { - assert(a_iArgc==1); - *ret = (float_type)a_pArg[0]->GetArray().GetRows(); - } - - //------------------------------------------------------------------------------ - const char_type* FunSizeOf::GetDesc() const - { - return _T("sizeof(a) - Returns the number of elements in a."); - } - - //------------------------------------------------------------------------------ - IToken* FunSizeOf::Clone() const - { - return new FunSizeOf(*this); - } - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpFuncMatrix.cpp b/src/third-party/headers/muparserx/mpFuncMatrix.cpp deleted file mode 100644 index 995e680e7b..0000000000 --- a/src/third-party/headers/muparserx/mpFuncMatrix.cpp +++ /dev/null @@ -1,249 +0,0 @@ -/** \file - \brief Definition of functions for complex valued operations. - -
          -               __________                                 ____  ___
          -    _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -    /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
          -    |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
          -    |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -          \/                     \/           \/     \/           \_/
          -
          -    muParserX - A C++ math parser library with array and string support
          -    Copyright (c) 2016, Ingo Berg
          -    All rights reserved.
          -
          -    Redistribution and use in source and binary forms, with or without
          -    modification, are permitted provided that the following conditions are met:
          -
          -    * Redistributions of source code must retain the above copyright notice,
          -    this list of conditions and the following disclaimer.
          -    * Redistributions in binary form must reproduce the above copyright notice,
          -    this list of conditions and the following disclaimer in the documentation
          -    and/or other materials provided with the distribution.
          -
          -    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
          -    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
          -    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
          -    IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
          -    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
          -    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
          -    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
          -    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
          -    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
          -    POSSIBILITY OF SUCH DAMAGE.
          -    
          - */ -#include "mpFuncMatrix.h" - -//--- Standard includes ---------------------------------------------------- -#include -#include -#include -#include - -//--- Parser framework ----------------------------------------------------- -#include "mpValue.h" -#include "mpError.h" - - -MUP_NAMESPACE_START - -//----------------------------------------------------------------------- -// -// class FunMatrixOnes -// -//----------------------------------------------------------------------- - -FunMatrixOnes::FunMatrixOnes() -:ICallback(cmFUNC, _T("ones"), -1) -{} - -//----------------------------------------------------------------------- -FunMatrixOnes::~FunMatrixOnes() -{} - -//----------------------------------------------------------------------- -void FunMatrixOnes::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int argc) -{ - if (argc < 1 || argc>2) - { - ErrorContext err; - err.Errc = ecINVALID_NUMBER_OF_PARAMETERS; - err.Arg = argc; - err.Ident = GetIdent(); - throw ParserError(err); - } - - int_type m = a_pArg[0]->GetInteger(), - n = (argc == 1) ? m : a_pArg[1]->GetInteger(); - - if (m == n && n == 1) - { - *ret = 1.0; // unboxing of 1x1 matrices - } - else - { - *ret = matrix_type(m, n, 1.0); - } -} - -//----------------------------------------------------------------------- -const char_type* FunMatrixOnes::GetDesc() const -{ - return _T("ones(x [, y]) - Returns a matrix whose elements are all 1."); -} - -//----------------------------------------------------------------------- -IToken* FunMatrixOnes::Clone() const -{ - return new FunMatrixOnes(*this); -} - -//----------------------------------------------------------------------- -// -// class FunMatrixZeros -// -//----------------------------------------------------------------------- - -FunMatrixZeros::FunMatrixZeros() - :ICallback(cmFUNC, _T("zeros"), -1) -{} - -//----------------------------------------------------------------------- -FunMatrixZeros::~FunMatrixZeros() -{} - -//----------------------------------------------------------------------- -void FunMatrixZeros::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int argc) -{ - if (argc < 1 || argc>2) - { - ErrorContext err; - err.Errc = ecINVALID_NUMBER_OF_PARAMETERS; - err.Arg = argc; - err.Ident = GetIdent(); - throw ParserError(err); - } - - int_type m = a_pArg[0]->GetInteger(), - n = (argc == 1) ? m : a_pArg[1]->GetInteger(); - - if (m == n && n == 1) - { - *ret = 0.0; // unboxing of 1x1 matrices - } - else - { - *ret = matrix_type(m, n, 0.0); - } -} - -//----------------------------------------------------------------------- -const char_type* FunMatrixZeros::GetDesc() const -{ - return _T("zeros(x [, y]) - Returns a matrix whose elements are all 0."); -} - -//----------------------------------------------------------------------- -IToken* FunMatrixZeros::Clone() const -{ - return new FunMatrixZeros(*this); -} - -//----------------------------------------------------------------------- -// -// class FunMatrixEye -// -//----------------------------------------------------------------------- - -FunMatrixEye::FunMatrixEye() - :ICallback(cmFUNC, _T("eye"), -1) -{} - -//----------------------------------------------------------------------- -FunMatrixEye::~FunMatrixEye() -{} - -//----------------------------------------------------------------------- -void FunMatrixEye::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int argc) -{ - if (argc < 1 || argc>2) - { - ErrorContext err; - err.Errc = ecINVALID_NUMBER_OF_PARAMETERS; - err.Arg = argc; - err.Ident = GetIdent(); - throw ParserError(err); - } - - int_type m = a_pArg[0]->GetInteger(), - n = (argc == 1) ? m : a_pArg[1]->GetInteger(); - - matrix_type eye(m, n, 0.0); - - for (int i = 0; i < std::min(m, n); ++i) - { - eye.At(i, i) = 1.0; - } - - *ret = eye; -} - -//----------------------------------------------------------------------- -const char_type* FunMatrixEye::GetDesc() const -{ - return _T("eye(x, y) - returns a matrix with ones on its diagonal and zeros elsewhere."); -} - -//----------------------------------------------------------------------- -IToken* FunMatrixEye::Clone() const -{ - return new FunMatrixEye(*this); -} - -//----------------------------------------------------------------------- -// -// class FunMatrixSize -// -//----------------------------------------------------------------------- - -FunMatrixSize::FunMatrixSize() - :ICallback(cmFUNC, _T("size"), -1) -{} - -//----------------------------------------------------------------------- -FunMatrixSize::~FunMatrixSize() -{} - -//----------------------------------------------------------------------- -void FunMatrixSize::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int argc) -{ - if (argc != 1) - { - ErrorContext err; - err.Errc = ecINVALID_NUMBER_OF_PARAMETERS; - err.Arg = argc; - err.Ident = GetIdent(); - throw ParserError(err); - } - - matrix_type sz(1, 2, 0.0); - sz.At(0, 0) = (float_type)a_pArg[0]->GetRows(); - sz.At(0, 1) = (float_type)a_pArg[0]->GetCols(); - *ret = sz; -} - -//----------------------------------------------------------------------- -const char_type* FunMatrixSize::GetDesc() const -{ - return _T("size(x) - returns the matrix dimensions."); -} - -//----------------------------------------------------------------------- -IToken* FunMatrixSize::Clone() const -{ - return new FunMatrixSize(*this); -} - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpFuncNonCmplx.cpp b/src/third-party/headers/muparserx/mpFuncNonCmplx.cpp deleted file mode 100644 index 4ea6b7db68..0000000000 --- a/src/third-party/headers/muparserx/mpFuncNonCmplx.cpp +++ /dev/null @@ -1,126 +0,0 @@ -/** \file - \brief Implementation of basic functions used by muParserX. - -
          -               __________                                 ____  ___
          -    _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
          -  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
          -  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -        \/                     \/           \/     \/           \_/
          -                                       Copyright (C) 2016, Ingo Berg
          -                                       All rights reserved.
          -
          -  Redistribution and use in source and binary forms, with or without 
          -  modification, are permitted provided that the following conditions are met:
          -
          -   * Redistributions of source code must retain the above copyright notice, 
          -     this list of conditions and the following disclaimer.
          -   * Redistributions in binary form must reproduce the above copyright notice, 
          -     this list of conditions and the following disclaimer in the documentation 
          -     and/or other materials provided with the distribution.
          -
          -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
          -  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
          -  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
          -  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
          -  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
          -  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
          -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
          -  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
          -  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
          -  POSSIBILITY OF SUCH DAMAGE.
          -  
          -*/ -#include "mpFuncNonCmplx.h" - -//--- Standard includes ---------------------------------------------------- -#include -#include -#include - -//--- muParserX framework -------------------------------------------------- -#include "mpValue.h" -#include "mpError.h" - -#undef log -#undef log2 - -MUP_NAMESPACE_START - -#define MUP_UNARY_FUNC(CLASS, IDENT, FUNC, DESC) \ - CLASS::CLASS() \ - :ICallback(cmFUNC, _T(IDENT), 1) \ - {} \ - \ - void CLASS::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) \ - { \ - *ret = FUNC(a_pArg[0]->GetFloat()); \ - } \ - \ - const char_type* CLASS::GetDesc() const \ - { \ - return _T(DESC); \ - } \ - \ - IToken* CLASS::Clone() const \ - { \ - return new CLASS(*this); \ - } - - // trigonometric functions - MUP_UNARY_FUNC(FunTan, "sin", std::sin, "sine function") - MUP_UNARY_FUNC(FunCos, "cos", std::cos, "cosine function") - MUP_UNARY_FUNC(FunSin, "tan", std::tan, "tangens function") - // arcus functions - MUP_UNARY_FUNC(FunASin, "asin", std::asin, "arcus sine") - MUP_UNARY_FUNC(FunACos, "acos", std::acos, "arcus cosine") - MUP_UNARY_FUNC(FunATan, "atan", std::atan, "arcus tangens") - // hyperbolic functions - MUP_UNARY_FUNC(FunSinH, "sinh", std::sinh, "hyperbolic sine") - MUP_UNARY_FUNC(FunCosH, "cosh", std::cosh, "hyperbolic cosine") - MUP_UNARY_FUNC(FunTanH, "tanh", std::tanh, "hyperbolic tangens") - // hyperbolic arcus functions - MUP_UNARY_FUNC(FunASinH, "asinh", std::asinh, "hyperbolic arcus sine") - MUP_UNARY_FUNC(FunACosH, "acosh", std::acosh, "hyperbolic arcus cosine") - MUP_UNARY_FUNC(FunATanH, "atanh", std::atanh, "hyperbolic arcus tangens") - // logarithm functions - MUP_UNARY_FUNC(FunLog, "log", std::log, "Natural logarithm") - MUP_UNARY_FUNC(FunLog10, "log10", std::log10, "Logarithm base 10") - MUP_UNARY_FUNC(FunLog2, "log2", std::log2, "Logarithm base 2") - MUP_UNARY_FUNC(FunLn, "ln", std::log, "Natural logarithm") - // square root - MUP_UNARY_FUNC(FunSqrt, "sqrt", std::sqrt, "sqrt(x) - square root of x") - MUP_UNARY_FUNC(FunCbrt, "cbrt", std::cbrt, "cbrt(x) - cubic root of x") - MUP_UNARY_FUNC(FunExp, "exp", std::exp, "exp(x) - e to the power of x") - MUP_UNARY_FUNC(FunAbs, "abs", std::fabs, "abs(x) - absolute value of x") -#undef MUP_UNARY_FUNC - -#define MUP_BINARY_FUNC(CLASS, IDENT, FUNC, DESC) \ - CLASS::CLASS() \ - :ICallback(cmFUNC, _T(IDENT), 2) \ - {} \ - \ - void CLASS::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) \ - { \ - *ret = FUNC(a_pArg[0]->GetFloat(), a_pArg[1]->GetFloat()); \ - } \ - \ - const char_type* CLASS::GetDesc() const \ - { \ - return _T(DESC); \ - } \ - \ - IToken* CLASS::Clone() const \ - { \ - return new CLASS(*this); \ - } - - MUP_BINARY_FUNC(FunPow, "pow", std::pow, "pow(x, y) - raise x to the power of y") - MUP_BINARY_FUNC(FunHypot, "hypot", std::hypot, "hypot(x, y) - compute the length of the vector x,y") - MUP_BINARY_FUNC(FunAtan2, "atan2", std::atan2, "arcus tangens with quadrant fix") - MUP_BINARY_FUNC(FunFmod, "fmod", std::fmod, "fmod(x, y) - floating point remainder of x / y") - MUP_BINARY_FUNC(FunRemainder, "remainder", std::remainder, "remainder(x, y) - IEEE remainder of x / y") -#undef MUP_BINARY_FUNC - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpFuncStr.cpp b/src/third-party/headers/muparserx/mpFuncStr.cpp deleted file mode 100644 index 093d016a01..0000000000 --- a/src/third-party/headers/muparserx/mpFuncStr.cpp +++ /dev/null @@ -1,180 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpFuncStr.h" - -#include -#include -#include -#include -#include - -#include "mpValue.h" -#include "mpError.h" - - -MUP_NAMESPACE_START - - //------------------------------------------------------------------------------ - // - // Strlen function - // - //------------------------------------------------------------------------------ - - FunStrLen::FunStrLen() - :ICallback(cmFUNC, _T("strlen"), 1) - {} - - //------------------------------------------------------------------------------ - void FunStrLen::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - string_type str = a_pArg[0]->GetString(); - *ret = (float_type)str.length(); - } - - //------------------------------------------------------------------------------ - const char_type* FunStrLen::GetDesc() const - { - return _T("strlen(s) - Returns the length of the string s."); - } - - //------------------------------------------------------------------------------ - IToken* FunStrLen::Clone() const - { - return new FunStrLen(*this); - } - - //------------------------------------------------------------------------------ - // - // ToUpper function - // - //------------------------------------------------------------------------------ - - FunStrToUpper::FunStrToUpper() - :ICallback(cmFUNC, _T("toupper"), 1) - {} - - //------------------------------------------------------------------------------ - void FunStrToUpper::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - using namespace std; - - string_type str = a_pArg[0]->GetString(); - std::transform(str.begin(), str.end(), str.begin(), ::toupper); - - *ret = str; - } - - //------------------------------------------------------------------------------ - const char_type* FunStrToUpper::GetDesc() const - { - return _T("toupper(s) - Converts the string s to uppercase characters."); - } - - //------------------------------------------------------------------------------ - IToken* FunStrToUpper::Clone() const - { - return new FunStrToUpper(*this); - } - - //------------------------------------------------------------------------------ - // - // ToLower function - // - //------------------------------------------------------------------------------ - - FunStrToLower::FunStrToLower() - :ICallback(cmFUNC, _T("tolower"), 1) - {} - - //------------------------------------------------------------------------------ - void FunStrToLower::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - using namespace std; - - string_type str = a_pArg[0]->GetString(); - std::transform(str.begin(), str.end(), str.begin(), ::tolower); - - *ret = str; - } - - //------------------------------------------------------------------------------ - const char_type* FunStrToLower::GetDesc() const - { - return _T("tolower(s) - Converts the string s to lowercase characters."); - } - - //------------------------------------------------------------------------------ - IToken* FunStrToLower::Clone() const - { - return new FunStrToLower(*this); - } - - //------------------------------------------------------------------------------ - // - // String to double conversion - // - //------------------------------------------------------------------------------ - - FunStrToDbl::FunStrToDbl() - :ICallback(cmFUNC, _T("str2dbl"), 1) - {} - - //------------------------------------------------------------------------------ - void FunStrToDbl::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) - { - assert(a_iArgc==1); - string_type in; - double out; // <- Ich will hier wirklich double, auch wenn der Type long double - // ist. sscanf und long double geht nicht mit GCC! - - in = a_pArg[0]->GetString(); - -#ifndef _UNICODE - sscanf(in.c_str(), "%lf", &out); -#else - swscanf(in.c_str(), _T("%lf"), &out); -#endif - - *ret = (float_type)out; - } - - //------------------------------------------------------------------------------ - const char_type* FunStrToDbl::GetDesc() const - { - return _T("str2dbl(s) - Converts the string stored in s into a floating foint value."); - } - - //------------------------------------------------------------------------------ - IToken* FunStrToDbl::Clone() const - { - return new FunStrToDbl(*this); - } -} // namespace mu diff --git a/src/third-party/headers/muparserx/mpICallback.cpp b/src/third-party/headers/muparserx/mpICallback.cpp deleted file mode 100644 index 1523f75468..0000000000 --- a/src/third-party/headers/muparserx/mpICallback.cpp +++ /dev/null @@ -1,141 +0,0 @@ -/** \file - \brief Implementation of the interface for parser callback objects. - -
          -               __________                                 ____  ___
          -    _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
          -  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
          -  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -        \/                     \/           \/     \/           \_/
          -                                       Copyright (C) 2016 Ingo Berg
          -                                       All rights reserved.
          -
          -  muParserX - A C++ math parser library with array and string support
          -  Copyright (c) 2016, Ingo Berg
          -  All rights reserved.
          -
          -  Redistribution and use in source and binary forms, with or without 
          -  modification, are permitted provided that the following conditions are met:
          -
          -   * Redistributions of source code must retain the above copyright notice, 
          -     this list of conditions and the following disclaimer.
          -   * Redistributions in binary form must reproduce the above copyright notice, 
          -     this list of conditions and the following disclaimer in the documentation 
          -     and/or other materials provided with the distribution.
          -
          -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
          -  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
          -  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
          -  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
          -  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
          -  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
          -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
          -  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
          -  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
          -  POSSIBILITY OF SUCH DAMAGE.
          -
          -*/ -#include "mpICallback.h" -#include - -#include "mpParserBase.h" - - -MUP_NAMESPACE_START - - //------------------------------------------------------------------------------ - ICallback::ICallback(ECmdCode a_iCode, - const char_type *a_szName, - int a_nArgc) - :IToken(a_iCode, a_szName) - ,m_pParent(nullptr) - ,m_nArgc(a_nArgc) - ,m_nArgsPresent(-1) - {} - - //------------------------------------------------------------------------------ - ICallback::~ICallback() - {} - - //--------------------------------------------------------------------------- - ICallback* ICallback::AsICallback() - { - return this; - } - - //--------------------------------------------------------------------------- - IValue* ICallback::AsIValue() - { - return nullptr; - } - - //------------------------------------------------------------------------------ - /** \brief Returns a pointer to the parser object owning this callback. - \pre [assert] m_pParent must be defined - */ - ParserXBase* ICallback::GetParent() - { - assert(m_pParent); - return m_pParent; - } - - //------------------------------------------------------------------------------ - void ICallback::SetArgc(int argc) - { - m_nArgc = argc; - } - - //------------------------------------------------------------------------------ - /** \brief Returns the m´number of arguments required by this callback. - \return Number of arguments or -1 if the number of arguments is variable. - */ - int ICallback::GetArgc() const - { - return m_nArgc; - } - - //------------------------------------------------------------------------------ - /** \brief Assign a parser object to the callback. - \param a_pParent The parser that belongs to this callback object. - - The parent object can be used in order to access internals of the parser - from within a callback object. Thus enabling callbacks to delete - variables or functions if this is desired. - */ - void ICallback::SetParent(parent_type *a_pParent) - { - assert(a_pParent); - m_pParent = a_pParent; - } - - //------------------------------------------------------------------------------ - string_type ICallback::AsciiDump() const - { - stringstream_type ss; - - ss << g_sCmdCode[ GetCode() ]; - ss << _T(" [addr=0x") << std::hex << this << std::dec; - ss << _T("; pos=") << GetExprPos(); - ss << _T("; id=\"") << GetIdent() << "\""; - ss << _T("; argc=") << GetArgc() << " (found: " << m_nArgsPresent << ")"; - ss << _T("]"); - - return ss.str(); - } - - //------------------------------------------------------------------------------ - void ICallback::SetNumArgsPresent(int argc) - { - m_nArgsPresent = argc; - } - - //------------------------------------------------------------------------------ - int ICallback::GetArgsPresent() const - { - if (m_nArgc!=-1) - return m_nArgc; - else - return m_nArgsPresent; - } -} // namespace mu diff --git a/src/third-party/headers/muparserx/mpIOprt.cpp b/src/third-party/headers/muparserx/mpIOprt.cpp deleted file mode 100644 index 5ccf807e0c..0000000000 --- a/src/third-party/headers/muparserx/mpIOprt.cpp +++ /dev/null @@ -1,170 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - muParserX - A C++ math parser library with array and string support - Copyright (c) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpIOprt.h" - -#include "mpError.h" - - -MUP_NAMESPACE_START - - //------------------------------------------------------------------------------ - // - // Binary Operators - // - //------------------------------------------------------------------------------ - - IOprtBin::IOprtBin(const char_type *a_szIdent, int nPrec, EOprtAsct eAsc) - :ICallback(cmOPRT_BIN, a_szIdent, 2) - ,IPrecedence() - ,m_nPrec(nPrec) - ,m_eAsc(eAsc) - {} - - //------------------------------------------------------------------------------ - IOprtBin::~IOprtBin() - {} - - //------------------------------------------------------------------------------ - string_type IOprtBin::AsciiDump() const - { - stringstream_type ss; - - ss << g_sCmdCode[ GetCode() ]; - ss << _T(" [addr=0x") << std::hex << this << std::dec; - ss << _T("; pos=") << GetExprPos(); - ss << _T("; id=\"") << GetIdent() << _T("\""); - ss << _T("; prec=") << GetPri(); - ss << _T("; argc=") << GetArgc(); - ss << _T("]"); - - return ss.str(); - } - - //------------------------------------------------------------------------------ - int IOprtBin::GetPri() const - { - return m_nPrec; - } - - //------------------------------------------------------------------------------ - EOprtAsct IOprtBin::GetAssociativity() const - { - return m_eAsc; - } - - //--------------------------------------------------------------------------- - IPrecedence* IOprtBin::AsIPrecedence() - { - return this; - } - - //------------------------------------------------------------------------------ - // - // Unary Postfix Operators - // - //------------------------------------------------------------------------------ - - IOprtPostfix::IOprtPostfix(const char_type *a_szIdent) - :ICallback(cmOPRT_POSTFIX, a_szIdent, 1) - {} - - //------------------------------------------------------------------------------ - IOprtPostfix::~IOprtPostfix() - {} - - //------------------------------------------------------------------------------ - string_type IOprtPostfix::AsciiDump() const - { - stringstream_type ss; - - ss << g_sCmdCode[ GetCode() ]; - ss << _T(" [addr=0x") << std::hex << this << std::dec; - ss << _T("; pos=") << GetExprPos(); - ss << _T("; id=\"") << GetIdent() << _T("\""); - ss << _T("; argc=") << GetArgc(); - ss << _T("]"); - - return ss.str(); - } - - //------------------------------------------------------------------------------ - // - // Unary Infix Operators - // - //------------------------------------------------------------------------------ - - IOprtInfix::IOprtInfix(const char_type *a_szIdent, int nPrec) - :ICallback(cmOPRT_INFIX, a_szIdent, 1) - ,IPrecedence() - ,m_nPrec(nPrec) - {} - - //------------------------------------------------------------------------------ - IOprtInfix::~IOprtInfix() - {} - - //------------------------------------------------------------------------------ - string_type IOprtInfix::AsciiDump() const - { - stringstream_type ss; - - ss << g_sCmdCode[ GetCode() ]; - ss << _T(" [addr=0x") << std::hex << this << std::dec; - ss << _T("; pos=") << GetExprPos(); - ss << _T("; id=\"") << GetIdent() << _T("\""); - ss << _T("; argc=") << GetArgc(); - ss << _T("]"); - - return ss.str(); - } - - //--------------------------------------------------------------------------- - IPrecedence* IOprtInfix::AsIPrecedence() - { - return this; - } - - //------------------------------------------------------------------------------ - int IOprtInfix::GetPri() const - { - return m_nPrec; - } - - //------------------------------------------------------------------------------ - EOprtAsct IOprtInfix::GetAssociativity() const - { - return oaNONE; - } -} // namespace mu diff --git a/src/third-party/headers/muparserx/mpIPackage.cpp b/src/third-party/headers/muparserx/mpIPackage.cpp deleted file mode 100644 index f534584cc5..0000000000 --- a/src/third-party/headers/muparserx/mpIPackage.cpp +++ /dev/null @@ -1,51 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - muParserX - A C++ math parser library with array and string support - Copyright (c) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpIPackage.h" - -#include "mpDefines.h" -#include "mpParserBase.h" - - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------ -IPackage::IPackage() -{} - -//------------------------------------------------------------------------------ -IPackage::~IPackage() -{} - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpIToken.cpp b/src/third-party/headers/muparserx/mpIToken.cpp deleted file mode 100644 index 4f261815ca..0000000000 --- a/src/third-party/headers/muparserx/mpIToken.cpp +++ /dev/null @@ -1,325 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - muParserX - A C++ math parser library with array and string support - Copyright (c) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpIToken.h" -#include -#include -#include -#include -#include - -#include "mpIPrecedence.h" - -MUP_NAMESPACE_START - -#ifdef MUP_LEAKAGE_REPORT - std::list IToken::s_Tokens; -#endif - -#ifndef _UNICODE - - //--------------------------------------------------------------------------- - /** \brief Overloaded streaming operator for outputting the value type - into an std::ostream. - \param a_Stream The stream object - \param a_Val The value object to be streamed - - This function is only present if _UNICODE is not defined. - */ - std::ostream& operator<<(std::ostream &a_Stream, const IToken &tok) - { - return a_Stream << tok.ToString(); - } - -#else - - //--------------------------------------------------------------------------- - /** \brief Overloaded streaming operator for outputting the value type - into an std::ostream. - \param a_Stream The stream object - \param a_Val The value object to be streamed - - This function is only present if _UNICODE is defined. - */ - std::wostream& operator<<(std::wostream &a_Stream, const IToken &tok) - { - return a_Stream << tok.ToString(); - } -#endif - -#ifdef MUP_LEAKAGE_REPORT - - void IToken::LeakageReport() - { - using namespace std; - - console() << "\n"; - console() << "Memory leakage report:\n\n"; - if (IToken::s_Tokens.size()) - { - list::const_iterator item = IToken::s_Tokens.begin(); - std::vector stat(cmCOUNT, 0); - for (; item!=IToken::s_Tokens.end(); ++item) - { - console() << "Addr: 0x" << hex << *item << " Ident: \"" << (*item)->GetIdent() << "\""; - console() << "\tCode: " << g_sCmdCode[(*item)->GetCode()] << "\n"; - stat[(*item)->GetCode()]++; - } - console() << "Leaked tokens: " << dec << (int)IToken::s_Tokens.size() << std::endl; - - for (int i=0; i::iterator it = std::find(IToken::s_Tokens.begin(), IToken::s_Tokens.end(), this); - IToken::s_Tokens.remove(this); -#endif - } - - //------------------------------------------------------------------------------ - /** \brief Copy constructor. - \param ref The token to copy basic state information from. - - The copy constructor must be implemented in order not to screw up - the reference count of the created object. CC's are used in the - Clone function and they would start with a reference count != 0 - introducing memory leaks if the default CC where used. - */ - IToken::IToken(const IToken &ref) - { - m_eCode = ref.m_eCode; - m_sIdent = ref.m_sIdent; - m_flags = ref.m_flags; - m_nPosExpr = ref.m_nPosExpr; - - // The following items must be initialised - // (rather than just beeing copied) - m_nRefCount = 0; - } - - //------------------------------------------------------------------------------ - void IToken::ResetRef() - { - m_nRefCount = 0; - } - - //------------------------------------------------------------------------------ - void IToken::Release() - { - delete this; - } - - //------------------------------------------------------------------------------ - string_type IToken::ToString() const - { - return AsciiDump(); - } - - //------------------------------------------------------------------------------ - int IToken::GetExprPos() const - { - return m_nPosExpr; - } - - //------------------------------------------------------------------------------ - void IToken::SetExprPos(int nPos) - { - m_nPosExpr = nPos; - } - - //------------------------------------------------------------------------------ - /** \brief return the token code. - - \sa ECmdCode - */ - ECmdCode IToken::GetCode() const - { - return m_eCode; - } - - //------------------------------------------------------------------------------ - /** \brief Return the token identifier string. */ - const string_type& IToken::GetIdent() const - { - return m_sIdent; - } - - //------------------------------------------------------------------------------ - void IToken::SetIdent(const string_type &a_sIdent) - { - m_sIdent = a_sIdent; - } - - //------------------------------------------------------------------------------ - string_type IToken::AsciiDump() const - { - stringstream_type ss; - ss << g_sCmdCode[m_eCode]; - return ss.str().c_str(); - } - - //------------------------------------------------------------------------------ - void IToken::IncRef() const - { - ++m_nRefCount; - } - - //------------------------------------------------------------------------------ - long IToken::DecRef() const - { - return --m_nRefCount; - } - - //------------------------------------------------------------------------------ - long IToken::GetRef() const - { - return m_nRefCount; - } - - //--------------------------------------------------------------------------- - void IToken::AddFlags(int flags) - { - m_flags |= flags; - } - - //--------------------------------------------------------------------------- - bool IToken::IsFlagSet(int flags) const - { - return (m_flags & flags)==flags; - } - - //--------------------------------------------------------------------------- - ICallback* IToken::AsICallback() - { - return nullptr; - } - - //--------------------------------------------------------------------------- - IValue* IToken::AsIValue() - { - return nullptr; - } - - //--------------------------------------------------------------------------- - IPrecedence* IToken::AsIPrecedence() - { - return nullptr; - } - - //------------------------------------------------------------------------------ - void IToken::Compile(const string_type & /*sArg*/) - { - } - - //--------------------------------------------------------------------------- - // - // Generic token implementation - // - //--------------------------------------------------------------------------- - - GenericToken::GenericToken(ECmdCode a_iCode, string_type a_sIdent) - :IToken(a_iCode, a_sIdent) - {} - - //--------------------------------------------------------------------------- - GenericToken::GenericToken(ECmdCode a_iCode) - :IToken(a_iCode, _T("")) - {} - - //--------------------------------------------------------------------------- - GenericToken::~GenericToken() - {} - - //--------------------------------------------------------------------------- - GenericToken::GenericToken(const GenericToken &a_Tok) - :IToken(a_Tok) - {} - - //--------------------------------------------------------------------------- - IToken* GenericToken::Clone() const - { - return new GenericToken(*this); - } - - //------------------------------------------------------------------------------ - string_type GenericToken::AsciiDump() const - { - stringstream_type ss; - - ss << g_sCmdCode[ GetCode() ]; - ss << _T(" [addr=0x") << std::hex << this << _T("]"); - - return ss.str(); - } - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpIValReader.cpp b/src/third-party/headers/muparserx/mpIValReader.cpp deleted file mode 100644 index ab6c629e96..0000000000 --- a/src/third-party/headers/muparserx/mpIValReader.cpp +++ /dev/null @@ -1,72 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - muParserX - A C++ math parser library with array and string support - Copyright (c) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpIValReader.h" -#include "mpTokenReader.h" - -#include - - -MUP_NAMESPACE_START - -//-------------------------------------------------------------------------------------------- - IValueReader::IValueReader() - :m_pTokenReader(nullptr) - {} - - //-------------------------------------------------------------------------------------------- - IValueReader::~IValueReader() - {} - - //-------------------------------------------------------------------------------------------- - IValueReader::IValueReader(const IValueReader &ref) - { - m_pTokenReader = ref.m_pTokenReader; - } - - //-------------------------------------------------------------------------------------------- - void IValueReader::SetParent(TokenReader *pTokenReader) - { - assert(pTokenReader); - m_pTokenReader = pTokenReader; - } - - //-------------------------------------------------------------------------------------------- - const IToken* IValueReader::TokenHistory(std::size_t pos) const - { - const TokenReader::token_buf_type &buf = m_pTokenReader->GetTokens(); - std::size_t size = buf.size(); - return (pos>=size) ? nullptr : buf[size-1-pos].Get(); - } -} diff --git a/src/third-party/headers/muparserx/mpIValue.cpp b/src/third-party/headers/muparserx/mpIValue.cpp deleted file mode 100644 index 878b3d0889..0000000000 --- a/src/third-party/headers/muparserx/mpIValue.cpp +++ /dev/null @@ -1,449 +0,0 @@ -/** \file - \brief Implementation of the virtual base class used for all parser values. - -
          -                __________                                 ____  ___
          -     _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -    /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
          -    |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
          -    |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -          \/                     \/           \/     \/           \_/
          -    Copyright (C) 2016 Ingo Berg
          -    All rights reserved.
          -
          -    muParserX - A C++ math parser library with array and string support
          -    Copyright (c) 2016, Ingo Berg
          -    All rights reserved.
          -
          -    Redistribution and use in source and binary forms, with or without
          -    modification, are permitted provided that the following conditions are met:
          -
          -    * Redistributions of source code must retain the above copyright notice,
          -    this list of conditions and the following disclaimer.
          -    * Redistributions in binary form must reproduce the above copyright notice,
          -    this list of conditions and the following disclaimer in the documentation
          -    and/or other materials provided with the distribution.
          -
          -    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
          -    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
          -    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
          -    IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
          -    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
          -    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
          -    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
          -    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
          -    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
          -    POSSIBILITY OF SUCH DAMAGE.
          -    
          - */ -#include "mpIValue.h" - -//--- Standard includes ------------------------------------------------------ -#include -#include -#include -#include - -//--- muParserX framework ----------------------------------------------------- -#include "mpValue.h" -#include "mpError.h" -#include "mpValue.h" - - -MUP_NAMESPACE_START - -#ifndef _UNICODE - -//--------------------------------------------------------------------------- -/** \brief Overloaded streaming operator for outputting the value type - into an std::ostream. - \param a_Stream The stream object - \param a_Val The value object to be streamed - - This function is only present if _UNICODE is not defined. - */ - std::ostream& operator<<(std::ostream &a_Stream, const IValue &a_Val) -{ - return a_Stream << a_Val.ToString(); -} - -#else - -//--------------------------------------------------------------------------- -/** \brief Overloaded streaming operator for outputting the value type - into an std::ostream. - \param a_Stream The stream object - \param a_Val The value object to be streamed - - This function is only present if _UNICODE is defined. - */ - std::wostream& operator<<(std::wostream &a_Stream, const IValue &a_Val) -{ - return a_Stream << a_Val.ToString(); -} -#endif - -//--------------------------------------------------------------------------------------------- -Value operator*(const IValue& lhs, const IValue& rhs) -{ - return Value(lhs) *= rhs; -} - -//--------------------------------------------------------------------------- -IValue::IValue(ECmdCode a_iCode) - :IToken(a_iCode) -{ - assert(a_iCode == cmVAL); -} - -//--------------------------------------------------------------------------- -IValue::IValue(ECmdCode a_iCode, const string_type &a_sIdent) - :IToken(a_iCode, a_sIdent) -{ - assert(a_iCode == cmVAL); -} - -//--------------------------------------------------------------------------- -IValue::~IValue() -{} - -//--------------------------------------------------------------------------- -ICallback* IValue::AsICallback() -{ - return nullptr; -} - -//--------------------------------------------------------------------------- -IValue* IValue::AsIValue() -{ - return this; -} - -//--------------------------------------------------------------------------- -string_type IValue::ToString() const -{ - stringstream_type ss; - switch (GetType()) - { - case 'm': - { - const matrix_type &arr(GetArray()); - - if (arr.GetRows() > 1) - ss << _T("{"); - - for (int i = 0; i < arr.GetRows(); ++i) - { - if (arr.GetCols()>1) - ss << _T("{"); - - for (int j = 0; j < arr.GetCols(); ++j) - { - ss << arr.At(i, j).ToString(); - if (j != arr.GetCols() - 1) - ss << _T(", "); - } - - if (arr.GetCols()>1) - ss << _T("}"); - - if (i != arr.GetRows() - 1) - ss << _T("; "); - } - - if (arr.GetRows() > 1) - ss << _T("} "); - } - break; - - case 'c': - { - float_type re = GetFloat(), - im = GetImag(); - - // realteil nicht ausgeben, wenn es eine rein imaginäre Zahl ist - if (im == 0 || re != 0 || (im == 0 && re == 0)) - ss << re; - - if (im != 0) - { - if (im > 0 && re != 0) - ss << _T("+"); - - if (im != 1) - ss << im; - - ss << _T("i"); - } - } - break; - - case 'i': - case 'f': ss << std::setprecision(std::numeric_limits::digits10) << GetFloat(); break; - case 's': ss << _T("\"") << GetString() << _T("\""); break; - case 'b': ss << ((GetBool() == true) ? _T("true") : _T("false")); break; - case 'v': ss << _T("void"); break; - default: ss << _T("internal error: unknown value type."); break; - } - - return ss.str(); -} - -//--------------------------------------------------------------------------- -bool IValue::operator==(const IValue &a_Val) const -{ - char_type type1 = GetType(), - type2 = a_Val.GetType(); - - if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) - { - switch (GetType()) - { - case 'i': - case 'f': return GetFloat() == a_Val.GetFloat(); - case 'c': return GetComplex() == a_Val.GetComplex(); - case 's': return GetString() == a_Val.GetString(); - case 'b': return GetBool() == a_Val.GetBool(); - case 'v': return false; - case 'm': if (GetRows() != a_Val.GetRows() || GetCols() != a_Val.GetCols()) - { - return false; - } - else - { - for (int i = 0; i < GetRows(); ++i) - { - if (const_cast(this)->At(i) != const_cast(a_Val).At(i)) - return false; - } - - return true; - } - default: - ErrorContext err; - err.Errc = ecINTERNAL_ERROR; - err.Pos = -1; - err.Type1 = GetType(); - err.Type2 = a_Val.GetType(); - throw ParserError(err); - } // switch this type - } - else - { - return false; - } -} - -//--------------------------------------------------------------------------- -bool IValue::operator!=(const IValue &a_Val) const -{ - char_type type1 = GetType(), - type2 = a_Val.GetType(); - - if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) - { - switch (GetType()) - { - case 's': return GetString() != a_Val.GetString(); - case 'i': - case 'f': return GetFloat() != a_Val.GetFloat(); - case 'c': return (GetFloat() != a_Val.GetFloat()) || (GetImag() != a_Val.GetImag()); - case 'b': return GetBool() != a_Val.GetBool(); - case 'v': return true; - case 'm': if (GetRows() != a_Val.GetRows() || GetCols() != a_Val.GetCols()) - { - return true; - } - else - { - for (int i = 0; i < GetRows(); ++i) - { - if (const_cast(this)->At(i) != const_cast(a_Val).At(i)) - return true; - } - - return false; - } - default: - ErrorContext err; - err.Errc = ecINTERNAL_ERROR; - err.Pos = -1; - err.Type2 = GetType(); - err.Type1 = a_Val.GetType(); - throw ParserError(err); - } // switch this type - } - else - { - return true; - } -} - -//--------------------------------------------------------------------------- -bool IValue::operator<(const IValue &a_Val) const -{ - char_type type1 = GetType(); - char_type type2 = a_Val.GetType(); - - if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) - { - switch (GetType()) - { - case 's': return GetString() < a_Val.GetString(); - case 'i': - case 'f': - case 'c': return GetFloat() < a_Val.GetFloat(); - case 'b': return GetBool() < a_Val.GetBool(); - - default: - ErrorContext err; - err.Errc = ecINTERNAL_ERROR; - err.Pos = -1; - err.Type1 = GetType(); - err.Type2 = a_Val.GetType(); - throw ParserError(err); - } // switch this type - } - else - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT_FUN; - err.Arg = (type1 != 'f' && type1 != 'i') ? 1 : 2; - err.Type1 = type2; - err.Type2 = type1; - throw ParserError(err); - } -} - -//--------------------------------------------------------------------------- -bool IValue::operator> (const IValue &a_Val) const -{ - char_type type1 = GetType(), - type2 = a_Val.GetType(); - - if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) - { - switch (GetType()) - { - case 's': return GetString() > a_Val.GetString(); - case 'i': - case 'f': - case 'c': return GetFloat() > a_Val.GetFloat(); - case 'b': return GetBool() > a_Val.GetBool(); - default: - ErrorContext err; - err.Errc = ecINTERNAL_ERROR; - err.Pos = -1; - err.Type1 = GetType(); - err.Type2 = a_Val.GetType(); - throw ParserError(err); - - } // switch this type - } - else - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT_FUN; - err.Arg = (type1 != 'f' && type1 != 'i') ? 1 : 2; - err.Type1 = type2; - err.Type2 = type1; - throw ParserError(err); - } -} - -//--------------------------------------------------------------------------- -bool IValue::operator>=(const IValue &a_Val) const -{ - char_type type1 = GetType(), - type2 = a_Val.GetType(); - - if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) - { - switch (GetType()) - { - case 's': return GetString() >= a_Val.GetString(); - case 'i': - case 'f': - case 'c': return GetFloat() >= a_Val.GetFloat(); - case 'b': return GetBool() >= a_Val.GetBool(); - default: - ErrorContext err; - err.Errc = ecINTERNAL_ERROR; - err.Pos = -1; - err.Type1 = GetType(); - err.Type2 = a_Val.GetType(); - throw ParserError(err); - - } // switch this type - } - else - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT_FUN; - err.Arg = (type1 != 'f' && type1 != 'i') ? 1 : 2; - err.Type1 = type2; - err.Type2 = type1; - throw ParserError(err); - } -} - -//--------------------------------------------------------------------------- -bool IValue::operator<=(const IValue &a_Val) const -{ - char_type type1 = GetType(), - type2 = a_Val.GetType(); - - if (type1 == type2 || (IsScalar() && a_Val.IsScalar())) - { - switch (GetType()) - { - case 's': return GetString() <= a_Val.GetString(); - case 'i': - case 'f': - case 'c': return GetFloat() <= a_Val.GetFloat(); - case 'b': return GetBool() <= a_Val.GetBool(); - default: - ErrorContext err; - err.Errc = ecINTERNAL_ERROR; - err.Pos = -1; - err.Type1 = GetType(); - err.Type2 = a_Val.GetType(); - throw ParserError(err); - - } // switch this type - } - else - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT_FUN; - err.Arg = (type1 != 'f' && type1 != 'i') ? 1 : 2; - err.Type1 = type2; - err.Type2 = type1; - throw ParserError(err); - } -} - -//--------------------------------------------------------------------------- -IValue& IValue::operator=(const IValue &ref) -{ - if (this == &ref) - return *this; - - switch (ref.GetType()) - { - case 'i': - case 'f': - case 'c': return *this = cmplx_type(ref.GetFloat(), ref.GetImag()); - case 's': return *this = ref.GetString(); - case 'm': return *this = ref.GetArray(); - case 'b': return *this = ref.GetBool(); - case 'v': - throw ParserError(_T("Assignment from void type is not possible")); - - default: - throw ParserError(_T("Internal error: unexpected data type identifier in IValue& operator=(const IValue &ref)")); - } -} - - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpIfThenElse.cpp b/src/third-party/headers/muparserx/mpIfThenElse.cpp deleted file mode 100644 index 3d5a76fc09..0000000000 --- a/src/third-party/headers/muparserx/mpIfThenElse.cpp +++ /dev/null @@ -1,100 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - muParserX - A C++ math parser library with array and string support - Copyright (c) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpIfThenElse.h" - -MUP_NAMESPACE_START - - //--------------------------------------------------------------------------- - // - // If part of if-then-else clauses - // - //--------------------------------------------------------------------------- - - TokenIfThenElse::TokenIfThenElse(ECmdCode eCode) - :IToken(eCode, g_sCmdCode[ eCode ]) - ,IPrecedence() - ,m_nOffset() - {} - - //--------------------------------------------------------------------------- - IToken* TokenIfThenElse::Clone() const - { - return new TokenIfThenElse(*this); - } - - //--------------------------------------------------------------------------- - void TokenIfThenElse::SetOffset(int nOffset) - { - m_nOffset = nOffset; - } - - //--------------------------------------------------------------------------- - int TokenIfThenElse::GetOffset() const - { - return m_nOffset; - } - - //--------------------------------------------------------------------------- - string_type TokenIfThenElse::AsciiDump() const - { - stringstream_type ss; - - ss << GetIdent(); - ss << _T(" [addr=0x") << std::hex << this << std::dec; - ss << _T("; pos=") << GetExprPos(); - ss << _T("; offset=") << m_nOffset; - ss << _T("]"); - return ss.str(); - } - - //--------------------------------------------------------------------------- - int TokenIfThenElse::GetPri() const - { - return (int)prIF_THEN_ELSE; - } - - //--------------------------------------------------------------------------- - EOprtAsct TokenIfThenElse::GetAssociativity() const - { - return oaNONE; - } - - //--------------------------------------------------------------------------- - IPrecedence* TokenIfThenElse::AsIPrecedence() - { - return this; - } - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpOprtBinAssign.cpp b/src/third-party/headers/muparserx/mpOprtBinAssign.cpp deleted file mode 100644 index 18fed101c9..0000000000 --- a/src/third-party/headers/muparserx/mpOprtBinAssign.cpp +++ /dev/null @@ -1,249 +0,0 @@ -/** \file - \brief This file contains the implementation of binary assignment - operators used in muParser. - -
          -               __________                                 ____  ___
          -    _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
          -  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
          -  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -        \/                     \/           \/     \/           \_/
          -                                       Copyright (C) 2016, Ingo Berg
          -                                       All rights reserved.
          -
          -  Redistribution and use in source and binary forms, with or without 
          -  modification, are permitted provided that the following conditions are met:
          -
          -   * Redistributions of source code must retain the above copyright notice, 
          -     this list of conditions and the following disclaimer.
          -   * Redistributions in binary form must reproduce the above copyright notice, 
          -     this list of conditions and the following disclaimer in the documentation 
          -     and/or other materials provided with the distribution.
          -
          -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
          -  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
          -  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
          -  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
          -  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
          -  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
          -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
          -  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
          -  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
          -  POSSIBILITY OF SUCH DAMAGE.
          -
          -*/ -#include "mpOprtBinAssign.h" - - -MUP_NAMESPACE_START - - //--------------------------------------------------------------------- - // - // class OprtAssign - // - //--------------------------------------------------------------------- - - OprtAssign::OprtAssign() - :IOprtBin(_T("="), (int)prASSIGN, oaLEFT) - {} - - //--------------------------------------------------------------------- - const char_type* OprtAssign::GetDesc() const - { - return _T("'=' assignement operator"); - } - - //--------------------------------------------------------------------- - IToken* OprtAssign::Clone() const - { - return new OprtAssign(*this); - } - - //--------------------------------------------------------------------- - void OprtAssign::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - Variable *pVar = dynamic_cast(a_pArg[0].Get()); - - // assigment to non variable type - if (!pVar) - { - ErrorContext err; - err.Arg = 1; - err.Ident = _T("="); - err.Errc = ecASSIGNEMENT_TO_VALUE; - throw ParserError(err); - } - - *pVar = *a_pArg[1]; //pVar->SetFloat(a_pArg[1]->GetFloat()); - *ret = *pVar; - } - - //--------------------------------------------------------------------- - // - // class OprtAssignAdd - // - //--------------------------------------------------------------------- - - OprtAssignAdd::OprtAssignAdd() - :IOprtBin(_T("+="), (int)prASSIGN, oaLEFT) - {} - - //--------------------------------------------------------------------- - void OprtAssignAdd::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) - { - Variable *pVar = dynamic_cast(a_pArg[0].Get()); - - // assigment to non variable type - if (!pVar) - { - ErrorContext err; - err.Arg = 1; - err.Ident = _T("+="); - err.Errc = ecASSIGNEMENT_TO_VALUE; - throw ParserError(err); - } - - *pVar = cmplx_type(a_pArg[0]->GetFloat() + a_pArg[1]->GetFloat(), - a_pArg[0]->GetImag() + a_pArg[1]->GetImag()); - *ret = *pVar; - } - - //--------------------------------------------------------------------- - const char_type* OprtAssignAdd::GetDesc() const - { - return _T("assignement operator"); - } - - //--------------------------------------------------------------------- - IToken* OprtAssignAdd::Clone() const - { - return new OprtAssignAdd(*this); - } - - //--------------------------------------------------------------------- - // - // class OprtAssignAdd - // - //--------------------------------------------------------------------- - - OprtAssignSub::OprtAssignSub() - :IOprtBin(_T("-="), (int)prASSIGN, oaLEFT) - {} - - //--------------------------------------------------------------------- - void OprtAssignSub::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) - { - Variable *pVar = dynamic_cast(a_pArg[0].Get()); - if (!pVar) - { - ErrorContext err; - err.Arg = 1; - err.Ident = _T("-="); - err.Errc = ecASSIGNEMENT_TO_VALUE; - throw ParserError(err); - } - - *pVar = cmplx_type(a_pArg[0]->GetFloat() - a_pArg[1]->GetFloat(), - a_pArg[0]->GetImag() - a_pArg[1]->GetImag()); - *ret = *pVar; - } - - //--------------------------------------------------------------------- - const char_type* OprtAssignSub::GetDesc() const - { - return _T("assignement operator"); - } - - //--------------------------------------------------------------------- - IToken* OprtAssignSub::Clone() const - { - return new OprtAssignSub(*this); - } - - //--------------------------------------------------------------------- - // - // class OprtAssignAdd - // - //--------------------------------------------------------------------- - - OprtAssignMul::OprtAssignMul() - :IOprtBin(_T("*="), (int)prASSIGN, oaLEFT) - {} - - //--------------------------------------------------------------------- - void OprtAssignMul::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) - { - Variable *pVar = dynamic_cast(a_pArg[0].Get()); - if (!pVar) - { - ErrorContext err; - err.Arg = 1; - err.Ident = _T("*="); - err.Errc = ecASSIGNEMENT_TO_VALUE; - throw ParserError(err); - } - - float_type a = a_pArg[0]->GetFloat(), - b = a_pArg[0]->GetImag(), - c = a_pArg[1]->GetFloat(), - d = a_pArg[1]->GetImag(); - *pVar = cmplx_type(a*c-b*d, a*d-b*c); - *ret = *pVar; - } - - //--------------------------------------------------------------------- - const char_type* OprtAssignMul::GetDesc() const - { - return _T("multiply and assign operator"); - } - - //--------------------------------------------------------------------- - IToken* OprtAssignMul::Clone() const - { - return new OprtAssignMul(*this); - } - - //--------------------------------------------------------------------- - // - // class OprtAssignDiv - // - //--------------------------------------------------------------------- - - OprtAssignDiv::OprtAssignDiv() : IOprtBin(_T("/="), (int)prASSIGN, oaLEFT) - {} - - //------------------------------------------------------------------------------ - void OprtAssignDiv::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) - { - Variable *pVar = dynamic_cast(a_pArg[0].Get()); - if (!pVar) - { - ErrorContext err; - err.Arg = 1; - err.Ident = _T("/="); - err.Errc = ecASSIGNEMENT_TO_VALUE; - throw ParserError(err); - } - - float_type a = a_pArg[0]->GetFloat(), - b = a_pArg[0]->GetImag(), - c = a_pArg[1]->GetFloat(), - d = a_pArg[1]->GetImag(), - n = c*c + d*d; - *pVar = cmplx_type((a*c+b*d)/n, (b*c-a*d)/n); - *ret = *pVar; - } - - //------------------------------------------------------------------------------ - const char_type* OprtAssignDiv::GetDesc() const - { - return _T("multiply and divide operator"); - } - - //------------------------------------------------------------------------------ - IToken* OprtAssignDiv::Clone() const - { - return new OprtAssignDiv(*this); - } -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpOprtBinCommon.cpp b/src/third-party/headers/muparserx/mpOprtBinCommon.cpp deleted file mode 100644 index c1d6e225a2..0000000000 --- a/src/third-party/headers/muparserx/mpOprtBinCommon.cpp +++ /dev/null @@ -1,589 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - muParserX - A C++ math parser library with array and string support - Copyright (c) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. - */ -#include "mpOprtBinCommon.h" -#include -#include - - -MUP_NAMESPACE_START - -//----------------------------------------------------------------------------------------------- -// -// class OprtStrAdd -// -//----------------------------------------------------------------------------------------------- - -OprtStrAdd::OprtStrAdd() -:IOprtBin(_T("//"), (int)prADD_SUB, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtStrAdd::Eval(ptr_val_type& ret, const ptr_val_type *arg, int argc) -{ - MUP_VERIFY(argc == 2); - string_type a = arg[0]->GetString(); - string_type b = arg[1]->GetString(); - *ret = a + b; -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtStrAdd::GetDesc() const -{ - return _T("string concatenation"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtStrAdd::Clone() const -{ - return new OprtStrAdd(*this); -} - - -//----------------------------------------------------------------------------------------------- -// -// class OprtEQ -// -//----------------------------------------------------------------------------------------------- - -OprtEQ::OprtEQ() - :IOprtBin(_T("=="), (int)prRELATIONAL1, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtEQ::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) -{ - *ret = *a_pArg[0] == *a_pArg[1]; -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtEQ::GetDesc() const -{ - return _T("equals operator"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtEQ::Clone() const -{ - return new OprtEQ(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtNEQ -// -//----------------------------------------------------------------------------------------------- - -OprtNEQ::OprtNEQ() - :IOprtBin(_T("!="), (int)prRELATIONAL1, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtNEQ::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) -{ - *ret = *a_pArg[0] != *a_pArg[1]; -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtNEQ::GetDesc() const -{ - return _T("not equal operator"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtNEQ::Clone() const -{ - return new OprtNEQ(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtLT -// -//----------------------------------------------------------------------------------------------- - -OprtLT::OprtLT() - :IOprtBin(_T("<"), (int)prRELATIONAL2, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtLT::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) -{ - *ret = *a_pArg[0] < *a_pArg[1]; -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtLT::GetDesc() const -{ - return _T("less than operator"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtLT::Clone() const -{ - return new OprtLT(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtGT -// -//----------------------------------------------------------------------------------------------- - -OprtGT::OprtGT() - :IOprtBin(_T(">"), (int)prRELATIONAL2, oaLEFT) {} - -//----------------------------------------------------------------------------------------------- -void OprtGT::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) -{ - *ret = *a_pArg[0] > *a_pArg[1]; -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtGT::GetDesc() const -{ - return _T("greater than operator"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtGT::Clone() const -{ - return new OprtGT(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtLE -// -//----------------------------------------------------------------------------------------------- - -OprtLE::OprtLE() - :IOprtBin(_T("<="), (int)prRELATIONAL2, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtLE::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) -{ - *ret = *a_pArg[0] <= *a_pArg[1]; -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtLE::GetDesc() const -{ - return _T("less or equal operator"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtLE::Clone() const -{ - return new OprtLE(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtGE -// -//----------------------------------------------------------------------------------------------- - -OprtGE::OprtGE() - :IOprtBin(_T(">="), (int)prRELATIONAL2, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtGE::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int) -{ - *ret = *a_pArg[0] >= *a_pArg[1]; -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtGE::GetDesc() const -{ - return _T("greater or equal operator"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtGE::Clone() const -{ - return new OprtGE(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtAnd -// -//----------------------------------------------------------------------------------------------- - -OprtAnd::OprtAnd() - :IOprtBin(_T("&"), (int)prBIT_AND, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtAnd::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) -{ - MUP_VERIFY(num == 2); - - if (!a_pArg[0]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[0]->GetType(), 'i', 1)); - - if (!a_pArg[1]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[1]->GetType(), 'i', 2)); - - float_type a = a_pArg[0]->GetFloat(), - b = a_pArg[1]->GetFloat(); - - if (a != (int_type)a) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, a_pArg[0]->GetIdent(), a_pArg[0]->GetType(), 'i', 1)); - - if (b != (int_type)b) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, a_pArg[1]->GetIdent(), a_pArg[1]->GetType(), 'i', 2)); - - *ret = (float_type)((int_type)a & (int_type)(b)); -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtAnd::GetDesc() const -{ - return _T("bitwise and"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtAnd::Clone() const -{ - return new OprtAnd(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtOr -// -//----------------------------------------------------------------------------------------------- - -OprtOr::OprtOr() - :IOprtBin(_T("|"), (int)prBIT_OR, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtOr::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) -{ - MUP_VERIFY(num == 2); - - if (!a_pArg[0]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[0]->GetType(), 'i', 1)); - - if (!a_pArg[1]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[1]->GetType(), 'i', 2)); - - float_type a = a_pArg[0]->GetFloat(), - b = a_pArg[1]->GetFloat(); - - if (a != (int_type)a) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, a_pArg[0]->GetIdent(), a_pArg[0]->GetType(), 'i', 1)); - - if (b != (int_type)b) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, a_pArg[1]->GetIdent(), a_pArg[1]->GetType(), 'i', 2)); - - *ret = (float_type)((int_type)a | (int_type)(b)); -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtOr::GetDesc() const -{ - return _T("bitwise or"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtOr::Clone() const -{ - return new OprtOr(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtLOr -// -//----------------------------------------------------------------------------------------------- - -OprtLOr::OprtLOr(const char_type *szIdent) - :IOprtBin(szIdent, (int)prLOGIC_OR, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtLOr::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) -{ - MUP_VERIFY(num == 2); - *ret = a_pArg[0]->GetBool() || a_pArg[1]->GetBool(); -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtLOr::GetDesc() const -{ - return _T("logical or"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtLOr::Clone() const -{ - return new OprtLOr(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtLAnd -// -//----------------------------------------------------------------------------------------------- - -OprtLAnd::OprtLAnd(const char_type *szIdent) - :IOprtBin(szIdent, (int)prLOGIC_AND, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtLAnd::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) -{ - MUP_VERIFY(num == 2); - *ret = a_pArg[0]->GetBool() && a_pArg[1]->GetBool(); -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtLAnd::GetDesc() const -{ - return _T("logical and"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtLAnd::Clone() const -{ - return new OprtLAnd(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtShl -// -//----------------------------------------------------------------------------------------------- - -OprtShl::OprtShl() - :IOprtBin(_T("<<"), (int)prSHIFT, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtShl::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) -{ - MUP_VERIFY(num == 2); - - if (!a_pArg[0]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[0]->GetType(), 'i', 1)); - - if (!a_pArg[1]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[1]->GetType(), 'i', 2)); - - float_type a = a_pArg[0]->GetFloat(), - b = a_pArg[1]->GetFloat(); - - if (a != (int_type)a) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), a_pArg[0]->GetIdent(), a_pArg[0]->GetType(), 'i', 1)); - - if (b != (int_type)b) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), a_pArg[1]->GetIdent(), a_pArg[1]->GetType(), 'i', 2)); - - float_type result = a*std::pow(2, b); - int numDigits = std::numeric_limits::digits10; - - if (std::fabs(result) >= std::fabs(std::pow(10.0, numDigits))) - throw ParserError(ErrorContext(ecOVERFLOW, GetExprPos(), GetIdent())); - - if (result > 0) - { - *ret = std::floor(result); - } - else - { - *ret = std::ceil(result); - } -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtShl::GetDesc() const -{ - return _T("shift left"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtShl::Clone() const -{ - return new OprtShl(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// class OprtShr -// -//----------------------------------------------------------------------------------------------- - -OprtShr::OprtShr() - :IOprtBin(_T(">>"), (int)prSHIFT, oaLEFT) -{} - -//----------------------------------------------------------- -void OprtShr::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) -{ - MUP_VERIFY(num == 2); - - if (!a_pArg[0]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[0]->GetType(), 'i', 1)); - - if (!a_pArg[1]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[1]->GetType(), 'i', 2)); - - float_type a = a_pArg[0]->GetFloat(), - b = a_pArg[1]->GetFloat(); - - if (a != (int_type)a) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), a_pArg[0]->GetIdent(), a_pArg[0]->GetType(), 'i', 1)); - - if (b != (int_type)b) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), a_pArg[1]->GetIdent(), a_pArg[1]->GetType(), 'i', 2)); - - float_type result = a*std::pow(2, -b); - int numDigits = std::numeric_limits::digits10; - - if (std::fabs(result) >= std::fabs(std::pow(10.0, numDigits))) - throw ParserError(ErrorContext(ecOVERFLOW, GetExprPos(), GetIdent())); - - if (result > 0) - *ret = std::floor(result); - else - *ret = std::ceil(result); -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtShr::GetDesc() const -{ - return _T("shift right"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtShr::Clone() const -{ - return new OprtShr(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// Cast To Float -// -//----------------------------------------------------------------------------------------------- - -OprtCastToFloat::OprtCastToFloat() - :IOprtInfix(_T("(float)"), prINFIX) -{} - -//----------------------------------------------------------------------------------------------- -void OprtCastToFloat::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int /*a_iArgc*/) -{ - switch (a_pArg[0]->GetType()) - { - case 'i': - case 'f': - case 'b': - *ret = a_pArg[0]->GetFloat(); - break; - - default: - { - ErrorContext err; - err.Errc = ecINVALID_TYPECAST; - err.Type1 = a_pArg[0]->GetType(); - err.Type2 = 'f'; - throw ParserError(err); - } - } // switch value type -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtCastToFloat::GetDesc() const -{ - return _T("cast a value into a floating point number"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtCastToFloat::Clone() const -{ - return new OprtCastToFloat(*this); -} - -//----------------------------------------------------------------------------------------------- -// -// Cast To Int -// -//----------------------------------------------------------------------------------------------- - -OprtCastToInt::OprtCastToInt() - :IOprtInfix(_T("(int)"), prINFIX) -{} - -//----------------------------------------------------------------------------------------------- -void OprtCastToInt::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int /*a_iArgc*/) -{ - switch (a_pArg[0]->GetType()) - { - case 'f': - case 'i': - case 'b': - *ret = (float_type)((int_type)a_pArg[0]->GetFloat()); - break; - - default: - { - ErrorContext err; - err.Errc = ecINVALID_TYPECAST; - err.Type1 = a_pArg[0]->GetType(); - err.Type2 = 'i'; - throw ParserError(err); - } - } // switch value type -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtCastToInt::GetDesc() const -{ - return _T("cast a value into a floating point number"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtCastToInt::Clone() const -{ - return new OprtCastToInt(*this); -} - -} diff --git a/src/third-party/headers/muparserx/mpOprtCmplx.cpp b/src/third-party/headers/muparserx/mpOprtCmplx.cpp deleted file mode 100644 index dfc6da5a44..0000000000 --- a/src/third-party/headers/muparserx/mpOprtCmplx.cpp +++ /dev/null @@ -1,321 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - muParserX - A C++ math parser library with array and string support - Copyright (c) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. - */ -#include "mpOprtCmplx.h" -#include -#include - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------------------------- -// -// class OprtSignCmplx -// -//------------------------------------------------------------------------------------------------- - -OprtSignCmplx::OprtSignCmplx() -:IOprtInfix(_T("-"), prINFIX) -{} - -//----------------------------------------------------------------------------------------------- -void OprtSignCmplx::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) -{ - MUP_VERIFY(a_iArgc == 1); - - if (a_pArg[0]->IsScalar()) - { - float_type re = a_pArg[0]->GetFloat(); - float_type im = a_pArg[0]->GetImag(); - - // Do not omit the test for zero! Multiplying 0 with -1 - // will yield -0 on IEEE754 compliant implementations! - // This would change the result of complex calculations: - // - // i.e. sqrt(-1 + (-0)i) != sqrt(-1 + 0i) - // -i != i - cmplx_type v((re == 0) ? 0 : -re, (im == 0) ? 0 : -im); - *ret = v; - } - else if (a_pArg[0]->GetType() == 'm') - { - Value v(a_pArg[0]->GetRows(), 0); - for (int i = 0; i < a_pArg[0]->GetRows(); ++i) - { - v.At(i) = a_pArg[0]->At(i).GetComplex() * (float_type)-1.0; - } - *ret = v; - } - else - { - ErrorContext err; - err.Errc = ecINVALID_TYPE; - err.Type1 = a_pArg[0]->GetType(); - err.Type2 = 's'; - throw ParserError(err); - } -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtSignCmplx::GetDesc() const -{ - return _T("negative sign operator"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtSignCmplx::Clone() const -{ - return new OprtSignCmplx(*this); -} - -//------------------------------------------------------------------------------------------------- -// -// class OprtAddCmplx -// -//------------------------------------------------------------------------------------------------- - -OprtAddCmplx::OprtAddCmplx() -:IOprtBin(_T("+"), (int)prADD_SUB, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtAddCmplx::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int num) -{ - assert(num == 2); - - const IValue *arg1 = a_pArg[0].Get(); - const IValue *arg2 = a_pArg[1].Get(); - - if (arg1->IsNonComplexScalar() && arg2->IsNonComplexScalar()) - { - *ret = arg1->GetFloat() + arg2->GetFloat(); - } - else if (arg1->GetType() == 'm' && arg2->GetType() == 'm') - { - // Matrix + Matrix - *ret = arg1->GetArray() + arg2->GetArray(); - } - else - { - if (!arg1->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), arg1->GetType(), 'c', 1)); - - if (!arg2->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), arg2->GetType(), 'c', 2)); - - *ret = cmplx_type(arg1->GetFloat() + arg2->GetFloat(), - arg1->GetImag() + arg2->GetImag()); - } -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtAddCmplx::GetDesc() const -{ - return _T("addition"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtAddCmplx::Clone() const -{ - return new OprtAddCmplx(*this); -} - -//------------------------------------------------------------------------------------------------- -// -// class OprtSubCmplx -// -//------------------------------------------------------------------------------------------------- - -OprtSubCmplx::OprtSubCmplx() -:IOprtBin(_T("-"), (int)prADD_SUB, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtSubCmplx::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) -{ - assert(num == 2); - - const IValue *arg1 = a_pArg[0].Get(); - const IValue *arg2 = a_pArg[1].Get(); - if (a_pArg[0]->IsNonComplexScalar() && a_pArg[1]->IsNonComplexScalar()) - { - *ret = arg1->GetFloat() - arg2->GetFloat(); - } - else if (a_pArg[0]->GetType() == 'm' && a_pArg[1]->GetType() == 'm') - { - // Matrix + Matrix - *ret = arg1->GetArray() - arg2->GetArray(); - } - else - { - if (!a_pArg[0]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[0]->GetType(), 'c', 1)); - - if (!a_pArg[1]->IsScalar()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), a_pArg[1]->GetType(), 'c', 2)); - - *ret = cmplx_type(a_pArg[0]->GetFloat() - a_pArg[1]->GetFloat(), - a_pArg[0]->GetImag() - a_pArg[1]->GetImag()); - } -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtSubCmplx::GetDesc() const -{ - return _T("subtraction"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtSubCmplx::Clone() const -{ - return new OprtSubCmplx(*this); -} - -//------------------------------------------------------------------------------------------------- -// -// class OprtMulCmplx -// -//------------------------------------------------------------------------------------------------- - -OprtMulCmplx::OprtMulCmplx() -:IOprtBin(_T("*"), (int)prMUL_DIV, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtMulCmplx::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) -{ - assert(num == 2); - IValue *arg1 = a_pArg[0].Get(); - IValue *arg2 = a_pArg[1].Get(); - *ret = (*arg1) * (*arg2); -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtMulCmplx::GetDesc() const -{ - return _T("foo*bar - multiplication"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtMulCmplx::Clone() const -{ - return new OprtMulCmplx(*this); -} - -//------------------------------------------------------------------------------------------------- -// -// class OprtDivCmplx -// -//------------------------------------------------------------------------------------------------- - - -OprtDivCmplx::OprtDivCmplx() -:IOprtBin(_T("/"), (int)prMUL_DIV, oaLEFT) -{} - -//----------------------------------------------------------------------------------------------- -/** \brief Implements the Division operator. - \throw ParserError in case one of the arguments if - nonnumeric or an array. - - */ -void OprtDivCmplx::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) -{ - assert(num == 2); - - if (a_pArg[0]->IsNonComplexScalar() && a_pArg[1]->IsNonComplexScalar()) - { - *ret = a_pArg[0]->GetFloat() / a_pArg[1]->GetFloat(); - } - else - { - // multiplication of two imaginary numbers - float_type a = a_pArg[0]->GetFloat(), - b = a_pArg[0]->GetImag(), - c = a_pArg[1]->GetFloat(), - d = a_pArg[1]->GetImag(), - n = c*c + d*d; - *ret = cmplx_type((a*c + b*d) / n, (b*c - a*d) / n); - } -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtDivCmplx::GetDesc() const -{ - return _T("division"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtDivCmplx::Clone() const -{ - return new OprtDivCmplx(*this); -} - -//------------------------------------------------------------------------------------------------- -// -// class OprtPowCmplx -// -//------------------------------------------------------------------------------------------------- - -OprtPowCmplx::OprtPowCmplx() -:IOprtBin(_T("^"), (int)prPOW, oaRIGHT) -{} - -//----------------------------------------------------------------------------------------------- -void OprtPowCmplx::Eval(ptr_val_type& ret, const ptr_val_type *arg, int argc) -{ - assert(argc == 2); - - if (arg[0]->IsComplex() || arg[1]->IsComplex() || (arg[0]->GetFloat() < 0 && !arg[1]->IsInteger())) - { - *ret = std::pow(arg[0]->GetComplex(), arg[1]->GetComplex());; - } - else - { - *ret = std::pow(arg[0]->GetFloat(), arg[1]->GetFloat()); - } -} - -//----------------------------------------------------------------------------------------------- -const char_type* OprtPowCmplx::GetDesc() const -{ - return _T("raise x to the power of y"); -} - -//----------------------------------------------------------------------------------------------- -IToken* OprtPowCmplx::Clone() const -{ - return new OprtPowCmplx(*this); -} - -} // namespace diff --git a/src/third-party/headers/muparserx/mpOprtIndex.cpp b/src/third-party/headers/muparserx/mpOprtIndex.cpp deleted file mode 100644 index 56700636af..0000000000 --- a/src/third-party/headers/muparserx/mpOprtIndex.cpp +++ /dev/null @@ -1,117 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpOprtIndex.h" -#include "mpVariable.h" - -MUP_NAMESPACE_START - - //----------------------------------------------------------------------------------------------- - // - // class OprtIndex - // - //----------------------------------------------------------------------------------------------- - - OprtIndex::OprtIndex() - :ICallback(cmIC, _T("Index operator"), -1) - {} - - //----------------------------------------------------------------------------------------------- - /** \brief Index operator implementation - \param ret A reference to the return value - \param a_pArg Pointer to an array with the indices as ptr_val_type - \param a_iArgc Number of indices (=dimension) actully used in the expression found. This must - be 1 or 2 since three dimensional data structures are not supported by muParserX. - */ - void OprtIndex::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) - { - try - { - int rows = a_pArg[-1]->GetRows(); - int cols = a_pArg[-1]->GetCols(); - bool bArgIsVariable = a_pArg[-1]->IsVariable(); - - // If the index operator is applied to a variable the return value is also a variable - // pointing to a specific cell in the matrix. If the operator is applied to a value - // the return value is also a value. - switch (a_iArgc) - { - case 1: - if (cols == 1) - { - if (bArgIsVariable) - ret.Reset(new Variable(&(ret->At(*a_pArg[0], Value(0.0))))); - else - *ret = ret->At(*a_pArg[0], Value(0.0)); - } - else if (rows == 1) - { - if (bArgIsVariable) - ret.Reset(new Variable(&(ret->At(Value(0.0), *a_pArg[0])))); - else - *ret = ret->At(Value(0.0), *a_pArg[0]); - } - else - { - throw ParserError(ErrorContext(ecINDEX_DIMENSION, -1, GetIdent())); - } - break; - - case 2: - if (bArgIsVariable) - ret.Reset(new Variable(&(ret->At(*a_pArg[0], *a_pArg[1])))); - else - *ret = ret->At(*a_pArg[0], *a_pArg[1]); - break; - - default: - throw ParserError(ErrorContext(ecINDEX_DIMENSION, -1, GetIdent())); - } - } - catch(ParserError &exc) - { - exc.GetContext().Pos = GetExprPos(); - throw exc; - } - } - - //----------------------------------------------------------------------------------------------- - const char_type* OprtIndex::GetDesc() const - { - return _T("[,] - The index operator."); - } - - //----------------------------------------------------------------------------------------------- - IToken* OprtIndex::Clone() const - { - return new OprtIndex(*this); - } - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpOprtMatrix.cpp b/src/third-party/headers/muparserx/mpOprtMatrix.cpp deleted file mode 100644 index b06ed6f06c..0000000000 --- a/src/third-party/headers/muparserx/mpOprtMatrix.cpp +++ /dev/null @@ -1,182 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpOprtMatrix.h" - - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------------------------- -// -// class OprtTranspose -// -//------------------------------------------------------------------------------------------------- - - OprtTranspose::OprtTranspose() - :IOprtPostfix(_T("'")) - {} - - //------------------------------------------------------------------------------------------------- - void OprtTranspose::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int /*a_iArgc*/) - { - if (a_pArg[0]->IsMatrix()) - { - matrix_type matrix = a_pArg[0]->GetArray(); - matrix.Transpose(); - *ret = matrix; - } - else - *ret = *a_pArg[0]; - } - - //------------------------------------------------------------------------------------------------- - const char_type* OprtTranspose::GetDesc() const - { - return _T("foo' - An operator for transposing a matrix."); - } - - //------------------------------------------------------------------------------------------------- - IToken* OprtTranspose::Clone() const - { - return new OprtTranspose(*this); - } - - //----------------------------------------------------------------------------------------------- - // - // class OprtCreateArray - // - //----------------------------------------------------------------------------------------------- - - OprtCreateArray::OprtCreateArray() - :ICallback(cmCBC, _T("Array constructor"), -1) - {} - - //----------------------------------------------------------------------------------------------- - /** \brief Index operator implementation - \param ret A reference to the return value - \param a_pArg Pointer to an array with the indices as ptr_val_type - \param a_iArgc Number of indices (=dimension) actully used in the expression found. This must - be 1 or 2 since three dimensional data structures are not supported by muParserX. - */ - void OprtCreateArray::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) - { - try - { - // The index is -1. - if (a_iArgc <= 0) - { - throw ParserError(ErrorContext(ecINVALID_PARAMETER, -1, GetIdent())); - } - - matrix_type m(a_iArgc, 1, 0.0); - for (int i = 0; i < a_iArgc; ++i) - { - if (a_pArg[i]->GetDim() != 0) - { - // Prevent people from using this constructor for matrix creation. - // This would not work as expected and i dont't want them - // to get used to awkward workarounds. It's just not working right now ok? - ErrorContext errc(ecINVALID_PARAMETER, -1, GetIdent()); - errc.Arg = i+1; - throw ParserError(errc); - } - - m.At(i) = *a_pArg[i]; - } - m.Transpose(); - - *ret = m; - } - catch (ParserError &exc) - { - exc.GetContext().Pos = GetExprPos(); - throw exc; - } - } - - //----------------------------------------------------------------------------------------------- - const char_type* OprtCreateArray::GetDesc() const - { - return _T("{,} - Array construction operator."); - } - - //----------------------------------------------------------------------------------------------- - IToken* OprtCreateArray::Clone() const - { - return new OprtCreateArray(*this); - } - -//----------------------------------------------------------- -// -// class OprtColon -// -//----------------------------------------------------------- - - OprtColon::OprtColon() - :IOprtBin(_T("~"), (int)prCOLON, oaLEFT) - {} - - //----------------------------------------------------------- - void OprtColon::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int num) - { - assert(num==2); - - const IValue *argMin = a_pArg[0].Get(); - const IValue *argMax = a_pArg[1].Get(); - - if (!argMin->IsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), argMin->GetType(), 'i', 1)); - - if (!argMax->IsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), argMax->GetType(), 'i', 1)); - - if (*argMax < *argMin) - throw ParserError(_T("Colon operator: Maximum value smaller than Minimum!")); - - int n = (int)(argMax->GetFloat() - argMin->GetFloat()) + 1; - matrix_type arr(n); - for (int i=0; iGetFloat() + i; - - *ret = arr; - } - - //----------------------------------------------------------- - const char_type* OprtColon::GetDesc() const - { - return _T(": - Colon operator"); - } - - //----------------------------------------------------------- - IToken* OprtColon::Clone() const - { - return new OprtColon(*this); - } -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpOprtNonCmplx.cpp b/src/third-party/headers/muparserx/mpOprtNonCmplx.cpp deleted file mode 100644 index d58ef632c3..0000000000 --- a/src/third-party/headers/muparserx/mpOprtNonCmplx.cpp +++ /dev/null @@ -1,423 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016 Ingo Berg - All rights reserved. - - muParserX - A C++ math parser library with array and string support - Copyright (c) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpOprtNonCmplx.h" - -MUP_NAMESPACE_START - - //------------------------------------------------------------------------------ - // - // Sign operator - // - //------------------------------------------------------------------------------ - - OprtSign::OprtSign() - :IOprtInfix( _T("-"), prINFIX) - {} - - //------------------------------------------------------------------------------ - void OprtSign::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) - { - MUP_VERIFY(a_iArgc == 1); - - if (a_pArg[0]->IsScalar()) - { - *ret = -a_pArg[0]->GetFloat(); - } - else if (a_pArg[0]->GetType()=='m') - { - Value v(a_pArg[0]->GetRows(), 0); - for (int i=0; iGetRows(); ++i) - { - v.At(i) = -a_pArg[0]->At(i).GetFloat(); - } - *ret = v; - } - else - { - ErrorContext err; - err.Errc = ecINVALID_TYPE; - err.Type1 = a_pArg[0]->GetType(); - err.Type2 = 's'; - throw ParserError(err); - } - } - - //------------------------------------------------------------------------------ - const char_type* OprtSign::GetDesc() const - { - return _T("-x - negative sign operator"); - } - - //------------------------------------------------------------------------------ - IToken* OprtSign::Clone() const - { - return new OprtSign(*this); - } - - //------------------------------------------------------------------------------ - // - // Sign operator - // - //------------------------------------------------------------------------------ - - OprtSignPos::OprtSignPos() - :IOprtInfix( _T("+"), prINFIX) - {} - - //------------------------------------------------------------------------------ - void OprtSignPos::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int a_iArgc) - { - MUP_VERIFY(a_iArgc == 1); - - if (a_pArg[0]->IsScalar()) - { - *ret = a_pArg[0]->GetFloat(); - } - else if (a_pArg[0]->GetType()=='m') - { - Value v(a_pArg[0]->GetRows(), 0); - for (int i=0; iGetRows(); ++i) - { - v.At(i) = a_pArg[0]->At(i).GetFloat(); - } - *ret = v; - } - else - { - ErrorContext err; - err.Errc = ecINVALID_TYPE; - err.Type1 = a_pArg[0]->GetType(); - err.Type2 = 's'; - throw ParserError(err); - } - } - - //------------------------------------------------------------------------------ - const char_type* OprtSignPos::GetDesc() const - { - return _T("+x - positive sign operator"); - } - - //------------------------------------------------------------------------------ - IToken* OprtSignPos::Clone() const - { - return new OprtSignPos(*this); - } - -//----------------------------------------------------------- -// -// class OprtAdd -// -//----------------------------------------------------------- - - OprtAdd::OprtAdd() - :IOprtBin(_T("+"), (int)prADD_SUB, oaLEFT) - {} - - //----------------------------------------------------------- - void OprtAdd::Eval(ptr_val_type& ret, const ptr_val_type *a_pArg, int num) - { - assert(num==2); - - const IValue *arg1 = a_pArg[0].Get(); - const IValue *arg2 = a_pArg[1].Get(); - if (arg1->GetType()=='m' && arg2->GetType()=='m') - { - // Vector + Vector - const matrix_type &a1 = arg1->GetArray(), - &a2 = arg2->GetArray(); - if (a1.GetRows()!=a2.GetRows()) - throw ParserError(ErrorContext(ecARRAY_SIZE_MISMATCH, -1, GetIdent(), 'm', 'm', 2)); - - matrix_type rv(a1.GetRows()); - for (int i=0; iIsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg1->GetType(), 'f', 1)); - - if (!arg2->IsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg2->GetType(), 'f', 2)); - - *ret = arg1->GetFloat() + arg2->GetFloat(); - } - } - - //----------------------------------------------------------- - const char_type* OprtAdd::GetDesc() const - { - return _T("x+y - Addition for noncomplex values"); - } - - //----------------------------------------------------------- - IToken* OprtAdd::Clone() const - { - return new OprtAdd(*this); - } - -//----------------------------------------------------------- -// -// class OprtSub -// -//----------------------------------------------------------- - - OprtSub::OprtSub() - :IOprtBin(_T("-"), (int)prADD_SUB, oaLEFT) - {} - - //----------------------------------------------------------- - void OprtSub::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) - { - assert(num==2); - - if (a_pArg[0]->GetType()=='m' && a_pArg[1]->GetType()=='m') - { - const matrix_type &a1 = a_pArg[0]->GetArray(), - &a2 = a_pArg[1]->GetArray(); - if (a1.GetRows()!=a2.GetRows()) - throw ParserError(ErrorContext(ecARRAY_SIZE_MISMATCH, -1, GetIdent(), 'm', 'm', 2)); - - matrix_type rv(a1.GetRows()); - for (int i=0; iIsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[0]->GetType(), 'f', 1)); - - if (!a_pArg[1]->IsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[1]->GetType(), 'f', 2)); - - *ret = a_pArg[0]->GetFloat() - a_pArg[1]->GetFloat(); - } - } - - //----------------------------------------------------------- - const char_type* OprtSub::GetDesc() const - { - return _T("subtraction"); - } - - //----------------------------------------------------------- - IToken* OprtSub::Clone() const - { - return new OprtSub(*this); - } - -//----------------------------------------------------------- -// -// class OprtMul -// -//----------------------------------------------------------- - - OprtMul::OprtMul() - :IOprtBin(_T("*"), (int)prMUL_DIV, oaLEFT) - {} - - //----------------------------------------------------------- - void OprtMul::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) - { - assert(num==2); - IValue *arg1 = a_pArg[0].Get(); - IValue *arg2 = a_pArg[1].Get(); - if (arg1->GetType()=='m' && arg2->GetType()=='m') - { - // Scalar multiplication - matrix_type a1 = arg1->GetArray(); - matrix_type a2 = arg2->GetArray(); - - if (a1.GetRows()!=a2.GetRows()) - throw ParserError(ErrorContext(ecARRAY_SIZE_MISMATCH, -1, GetIdent(), 'm', 'm', 2)); - - float_type val(0); - for (int i=0; iGetType()=='m' && arg2->IsNonComplexScalar()) - { - // Skalar * Vector - matrix_type out(a_pArg[0]->GetArray()); - for (int i=0; iGetFloat(); - - *ret = out; - } - else if (arg2->GetType()=='m' && arg1->IsNonComplexScalar()) - { - // Vector * Skalar - matrix_type out(arg2->GetArray()); - for (int i=0; iGetFloat(); - - *ret = out; - } - else - { - if (!arg1->IsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg1->GetType(), 'f', 1)); - - if (!arg2->IsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), arg2->GetType(), 'f', 2)); - - *ret = arg1->GetFloat() * arg2->GetFloat(); - } - } - - //----------------------------------------------------------- - const char_type* OprtMul::GetDesc() const - { - return _T("multiplication"); - } - - //----------------------------------------------------------- - IToken* OprtMul::Clone() const - { - return new OprtMul(*this); - } - -//----------------------------------------------------------- -// -// class OprtDiv -// -//----------------------------------------------------------- - - - OprtDiv::OprtDiv() - :IOprtBin(_T("/"), (int)prMUL_DIV, oaLEFT) - {} - - //----------------------------------------------------------- - /** \brief Implements the Division operator. - \throw ParserError in case one of the arguments if - nonnumeric or an array. - - */ - void OprtDiv::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int num) - { - assert(num==2); - - if (!a_pArg[0]->IsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[0]->GetType(), 'f', 1)); - - if (!a_pArg[1]->IsNonComplexScalar()) - throw ParserError( ErrorContext(ecTYPE_CONFLICT_FUN, -1, GetIdent(), a_pArg[1]->GetType(), 'f', 2)); - - *ret = a_pArg[0]->GetFloat() / a_pArg[1]->GetFloat(); - } - - //----------------------------------------------------------- - const char_type* OprtDiv::GetDesc() const - { - return _T("division"); - } - - //----------------------------------------------------------- - IToken* OprtDiv::Clone() const - { - return new OprtDiv(*this); - } - -//----------------------------------------------------------- -// -// class OprtPow -// -//----------------------------------------------------------- - - OprtPow::OprtPow() - :IOprtBin(_T("^"), (int)prPOW, oaRIGHT) - {} - - //----------------------------------------------------------- - void OprtPow::Eval(ptr_val_type& ret, const ptr_val_type *arg, int argc) - { - assert(argc==2); - float_type a = arg[0]->GetFloat(); - float_type b = arg[1]->GetFloat(); - - int ib = (int)b; - if (b-ib==0) - { - switch (ib) - { - case 1: *ret = a; return; - case 2: *ret = a*a; return; - case 3: *ret = a*a*a; return; - case 4: *ret = a*a*a*a; return; - case 5: *ret = a*a*a*a*a; return; - default: *ret = std::pow(a, ib); return; - } - } - else - *ret = std::pow(a, b); - } - - //----------------------------------------------------------- - const char_type* OprtPow::GetDesc() const - { - return _T("x^y - Raises x to the power of y."); - } - - //----------------------------------------------------------- - IToken* OprtPow::Clone() const - { - return new OprtPow(*this); - } -} diff --git a/src/third-party/headers/muparserx/mpOprtPostfixCommon.cpp b/src/third-party/headers/muparserx/mpOprtPostfixCommon.cpp deleted file mode 100755 index f8ba01e895..0000000000 --- a/src/third-party/headers/muparserx/mpOprtPostfixCommon.cpp +++ /dev/null @@ -1,112 +0,0 @@ -#include -#include "mpOprtPostfixCommon.h" - -MUP_NAMESPACE_START - -//----------------------------------------------------------- -// -// class OprtFact -// -//----------------------------------------------------------- - - OprtFact::OprtFact() - :IOprtPostfix(_T("!")) - {} - - //----------------------------------------------------------- - void OprtFact::Eval(ptr_val_type& ret, const ptr_val_type *arg, int) - { - if (!arg[0]->IsInteger()) - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), arg[0]->GetType(), 'i', 1)); - - int_type input = arg[0]->GetInteger(); - float_type input_long = float_type(input); - - if (input < 0) { - throw ParserError(ErrorContext(ecDOMAIN_ERROR, GetExprPos(), - GetIdent())); - } - - float_type result = 1; - for (float_type i = 1.0; i <= input_long; i += 1.0) - { - result *= i; - - // Only throw exceptions if IEEE 754 is not supported. The - // Prefered way of dealing with overflows is relying on: - // - // http://en.wikipedia.org/wiki/IEEE_754-1985 - // - // If the compiler does not support IEEE 754, chances are - // you are running on a pretty fucked up system. - // - #ifdef _MSC_VER - #pragma warning(push) - #pragma warning(disable:4127) - #endif /* _MSC_VER */ - if ( !std::numeric_limits::is_iec559 && - (result>std::numeric_limits::max() || result < 1.0) ) - #ifdef _MSC_VER - #pragma warning(pop) - #endif /* _MSC_VER */ - { - throw ParserError(ErrorContext(ecOVERFLOW, GetExprPos(), GetIdent())); - } - // - } - - *ret = result; - } - - //----------------------------------------------------------- - const char_type* OprtFact::GetDesc() const - { - return _T("x! - Returns factorial of a non-negative integer."); - } - - //----------------------------------------------------------- - IToken* OprtFact::Clone() const - { - return new OprtFact(*this); - } - - //----------------------------------------------------------- - // - // class OprtPercentage - // - //----------------------------------------------------------- - - OprtPercentage::OprtPercentage() - :IOprtPostfix(_T("%")) - {} - - //----------------------------------------------------------- - void OprtPercentage::Eval(ptr_val_type& ret, const ptr_val_type *arg, int) - { - - switch (arg[0]->GetType()) { - case 'i': - case 'f': { - float_type input = arg[0]->GetFloat(); - *ret = input / 100.0; - break; - } - default: - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, GetExprPos(), GetIdent(), arg[0]->GetType(), 'f', 1)); - break; - } - } - - //----------------------------------------------------------- - const char_type* OprtPercentage::GetDesc() const - { - return _T("x% - Returns percentage of integer/float."); - } - - //----------------------------------------------------------- - IToken* OprtPercentage::Clone() const - { - return new OprtPercentage(*this); - } - -} diff --git a/src/third-party/headers/muparserx/mpPackageCmplx.cpp b/src/third-party/headers/muparserx/mpPackageCmplx.cpp deleted file mode 100644 index 29435c48f1..0000000000 --- a/src/third-party/headers/muparserx/mpPackageCmplx.cpp +++ /dev/null @@ -1,102 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpPackageCmplx.h" - -#include "mpParserBase.h" -#include "mpFuncCmplx.h" -#include "mpOprtCmplx.h" -#include "mpOprtBinCommon.h" - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------ -std::unique_ptr PackageCmplx::s_pInstance; - -//------------------------------------------------------------------------------ -IPackage* PackageCmplx::Instance() -{ - if (s_pInstance.get()==nullptr) - { - s_pInstance.reset(new PackageCmplx); - } - - return s_pInstance.get(); -} - -//------------------------------------------------------------------------------ -void PackageCmplx::AddToParser(ParserXBase *pParser) -{ - // Constants - pParser->DefineConst( _T("i"), cmplx_type(0.0, 1.0) ); - - // Complex valued functions - pParser->DefineFun(new FunCmplxReal()); - pParser->DefineFun(new FunCmplxImag()); - pParser->DefineFun(new FunCmplxConj()); - pParser->DefineFun(new FunCmplxArg()); - pParser->DefineFun(new FunCmplxNorm()); - pParser->DefineFun(new FunCmplxSin()); - pParser->DefineFun(new FunCmplxCos()); - pParser->DefineFun(new FunCmplxTan()); - pParser->DefineFun(new FunCmplxSinH()); - pParser->DefineFun(new FunCmplxCosH()); - pParser->DefineFun(new FunCmplxTanH()); - pParser->DefineFun(new FunCmplxSqrt()); - pParser->DefineFun(new FunCmplxExp()); - pParser->DefineFun(new FunCmplxLn()); - pParser->DefineFun(new FunCmplxLog()); - pParser->DefineFun(new FunCmplxLog2()); - pParser->DefineFun(new FunCmplxLog10()); - pParser->DefineFun(new FunCmplxAbs()); - pParser->DefineFun(new FunCmplxPow()); - - // Complex valued operators - pParser->DefineOprt(new OprtAddCmplx()); - pParser->DefineOprt(new OprtSubCmplx()); - pParser->DefineOprt(new OprtMulCmplx()); - pParser->DefineOprt(new OprtDivCmplx()); - pParser->DefineOprt(new OprtPowCmplx()); - pParser->DefineInfixOprt(new OprtSignCmplx()); -} - -//------------------------------------------------------------------------------ -string_type PackageCmplx::GetDesc() const -{ - return _T(""); -} - -//------------------------------------------------------------------------------ -string_type PackageCmplx::GetPrefix() const -{ - return _T(""); -} - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageCommon.cpp b/src/third-party/headers/muparserx/mpPackageCommon.cpp deleted file mode 100644 index 30fec3c1c0..0000000000 --- a/src/third-party/headers/muparserx/mpPackageCommon.cpp +++ /dev/null @@ -1,141 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpPackageCommon.h" - -#include "mpParserBase.h" -#include "mpFuncNonCmplx.h" -#include "mpFuncCommon.h" -#include "mpOprtBinCommon.h" -#include "mpOprtBinAssign.h" -#include "mpOprtPostfixCommon.h" -#include "mpValReader.h" - -/** \brief Pi (what else?). */ -#define MUP_CONST_PI 3.141592653589793238462643 -//#define MUP_CONST_PI 3.14159265358979323846264338327950288419716939937510L - -/** \brief The eulerian number. */ -#define MUP_CONST_E 2.718281828459045235360287 - - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------ -std::unique_ptr PackageCommon::s_pInstance; - -//------------------------------------------------------------------------------ -IPackage* PackageCommon::Instance() -{ - if (s_pInstance.get()==nullptr) - { - s_pInstance.reset(new PackageCommon); - } - - return s_pInstance.get(); -} - -//------------------------------------------------------------------------------ -void PackageCommon::AddToParser(ParserXBase *pParser) -{ - // Readers that need fancy decorations on their values must - // be added first (i.e. hex -> "0x...") Otherwise the - // zero in 0x will be read as a value of zero! - pParser->AddValueReader(new HexValReader); - pParser->AddValueReader(new BinValReader); - pParser->AddValueReader(new DblValReader); - pParser->AddValueReader(new BoolValReader); - - // Constants - pParser->DefineConst( _T("pi"), (float_type)MUP_CONST_PI ); - pParser->DefineConst( _T("e"), (float_type)MUP_CONST_E ); - - // Vector - pParser->DefineFun(new FunSizeOf()); - - // Generic functions - pParser->DefineFun(new FunMax()); - pParser->DefineFun(new FunMin()); - pParser->DefineFun(new FunSum()); - - // misc - pParser->DefineFun(new FunParserID); - - // integer package - pParser->DefineOprt(new OprtLAnd); - pParser->DefineOprt(new OprtLOr); - pParser->DefineOprt(new OprtAnd); - pParser->DefineOprt(new OprtOr); - pParser->DefineOprt(new OprtShr); - pParser->DefineOprt(new OprtShl); - - // booloean package - pParser->DefineOprt(new OprtLE); - pParser->DefineOprt(new OprtGE); - pParser->DefineOprt(new OprtLT); - pParser->DefineOprt(new OprtGT); - pParser->DefineOprt(new OprtEQ); - pParser->DefineOprt(new OprtNEQ); - pParser->DefineOprt(new OprtLAnd(_T("and"))); // add logic and with a different identifier - pParser->DefineOprt(new OprtLOr(_T("or"))); // add logic and with a different identifier -// pParser->DefineOprt(new OprtBXor); - - // assignement operators - pParser->DefineOprt(new OprtAssign); - pParser->DefineOprt(new OprtAssignAdd); - pParser->DefineOprt(new OprtAssignSub); - pParser->DefineOprt(new OprtAssignMul); - pParser->DefineOprt(new OprtAssignDiv); - - // infix operators - pParser->DefineInfixOprt(new OprtCastToFloat); - pParser->DefineInfixOprt(new OprtCastToInt); - - // postfix operators - pParser->DefinePostfixOprt(new OprtFact); -// commented: "%" is a reserved sign for either the -// modulo operator or comment lines. -// pParser->DefinePostfixOprt(new OprtPercentage); -// -} - -//------------------------------------------------------------------------------ -string_type PackageCommon::GetDesc() const -{ - return _T(""); -} - -//------------------------------------------------------------------------------ -string_type PackageCommon::GetPrefix() const -{ - return _T(""); -} - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageMatrix.cpp b/src/third-party/headers/muparserx/mpPackageMatrix.cpp deleted file mode 100644 index 26dc20b949..0000000000 --- a/src/third-party/headers/muparserx/mpPackageMatrix.cpp +++ /dev/null @@ -1,82 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpPackageMatrix.h" - -#include "mpParserBase.h" -#include "mpFuncMatrix.h" -#include "mpOprtMatrix.h" - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------ -std::unique_ptr PackageMatrix::s_pInstance; - -//------------------------------------------------------------------------------ -IPackage* PackageMatrix::Instance() -{ - if (s_pInstance.get()==nullptr) - { - s_pInstance.reset(new PackageMatrix); - } - - return s_pInstance.get(); -} - -//------------------------------------------------------------------------------ -void PackageMatrix::AddToParser(ParserXBase *pParser) -{ - // Matrix functions - pParser->DefineFun(new FunMatrixOnes()); - pParser->DefineFun(new FunMatrixZeros()); - pParser->DefineFun(new FunMatrixEye()); - pParser->DefineFun(new FunMatrixSize()); - - // Matrix Operators - pParser->DefinePostfixOprt(new OprtTranspose()); - - // Colon operator -//pParser->DefineOprt(new OprtColon()); -//pParser->DefineAggregator(new AggColon()); -} - -//------------------------------------------------------------------------------ -string_type PackageMatrix::GetDesc() const -{ - return _T("Operators and functions for matrix operations"); -} - -//------------------------------------------------------------------------------ -string_type PackageMatrix::GetPrefix() const -{ - return _T(""); -} - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageNonCmplx.cpp b/src/third-party/headers/muparserx/mpPackageNonCmplx.cpp deleted file mode 100644 index fca5624429..0000000000 --- a/src/third-party/headers/muparserx/mpPackageNonCmplx.cpp +++ /dev/null @@ -1,108 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpPackageNonCmplx.h" - -#include "mpParserBase.h" -#include "mpFuncNonCmplx.h" -#include "mpOprtNonCmplx.h" -#include "mpOprtBinCommon.h" - - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------ -std::unique_ptr PackageNonCmplx::s_pInstance; - -//------------------------------------------------------------------------------ -IPackage* PackageNonCmplx::Instance() -{ - if (s_pInstance.get()==nullptr) - { - s_pInstance.reset(new PackageNonCmplx); - } - - return s_pInstance.get(); -} - -//------------------------------------------------------------------------------ -void PackageNonCmplx::AddToParser(ParserXBase *pParser) -{ - pParser->DefineFun(new FunSin()); - pParser->DefineFun(new FunCos()); - pParser->DefineFun(new FunTan()); - pParser->DefineFun(new FunSinH()); - pParser->DefineFun(new FunCosH()); - pParser->DefineFun(new FunTanH()); - pParser->DefineFun(new FunASin()); - pParser->DefineFun(new FunACos()); - pParser->DefineFun(new FunATan()); - pParser->DefineFun(new FunASinH()); - pParser->DefineFun(new FunACosH()); - pParser->DefineFun(new FunATanH()); - pParser->DefineFun(new FunLog()); - pParser->DefineFun(new FunLog10()); - pParser->DefineFun(new FunLog2()); - pParser->DefineFun(new FunLn()); - pParser->DefineFun(new FunExp()); - pParser->DefineFun(new FunSqrt()); - pParser->DefineFun(new FunCbrt()); - pParser->DefineFun(new FunAbs()); - - // binary functions - pParser->DefineFun(new FunPow()); - pParser->DefineFun(new FunHypot()); - pParser->DefineFun(new FunAtan2()); - pParser->DefineFun(new FunFmod()); - pParser->DefineFun(new FunRemainder()); - - // Operator callbacks - pParser->DefineInfixOprt(new OprtSign()); - pParser->DefineInfixOprt(new OprtSignPos()); - pParser->DefineOprt(new OprtAdd()); - pParser->DefineOprt(new OprtSub()); - pParser->DefineOprt(new OprtMul()); - pParser->DefineOprt(new OprtDiv()); - pParser->DefineOprt(new OprtPow); -} - -//------------------------------------------------------------------------------ -string_type PackageNonCmplx::GetDesc() const -{ - return _T(""); -} - -//------------------------------------------------------------------------------ -string_type PackageNonCmplx::GetPrefix() const -{ - return _T(""); -} - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageStr.cpp b/src/third-party/headers/muparserx/mpPackageStr.cpp deleted file mode 100644 index 2fc00a0ec7..0000000000 --- a/src/third-party/headers/muparserx/mpPackageStr.cpp +++ /dev/null @@ -1,81 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpPackageStr.h" - -#include "mpParserBase.h" -#include "mpFuncStr.h" -#include "mpOprtBinCommon.h" -#include "mpValReader.h" - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------ -std::unique_ptr PackageStr::s_pInstance; - -//------------------------------------------------------------------------------ -IPackage* PackageStr::Instance() -{ - if (s_pInstance.get()==nullptr) - { - s_pInstance.reset(new PackageStr); - } - - return s_pInstance.get(); -} - -//------------------------------------------------------------------------------ -void PackageStr::AddToParser(ParserXBase *pParser) -{ - pParser->AddValueReader(new StrValReader()); - - // Functions - pParser->DefineFun(new FunStrLen()); - pParser->DefineFun(new FunStrToDbl()); - pParser->DefineFun(new FunStrToUpper()); - pParser->DefineFun(new FunStrToLower()); - - // Operators - pParser->DefineOprt(new OprtStrAdd); -} - -//------------------------------------------------------------------------------ -string_type PackageStr::GetDesc() const -{ - return _T("A package for string operations."); -} - -//------------------------------------------------------------------------------ -string_type PackageStr::GetPrefix() const -{ - return _T(""); -} - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpPackageUnit.cpp b/src/third-party/headers/muparserx/mpPackageUnit.cpp deleted file mode 100644 index 7420e75e30..0000000000 --- a/src/third-party/headers/muparserx/mpPackageUnit.cpp +++ /dev/null @@ -1,119 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpPackageUnit.h" - -#include "mpParserBase.h" - - -MUP_NAMESPACE_START - -/** \brief This is a macro for defining scaling postfix operators. - - These operators can be used for unit conversions. -*/ -#define MUP_POSTFIX_IMLP(CLASS, IDENT, MUL, DESC) \ - CLASS::CLASS(IPackage*) \ - :IOprtPostfix(_T(IDENT)) \ - {} \ - \ - void CLASS::Eval(ptr_val_type &ret, const ptr_val_type *a_pArg, int) \ - { \ - if (!a_pArg[0]->IsScalar()) \ - { \ - ErrorContext err(ecTYPE_CONFLICT, \ - GetExprPos(), \ - a_pArg[0]->ToString(), \ - a_pArg[0]->GetType(), \ - 'c', \ - 1); \ - throw ParserError(err); \ - } \ - \ - *ret = a_pArg[0]->GetComplex() * MUL; \ - } \ - \ - const char_type* CLASS::GetDesc() const \ - { \ - return _T(DESC); \ - } \ - \ - IToken* CLASS::Clone() const \ - { \ - return new CLASS(*this); \ - } - - MUP_POSTFIX_IMLP(OprtNano, "n", (float_type)1e-9, "n - unit multiplicator 1e-9") - MUP_POSTFIX_IMLP(OprtMicro, "u", (float_type)1e-6, "u - unit multiplicator 1e-6") - MUP_POSTFIX_IMLP(OprtMilli, "m", (float_type)1e-3, "m - unit multiplicator 1e-3") - MUP_POSTFIX_IMLP(OprtKilo, "k", (float_type)1e3, "k - unit multiplicator 1e3") - MUP_POSTFIX_IMLP(OprtMega, "M", (float_type)1e6, "M - unit multiplicator 1e6") - MUP_POSTFIX_IMLP(OprtGiga, "G", (float_type)1e9, "G - unit multiplicator 1e9") - -#undef MUP_POSTFIX_IMLP - -//------------------------------------------------------------------------------ -std::unique_ptr PackageUnit::s_pInstance; - -//------------------------------------------------------------------------------ -IPackage* PackageUnit::Instance() -{ - if (s_pInstance.get()==nullptr) - { - s_pInstance.reset(new PackageUnit); - } - - return s_pInstance.get(); -} - -//------------------------------------------------------------------------------ -void PackageUnit::AddToParser(ParserXBase *pParser) -{ - pParser->DefinePostfixOprt(new OprtNano(this)); - pParser->DefinePostfixOprt(new OprtMicro(this)); - pParser->DefinePostfixOprt(new OprtMilli(this)); - pParser->DefinePostfixOprt(new OprtKilo(this)); - pParser->DefinePostfixOprt(new OprtMega(this)); - pParser->DefinePostfixOprt(new OprtGiga(this)); -} - -//------------------------------------------------------------------------------ -string_type PackageUnit::GetDesc() const -{ - return _T("Postfix operators for basic unit conversions."); -} - -//------------------------------------------------------------------------------ -string_type PackageUnit::GetPrefix() const -{ - return _T(""); -} - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpParser.cpp b/src/third-party/headers/muparserx/mpParser.cpp deleted file mode 100644 index 59ea64d8ba..0000000000 --- a/src/third-party/headers/muparserx/mpParser.cpp +++ /dev/null @@ -1,91 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ - -#include "mpParser.h" - -//--- Standard includes ---------------------------------------------------- -#include -#include -#include - -//--- Parser framework ----------------------------------------------------- -#include "mpPackageUnit.h" -#include "mpPackageStr.h" -#include "mpPackageCmplx.h" -#include "mpPackageNonCmplx.h" -#include "mpPackageCommon.h" -#include "mpPackageMatrix.h" - -using namespace std; - - -/** \brief Namespace for mathematical applications. */ -MUP_NAMESPACE_START - - //--------------------------------------------------------------------------- - /** \brief Default constructor. - - Call ParserXBase class constructor and initiate function, operator - and constant initialization. - */ - ParserX::ParserX(unsigned ePackages) - :ParserXBase() - { - DefineNameChars(_T("0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ")); - DefineOprtChars(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ+-*^/?<>=#!$%&|~'_µ{}")); - DefineInfixOprtChars(_T("abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ()/+-*^?<>=#!$%&|~'_")); - - if (ePackages & pckUNIT) - AddPackage(PackageUnit::Instance()); - - if (ePackages & pckSTRING) - AddPackage(PackageStr::Instance()); - - if (ePackages & pckCOMPLEX) - AddPackage(PackageCmplx::Instance()); - - if (ePackages & pckNON_COMPLEX) - AddPackage(PackageNonCmplx::Instance()); - - if (ePackages & pckCOMMON) - AddPackage(PackageCommon::Instance()); - - if (ePackages & pckMATRIX) - AddPackage(PackageMatrix::Instance()); - } - - //------------------------------------------------------------------------------ - void ParserX::ResetErrorMessageProvider(ParserMessageProviderBase *pProvider) - { - ParserErrorMsg::Reset(pProvider); - } - -} // namespace mu diff --git a/src/third-party/headers/muparserx/mpParserBase.cpp b/src/third-party/headers/muparserx/mpParserBase.cpp deleted file mode 100644 index cddb65103a..0000000000 --- a/src/third-party/headers/muparserx/mpParserBase.cpp +++ /dev/null @@ -1,1301 +0,0 @@ -/** \file - \brief Implementation of the muParserX engine. - -
          -			   __________                                 ____  ___
          -	 _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -	/     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
          -	|  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
          -	|__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -		  \/                     \/           \/     \/           \_/
          -	Copyright (C) 2016 Ingo Berg
          -	All rights reserved.
          -
          -	Redistribution and use in source and binary forms, with or without
          -	modification, are permitted provided that the following conditions are met:
          -
          -	* Redistributions of source code must retain the above copyright notice,
          -	this list of conditions and the following disclaimer.
          -	* Redistributions in binary form must reproduce the above copyright notice,
          -	this list of conditions and the following disclaimer in the documentation
          -	and/or other materials provided with the distribution.
          -
          -	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
          -	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
          -	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
          -	IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
          -	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
          -	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
          -	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
          -	WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
          -	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
          -	POSSIBILITY OF SUCH DAMAGE.
          -	
          - */ -#include "mpParserBase.h" - -#include -#include -#include -#include - -#include "utGeneric.h" -#include "mpDefines.h" -#include "mpIfThenElse.h" -#include "mpScriptTokens.h" - -using namespace std; - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------ -const char_type *g_sCmdCode[] = { - _T("BRCK. OPEN "), - _T("BRCK. CLOSE "), - _T("IDX OPEN "), - _T("IDX CLOSE "), - _T("CURLY BRCK. OPEN "), - _T("CURLY BRCK. CLOSE"), - _T("ARG_SEP "), - _T("IF "), - _T("ELSE "), - _T("ENDIF "), - _T("JMP "), - _T("VAL "), - _T("FUNC "), - _T("OPRT_BIN "), - _T("OPRT_IFX "), - _T("OPRT_PFX "), - _T("END "), - _T("SCR_ENDL "), - _T("SCR_CMT "), - _T("SCR_WHILE "), - _T("SCR_GOTO "), - _T("SCR_LABEL "), - _T("SCR_FOR "), - _T("SCR_IF "), - _T("SCR_ELSE "), - _T("SCR_ELIF "), - _T("SCR_ENDIF "), - _T("SCR_FUNC "), - _T("UNKNOWN "), - nullptr }; - -//------------------------------------------------------------------------------ -bool ParserXBase::s_bDumpStack = false; -bool ParserXBase::s_bDumpRPN = false; - -//------------------------------------------------------------------------------ -/** \brief Identifiers for built in binary operators. - - When defining custom binary operators with AddOprt(...) make sure not to choose - names conflicting with these definitions. - */ -const char_type* ParserXBase::c_DefaultOprt[] = { - _T("("), - _T(")"), - _T("["), - _T("]"), - _T("{"), - _T("}"), - _T(","), - _T("?"), - _T(":"), - 0 }; - -//------------------------------------------------------------------------------ -/** \brief Default constructor. */ -ParserXBase::ParserXBase() - :m_FunDef() - , m_PostOprtDef() - , m_InfixOprtDef() - , m_OprtDef() - , m_valDef() - , m_varDef() - , m_pParserEngine(&ParserXBase::ParseFromString) - , m_pTokenReader() - , m_valDynVarShadow() - , m_sNameChars() - , m_sOprtChars() - , m_sInfixOprtChars() - , m_bIsQueryingExprVar(false) - , m_bAutoCreateVar(false) - , m_rpn() - , m_vStackBuffer() -{ - InitTokenReader(); -} - -//--------------------------------------------------------------------------- -/** \brief Copy constructor. - \param a_Parser Reference to the other parser object - - Implemented by calling Assign(a_Parser) - */ -ParserXBase::ParserXBase(const ParserXBase &a_Parser) - :m_FunDef() - , m_PostOprtDef() - , m_InfixOprtDef() - , m_OprtDef() - , m_valDef() - , m_varDef() - , m_pParserEngine(&ParserXBase::ParseFromString) - , m_pTokenReader() - , m_valDynVarShadow() - , m_sNameChars() - , m_sOprtChars() - , m_sInfixOprtChars() - , m_bAutoCreateVar() - , m_rpn() - , m_vStackBuffer() -{ - m_pTokenReader.reset(new TokenReader(this)); - Assign(a_Parser); -} - -//--------------------------------------------------------------------------- -/** \brief Destructor. - \throw nothrow - */ -ParserXBase::~ParserXBase() -{ - // It is important to release the stack buffer before - // releasing the value cache. Since it may contain - // Values referencing the cache. - m_vStackBuffer.clear(); - m_cache.ReleaseAll(); -} - -//--------------------------------------------------------------------------- -/** \brief Assignement operator. - \param a_Parser Object to copy to this. - \return *this - \throw nothrow - - Implemented by calling Assign(a_Parser). Self assignement is suppressed. - */ -ParserXBase& ParserXBase::operator=(const ParserXBase &a_Parser) -{ - Assign(a_Parser); - return *this; -} - -//--------------------------------------------------------------------------- -/** \brief Copy state of a parser object to this. - \param a_Parser the source object. - - Clears Variables and Functions of this parser. - Copies the states of all internal variables. - Resets parse function to string parse mode. - */ -void ParserXBase::Assign(const ParserXBase &ref) -{ - if (&ref == this) - return; - - // Don't copy bytecode instead cause the parser to create new bytecode - // by resetting the parse function. - ReInit(); - - m_pTokenReader.reset(ref.m_pTokenReader->Clone(this)); - - m_OprtDef = ref.m_OprtDef; - m_FunDef = ref.m_FunDef; - m_PostOprtDef = ref.m_PostOprtDef; - m_InfixOprtDef = ref.m_InfixOprtDef; - m_valDef = ref.m_valDef; - m_valDynVarShadow = ref.m_valDynVarShadow; - m_varDef = ref.m_varDef; // Copy user defined variables - - // Copy charsets - m_sNameChars = ref.m_sNameChars; - m_sOprtChars = ref.m_sOprtChars; - m_sInfixOprtChars = ref.m_sInfixOprtChars; - - m_bAutoCreateVar = ref.m_bAutoCreateVar; - - // Things that should not be copied: - // - m_vStackBuffer - // - m_cache - // - m_rpn -} - -//--------------------------------------------------------------------------- -/** \brief Evaluate the expression. - \pre A formula must be set. - \pre Variables must have been set (if needed) - \sa SetExpr - \return The evaluation result - \throw ParseException if no Formula is set or in case of any other error related to the formula. - - A note on const correctness: - I consider it important that Calc is a const function. - Due to caching operations Calc changes only the state of internal variables with one exception - m_UsedVar this is reset during string parsing and accessible from the outside. Instead of making - Calc non const GetExprVar is non const because it explicitely calls Eval() forcing this update. - */ -const IValue& ParserXBase::Eval() const -{ - return (this->*m_pParserEngine)(); -} - -//--------------------------------------------------------------------------- -/** \brief Return the strings of all Operator identifiers. - \return Returns a pointer to the c_DefaultOprt array of const char *. - \throw nothrow - - GetOprt is a const function returning a pinter to an array of const char pointers. - */ -const char_type** ParserXBase::GetOprtDef() const -{ - return (const char_type **)(&c_DefaultOprt[0]); -} - -//--------------------------------------------------------------------------- -/** \brief Define the set of valid characters to be used in names of - functions, variables, constants. - */ -void ParserXBase::DefineNameChars(const char_type *a_szCharset) -{ - m_sNameChars = a_szCharset; -} - -//--------------------------------------------------------------------------- -/** \brief Define the set of valid characters to be used in names of - binary operators and postfix operators. - \param a_szCharset A string containing all characters that can be used - in operator identifiers. - */ -void ParserXBase::DefineOprtChars(const char_type *a_szCharset) -{ - m_sOprtChars = a_szCharset; -} - -//--------------------------------------------------------------------------- -/** \brief Define the set of valid characters to be used in names of - infix operators. - \param a_szCharset A string containing all characters that can be used - in infix operator identifiers. - */ -void ParserXBase::DefineInfixOprtChars(const char_type *a_szCharset) -{ - m_sInfixOprtChars = a_szCharset; -} - -//--------------------------------------------------------------------------- -/** \brief Virtual function that defines the characters allowed in name identifiers. - \sa #ValidOprtChars, #ValidPrefixOprtChars - */ -const char_type* ParserXBase::ValidNameChars() const -{ - MUP_VERIFY(m_sNameChars.size()); - return m_sNameChars.c_str(); -} - -//--------------------------------------------------------------------------- -/** \brief Virtual function that defines the characters allowed in operator definitions. - \sa #ValidNameChars, #ValidPrefixOprtChars - */ -const char_type* ParserXBase::ValidOprtChars() const -{ - MUP_VERIFY(m_sOprtChars.size()); - return m_sOprtChars.c_str(); -} - -//--------------------------------------------------------------------------- -/** \brief Virtual function that defines the characters allowed in infix operator definitions. - \sa #ValidNameChars, #ValidOprtChars - */ -const char_type* ParserXBase::ValidInfixOprtChars() const -{ - MUP_VERIFY(m_sInfixOprtChars.size()); - return m_sInfixOprtChars.c_str(); -} - -//--------------------------------------------------------------------------- -/** \brief Initialize the token reader. - \post m_pTokenReader.Get()!=0 - \throw nothrow - - Create new token reader object and submit pointers to function, operator, - constant and variable definitions. - */ -void ParserXBase::InitTokenReader() -{ - m_pTokenReader.reset(new TokenReader(this)); -} - -//--------------------------------------------------------------------------- -/** \brief Reset parser to string parsing mode and clear internal buffers. - \throw nothrow - - Resets the token reader. - */ -void ParserXBase::ReInit() const -{ - m_pParserEngine = &ParserXBase::ParseFromString; - m_pTokenReader->ReInit(); - m_rpn.Reset(); - m_vStackBuffer.clear(); - m_nPos = 0; -} - -//--------------------------------------------------------------------------- -/** \brief Adds a new package to the parser. - - The parser becomes the owner of the package pointer and is responsible for - its deletion. - */ -void ParserXBase::AddPackage(IPackage *p) -{ - p->AddToParser(this); -} - -//--------------------------------------------------------------------------- -/** \brief Add a value reader object to muParserX. - \param a_pReader Pointer to the value reader object. - */ -void ParserXBase::AddValueReader(IValueReader *a_pReader) -{ - m_pTokenReader->AddValueReader(a_pReader); -} - -//--------------------------------------------------------------------------- -/** \brief Check if a given name contains invalid characters. - \param a_strName The name to check - \param a_szCharSet The characterset - \throw ParserException if the name contains invalid charakters. - */ -void ParserXBase::CheckName(const string_type &a_strName, - const string_type &a_szCharSet) const -{ - if (!a_strName.length() || - (a_strName.find_first_not_of(a_szCharSet) != string_type::npos) || - (a_strName[0] >= (char_type)'0' && a_strName[0] <= (char_type)'9')) - { - Error(ecINVALID_NAME); - } -} - -//--------------------------------------------------------------------------- -/** \brief Set the mathematical expression. - \param a_sExpr String with the expression - \throw ParserException in case of syntax errors. - - Triggers first time calculation thus the creation of the bytecode and - scanning of used variables. - */ -void ParserXBase::SetExpr(const string_type &a_sExpr) -{ - m_pTokenReader->SetExpr(a_sExpr); - ReInit(); -} - -//--------------------------------------------------------------------------- -/** \brief Add a user defined variable. - \param a_sName The variable name - \param a_Var The variable to be added to muParserX - */ -void ParserXBase::DefineVar(const string_type &ident, const Variable &var) -{ - CheckName(ident, ValidNameChars()); - - CheckForEntityExistence(ident, ecVARIABLE_DEFINED); - - m_varDef[ident] = ptr_tok_type(var.Clone()); -} - -void ParserXBase::CheckForEntityExistence(const string_type &ident, EErrorCodes error_code) -{ - if (IsVarDefined(ident) || - IsConstDefined(ident) || - IsFunDefined(ident) || - IsOprtDefined(ident) || - IsPostfixOprtDefined(ident) || - IsInfixOprtDefined(ident)) - throw ParserError(ErrorContext(error_code, 0, ident)); -} - -//--------------------------------------------------------------------------- -/** \brief Define a parser Constant. - \param a_sName The name of the constant - \param a_Val Const reference to the constants value - - Parser constants are handed over by const reference as opposed to variables - which are handed over by reference. Consequently the parser can not change - their value. - */ -void ParserXBase::DefineConst(const string_type &ident, const Value &val) -{ - CheckName(ident, ValidNameChars()); - - CheckForEntityExistence(ident, ecCONSTANT_DEFINED); - - m_valDef[ident] = ptr_tok_type(val.Clone()); -} - -//--------------------------------------------------------------------------- -/** \brief Add a callback object to the parser. - \param a_pFunc Pointer to the intance of a parser callback object - representing the function. - \sa GetFunDef, functions - - The parser takes ownership over the callback object. - */ -void ParserXBase::DefineFun(const ptr_cal_type &fun) -{ - if (IsFunDefined(fun->GetIdent())) - throw ParserError(ErrorContext(ecFUNOPRT_DEFINED, 0, fun->GetIdent())); - - fun->SetParent(this); - m_FunDef[fun->GetIdent()] = ptr_tok_type(fun->Clone()); -} - -//--------------------------------------------------------------------------- -/** \brief Define a binary operator. - \param a_pCallback Pointer to the callback object - */ -void ParserXBase::DefineOprt(const TokenPtr &oprt) -{ - if (IsOprtDefined(oprt->GetIdent())) - throw ParserError(ErrorContext(ecFUNOPRT_DEFINED, 0, oprt->GetIdent())); - - oprt->SetParent(this); - m_OprtDef[oprt->GetIdent()] = ptr_tok_type(oprt->Clone()); -} - -//--------------------------------------------------------------------------- -/** \brief Add a user defined operator. - \post Will reset the Parser to string parsing mode. - \param a_pOprt Pointer to a unary postfix operator object. The parser will - become the new owner of this object hence will destroy it. - */ -void ParserXBase::DefinePostfixOprt(const TokenPtr &oprt) -{ - if (IsPostfixOprtDefined(oprt->GetIdent())) - throw ParserError(ErrorContext(ecFUNOPRT_DEFINED, 0, oprt->GetIdent())); - - // Operator is not added yet, add it. - oprt->SetParent(this); - m_PostOprtDef[oprt->GetIdent()] = ptr_tok_type(oprt->Clone()); -} - -//--------------------------------------------------------------------------- -/** \brief Add a user defined operator. - \param a_pOprt Pointer to a unary postfix operator object. The parser will - become the new owner of this object hence will destroy it. -*/ -void ParserXBase::DefineInfixOprt(const TokenPtr &oprt) -{ - if (IsInfixOprtDefined(oprt->GetIdent())) - throw ParserError(ErrorContext(ecFUNOPRT_DEFINED, 0, oprt->GetIdent())); - - // Function is not added yet, add it. - oprt->SetParent(this); - m_InfixOprtDef[oprt->GetIdent()] = ptr_tok_type(oprt->Clone()); -} - -//--------------------------------------------------------------------------- -void ParserXBase::RemoveVar(const string_type &ident) -{ - m_varDef.erase(ident); - ReInit(); -} - -//--------------------------------------------------------------------------- -void ParserXBase::RemoveConst(const string_type &ident) -{ - m_valDef.erase(ident); - ReInit(); -} - -//--------------------------------------------------------------------------- -void ParserXBase::RemoveFun(const string_type &ident) -{ - m_FunDef.erase(ident); - ReInit(); -} - -//--------------------------------------------------------------------------- -void ParserXBase::RemoveOprt(const string_type &ident) -{ - m_OprtDef.erase(ident); - ReInit(); -} - -//--------------------------------------------------------------------------- -void ParserXBase::RemovePostfixOprt(const string_type &ident) -{ - m_PostOprtDef.erase(ident); - ReInit(); -} - -//--------------------------------------------------------------------------- -void ParserXBase::RemoveInfixOprt(const string_type &ident) -{ - m_InfixOprtDef.erase(ident); - ReInit(); -} - -//--------------------------------------------------------------------------- -bool ParserXBase::IsVarDefined(const string_type &ident) const -{ - return m_varDef.find(ident) != m_varDef.end(); -} - -//--------------------------------------------------------------------------- -bool ParserXBase::IsConstDefined(const string_type &ident) const -{ - return m_valDef.find(ident) != m_valDef.end(); -} - -//--------------------------------------------------------------------------- -bool ParserXBase::IsFunDefined(const string_type &ident) const -{ - return m_FunDef.find(ident) != m_FunDef.end(); -} - -//--------------------------------------------------------------------------- -bool ParserXBase::IsOprtDefined(const string_type &ident) const -{ - return m_OprtDef.find(ident) != m_OprtDef.end(); -} - -//--------------------------------------------------------------------------- -bool ParserXBase::IsPostfixOprtDefined(const string_type &ident) const -{ - return m_PostOprtDef.find(ident) != m_PostOprtDef.end(); -} - -//--------------------------------------------------------------------------- -bool ParserXBase::IsInfixOprtDefined(const string_type &ident) const -{ - return m_InfixOprtDef.find(ident) != m_InfixOprtDef.end(); -} - -//--------------------------------------------------------------------------- -/** \brief Return a map containing the used variables only. */ -const var_maptype& ParserXBase::GetExprVar() const -{ - utils::scoped_setter guard(m_bIsQueryingExprVar, true); - - // Create RPN, but do not compute the result or switch to RPN - // parsing mode. The expression may contain yet to be defined variables. - CreateRPN(); - return m_pTokenReader->GetUsedVar(); -} - -//--------------------------------------------------------------------------- -/** \brief Return a map containing the used variables only. */ -const var_maptype& ParserXBase::GetVar() const -{ - return m_varDef; -} - -//--------------------------------------------------------------------------- -/** \brief Return a map containing all parser constants. */ -const val_maptype& ParserXBase::GetConst() const -{ - return m_valDef; -} - -//--------------------------------------------------------------------------- -/** \brief Return prototypes of all parser functions. - \return #m_FunDef - \sa FunProt, functions - \throw nothrow - - The return type is a map of the public type #funmap_type containing the prototype - definitions for all numerical parser functions. String functions are not part of - this map. The Prototype definition is encapsulated in objects of the class FunProt - one per parser function each associated with function names via a map construct. - */ -const fun_maptype& ParserXBase::GetFunDef() const -{ - return m_FunDef; -} - -//--------------------------------------------------------------------------- -/** \brief Retrieve the mathematical expression. */ -const string_type& ParserXBase::GetExpr() const -{ - return m_pTokenReader->GetExpr(); -} - -//--------------------------------------------------------------------------- -/** \brief Get the version number of muParserX. - \return A string containing the version number of muParserX. - */ -string_type ParserXBase::GetVersion() -{ - return MUP_PARSER_VERSION; -} - -//--------------------------------------------------------------------------- -void ParserXBase::ApplyRemainingOprt(Stack &stOpt) const - -{ - while (stOpt.size() && - stOpt.top()->GetCode() != cmBO && - stOpt.top()->GetCode() != cmIO && - stOpt.top()->GetCode() != cmCBO && - stOpt.top()->GetCode() != cmIF) - { - ptr_tok_type &op = stOpt.top(); - switch (op->GetCode()) - { - case cmOPRT_INFIX: - case cmOPRT_BIN: ApplyFunc(stOpt, 2); break; - case cmELSE: ApplyIfElse(stOpt); break; - default: Error(ecINTERNAL_ERROR); - } // switch operator token type - } // While operator stack not empty -} - -//--------------------------------------------------------------------------- -/** \brief Simulates the call of a parser function with its corresponding arguments. - \param a_stOpt The operator stack - \param a_stVal The value stack - \param a_iArgCount The number of function arguments - */ -void ParserXBase::ApplyFunc(Stack &a_stOpt, - int a_iArgCount) const -{ - if (a_stOpt.empty()) - return; - - ptr_tok_type tok = a_stOpt.pop(); - ICallback *pFun = tok->AsICallback(); - - int iArgCount = (pFun->GetArgc() >= 0) ? pFun->GetArgc() : a_iArgCount; - pFun->SetNumArgsPresent(iArgCount); - - m_nPos -= (iArgCount - 1); - m_rpn.Add(tok); -} - -//--------------------------------------------------------------------------- -/** \brief Simulates the effect of the execution of an if-then-else block. -*/ -void ParserXBase::ApplyIfElse(Stack &a_stOpt) const -{ - while (a_stOpt.size() && a_stOpt.top()->GetCode() == cmELSE) - { - MUP_VERIFY(a_stOpt.size() > 0); - MUP_VERIFY(m_nPos >= 3); - MUP_VERIFY(a_stOpt.top()->GetCode() == cmELSE); - - ptr_tok_type opElse = a_stOpt.pop(); - ptr_tok_type opIf = a_stOpt.pop(); - MUP_VERIFY(opElse->GetCode() == cmELSE) - MUP_VERIFY(opIf->GetCode() == cmIF) - - // If then else hat 3 argumente und erzeugt einen rückgabewert (3-1=2) - m_nPos -= 2; - m_rpn.Add(ptr_tok_type(new TokenIfThenElse(cmENDIF))); - } -} - -//--------------------------------------------------------------------------- -void ParserXBase::DumpRPN() const -{ - m_rpn.AsciiDump(); -} - -//--------------------------------------------------------------------------- -void ParserXBase::CreateRPN() const -{ - if (!m_pTokenReader->GetExpr().length()) - Error(ecUNEXPECTED_EOF, 0); - - // The Stacks take the ownership over the tokens - Stack stOpt; - Stack stArgCount; - Stack stIdxCount; - ptr_tok_type pTok, pTokPrev; - Value val; - - ReInit(); - - for (;;) - { - pTokPrev = pTok; - pTok = m_pTokenReader->ReadNextToken(); - -#if defined(MUP_DUMP_TOKENS) - console() << pTok->AsciiDump() << endl; -#endif - - ECmdCode eCmd = pTok->GetCode(); - switch (eCmd) - { - case cmVAL: - m_nPos++; - m_rpn.Add(pTok); - break; - - case cmCBC: - case cmIC: - { - ECmdCode eStarter = (ECmdCode)(eCmd - 1); - MUP_VERIFY(eStarter == cmCBO || eStarter == cmIO); - - // The argument count for parameterless functions is zero - // by default an opening bracket sets parameter count to 1 - // in preparation of arguments to come. If the last token - // was an opening bracket we know better... - if (pTokPrev.Get() != nullptr && pTokPrev->GetCode() == eStarter) - --stArgCount.top(); - - ApplyRemainingOprt(stOpt); - - // if opt is "]" and opta is "[" the bracket content has been evaluated. - // Now check whether there is an index operator on the stack. - if (stOpt.size() && stOpt.top()->GetCode() == eStarter) - { - // - // Find out how many dimensions were used in the index operator. - // - int iArgc = stArgCount.pop(); - stOpt.pop(); // Take opening bracket from stack - - ICallback *pOprtIndex = pTok->AsICallback(); - MUP_VERIFY(pOprtIndex != nullptr); - - pOprtIndex->SetNumArgsPresent(iArgc); - m_rpn.Add(pOprtIndex); - - // If this is an index operator there must be something else in the register (the variable to index) - MUP_VERIFY(eCmd != cmIC || m_nPos >= (int)iArgc + 1); - - // Reduce the index into the value registers accordingly - m_nPos -= iArgc; - - if (eCmd == cmCBC) - { - ++m_nPos; - } - } // if opening index bracket is on top of operator stack - } - break; - - case cmBC: - { - // The argument count for parameterless functions is zero - // by default an opening bracket sets parameter count to 1 - // in preparation of arguments to come. If the last token - // was an opening bracket we know better... - if (pTokPrev.Get() != nullptr && pTokPrev->GetCode() == cmBO) - --stArgCount.top(); - - ApplyRemainingOprt(stOpt); - - // if opt is ")" and opta is "(" the bracket content has been evaluated. - // Now its time to check if there is either a function or a sign pending. - // - Neither the opening nor the closing bracket will be pushed back to - // the operator stack - // - Check if a function is standing in front of the opening bracket, - // if so evaluate it afterwards to apply an infix operator. - if (stOpt.size() && stOpt.top()->GetCode() == cmBO) - { - // - // Here is the stuff to evaluate a function token - // - int iArgc = stArgCount.pop(); - - stOpt.pop(); // Take opening bracket from stack - if (stOpt.empty()) - break; - - if ((stOpt.top()->GetCode() != cmFUNC) && (stOpt.top()->GetCode() != cmOPRT_INFIX)) - break; - - ICallback *pFun = stOpt.top()->AsICallback(); - - if (pFun->GetArgc() != -1 && iArgc > pFun->GetArgc()) - Error(ecTOO_MANY_PARAMS, pTok->GetExprPos(), pFun); - - if (iArgc < pFun->GetArgc()) - Error(ecTOO_FEW_PARAMS, pTok->GetExprPos(), pFun); - - // Apply function, if present - if (stOpt.size() && - stOpt.top()->GetCode() != cmOPRT_INFIX && - stOpt.top()->GetCode() != cmOPRT_BIN) - { - ApplyFunc(stOpt, iArgc); - } - } - } - break; - - case cmELSE: - ApplyRemainingOprt(stOpt); - m_rpn.Add(pTok); - stOpt.push(pTok); - break; - - case cmSCRIPT_NEWLINE: - ApplyRemainingOprt(stOpt); - m_rpn.AddNewline(pTok, m_nPos); - stOpt.clear(); - m_nPos = 0; - break; - - case cmARG_SEP: - if (stArgCount.empty()) - Error(ecUNEXPECTED_COMMA, m_pTokenReader->GetPos() - 1); - - ++stArgCount.top(); - - ApplyRemainingOprt(stOpt); - break; - - case cmEOE: - ApplyRemainingOprt(stOpt); - m_rpn.Finalize(); - break; - - case cmIF: - case cmOPRT_BIN: - { - while (stOpt.size() && - stOpt.top()->GetCode() != cmBO && - stOpt.top()->GetCode() != cmIO && - stOpt.top()->GetCode() != cmCBO && - stOpt.top()->GetCode() != cmELSE && - stOpt.top()->GetCode() != cmIF) - { - IToken *pOprt1 = stOpt.top().Get(); - IToken *pOprt2 = pTok.Get(); - MUP_VERIFY(pOprt1 != nullptr && pOprt2 != nullptr); - MUP_VERIFY(pOprt1->AsIPrecedence() && pOprt2->AsIPrecedence()); - - int nPrec1 = pOprt1->AsIPrecedence()->GetPri(), - nPrec2 = pOprt2->AsIPrecedence()->GetPri(); - - if (pOprt1->GetCode() == pOprt2->GetCode()) - { - // Deal with operator associativity - EOprtAsct eOprtAsct = pOprt1->AsIPrecedence()->GetAssociativity(); - if ((eOprtAsct == oaRIGHT && (nPrec1 <= nPrec2)) || - (eOprtAsct == oaLEFT && (nPrec1 < nPrec2))) - { - break; - } - } - else if (nPrec1 < nPrec2) - { - break; - } - - // apply the operator now - // (binary operators are identic to functions with two arguments) - ApplyFunc(stOpt, 2); - } // while ( ... ) - - if (pTok->GetCode() == cmIF) - m_rpn.Add(pTok); - - stOpt.push(pTok); - } - break; - - // - // Postfix Operators - // - case cmOPRT_POSTFIX: - MUP_VERIFY(m_nPos); - m_rpn.Add(pTok); - break; - - case cmCBO: - case cmIO: - case cmBO: - stOpt.push(pTok); - stArgCount.push(1); - break; - - // - // Functions - // - case cmOPRT_INFIX: - case cmFUNC: - { - ICallback *pFunc = pTok->AsICallback(); - MUP_VERIFY(pFunc != nullptr); - stOpt.push(pTok); - } - break; - - default: - Error(ecINTERNAL_ERROR); - } // switch Code - - if (ParserXBase::s_bDumpStack) - { - StackDump(stOpt); - } - - if (pTok->GetCode() == cmEOE) - break; - } // for (all tokens) - - if (ParserXBase::s_bDumpRPN) - { - m_rpn.AsciiDump(); - } - - if (m_nPos > 1) - { - Error(ecUNEXPECTED_COMMA, -1); - } -} - -//--------------------------------------------------------------------------- -/** \brief One of the two main parse functions. - \sa ParseCmdCode(), ParseValue() - - Parse expression from input string. Perform syntax checking and create bytecode. - After parsing the string and creating the bytecode the function pointer - #m_pParseFormula will be changed to the second parse routine the uses bytecode instead of string parsing. - */ -const IValue& ParserXBase::ParseFromString() const -{ - CreateRPN(); - - // Umsachalten auf RPN - m_vStackBuffer.assign(m_rpn.GetRequiredStackSize(), ptr_val_type()); - for (std::size_t i = 0; i < m_vStackBuffer.size(); ++i) - { - Value *pValue = new Value; - pValue->BindToCache(&m_cache); - m_vStackBuffer[i].Reset(pValue); - } - - m_pParserEngine = &ParserXBase::ParseFromRPN; - - return (this->*m_pParserEngine)(); -} - -//--------------------------------------------------------------------------- -const IValue& ParserXBase::ParseFromRPN() const -{ - ptr_val_type *pStack = &m_vStackBuffer[0]; - if (m_rpn.GetSize() == 0) - { - // Passiert bei leeren strings oder solchen, die nur Leerzeichen enthalten - ErrorContext err; - err.Expr = m_pTokenReader->GetExpr(); - err.Errc = ecUNEXPECTED_EOF; - err.Pos = 0; - throw ParserError(err); - } - - const ptr_tok_type *pRPN = &(m_rpn.GetData()[0]); - - int sidx = -1; - std::size_t lenRPN = m_rpn.GetSize(); - for (std::size_t i = 0; i < lenRPN; ++i) - { - IToken *pTok = pRPN[i].Get(); - ECmdCode eCode = pTok->GetCode(); - - switch (eCode) - { - case cmSCRIPT_NEWLINE: - sidx = -1; - continue; - - case cmVAL: - { - IValue *pVal = static_cast(pTok); - - sidx++; - MUP_VERIFY(sidx < (int)m_vStackBuffer.size()); - if (pVal->IsVariable()) - { - pStack[sidx].Reset(pVal); - } - else - { - ptr_val_type &val = pStack[sidx]; - if (val->IsVariable()) - val.Reset(m_cache.CreateFromCache()); - - *val = *(static_cast(pTok)); - } - } - continue; - /* - // Deal with: - // - Index operator: [,,,] - // - Array constrution operator: {,,,} - case cmCBC: - { - ICallback *pFun = static_cast(pTok); - int nArgs = pFun->GetArgsPresent(); - sidx -= nArgs - 1; - MUP_VERIFY(sidx >= 0); - - ptr_val_type &val = pStack[sidx]; // Pointer to the variable or value beeing indexed - if (val->IsVariable()) - { - ptr_val_type buf(m_cache.CreateFromCache()); - pFun->Eval(buf, &val, nArgs); - val = buf; - } - else - { - pFun->Eval(val, &val, nArgs); - } - } - continue; - */ - case cmIC: - { - ICallback *pIdxOprt = static_cast(pTok); - int nArgs = pIdxOprt->GetArgsPresent(); - sidx -= nArgs - 1; - MUP_VERIFY(sidx >= 0); - - ptr_val_type &idx = pStack[sidx]; // Pointer to the first index - ptr_val_type &val = pStack[--sidx]; // Pointer to the variable or value beeing indexed - pIdxOprt->Eval(val, &idx, nArgs); - } - continue; - - case cmCBC: - case cmOPRT_POSTFIX: - case cmFUNC: - case cmOPRT_BIN: - case cmOPRT_INFIX: - { - ICallback *pFun = static_cast(pTok); - int nArgs = pFun->GetArgsPresent(); - sidx -= nArgs - 1; - MUP_VERIFY(sidx >= 0); - - ptr_val_type &val = pStack[sidx]; - try - { - if (val->IsVariable()) - { - ptr_val_type buf(m_cache.CreateFromCache()); - pFun->Eval(buf, &val, nArgs); - val = buf; - } - else - { - pFun->Eval(val, &val, nArgs); - } - } - catch (ParserError &exc) - { - // Not too happy about that: - // Multiarg functions may throw specific error codes when evaluating. - // These codes would be converted to ecEVAL here. I omit the conversion - // for certain handpicked errors. (The reason this catch block exists is - // that not all exceptions contain proper metadata when thrown out of - // a function.) - if (exc.GetCode() == ecTOO_FEW_PARAMS || - exc.GetCode() == ecDOMAIN_ERROR || - exc.GetCode() == ecOVERFLOW || - exc.GetCode() == ecINVALID_NUMBER_OF_PARAMETERS || - exc.GetCode() == ecASSIGNEMENT_TO_VALUE) - { - exc.GetContext().Pos = pFun->GetExprPos(); - throw; - } - // - else - { - ErrorContext err; - err.Expr = m_pTokenReader->GetExpr(); - err.Ident = pFun->GetIdent(); - err.Errc = ecEVAL; - err.Pos = pFun->GetExprPos(); - err.Hint = exc.GetMsg(); - throw ParserError(err); - } - } - catch (MatrixError & /*exc*/) - { - ErrorContext err; - err.Expr = m_pTokenReader->GetExpr(); - err.Ident = pFun->GetIdent(); - err.Errc = ecMATRIX_DIMENSION_MISMATCH; - err.Pos = pFun->GetExprPos(); - throw ParserError(err); - } - } - continue; - - case cmIF: - MUP_VERIFY(sidx >= 0); - if (pStack[sidx--]->GetBool() == false) - i += static_cast(pTok)->GetOffset(); - continue; - - case cmELSE: - case cmJMP: - i += static_cast(pTok)->GetOffset(); - continue; - - case cmENDIF: - continue; - - default: - Error(ecINTERNAL_ERROR); - } // switch token - } // for all RPN tokens - - return *pStack[0]; -} - -//--------------------------------------------------------------------------- -void ParserXBase::Error(EErrorCodes a_iErrc, int a_iPos, const IToken *a_pTok) const -{ - ErrorContext err; - err.Errc = a_iErrc; - err.Pos = a_iPos; - err.Expr = m_pTokenReader->GetExpr(); - err.Ident = (a_pTok) ? a_pTok->GetIdent() : _T(""); - throw ParserError(err); -} - -//------------------------------------------------------------------------------ -/** \brief Clear all user defined variables. - \throw nothrow - - Resets the parser to string parsing mode by calling #ReInit. - */ -void ParserXBase::ClearVar() -{ - m_varDef.clear(); - m_valDynVarShadow.clear(); - ReInit(); -} - -//------------------------------------------------------------------------------ -/** \brief Clear the expression. - \throw nothrow - - Clear the expression and existing bytecode. - */ -void ParserXBase::ClearExpr() -{ - m_pTokenReader->SetExpr(_T("")); - ReInit(); -} - -//------------------------------------------------------------------------------ -/** \brief Clear all function definitions. - \throw nothrow - */ -void ParserXBase::ClearFun() -{ - m_FunDef.clear(); - ReInit(); -} - -//------------------------------------------------------------------------------ -/** \brief Clear all user defined constants. - \throw nothrow - - Both numeric and string constants will be removed from the internal storage. - */ -void ParserXBase::ClearConst() -{ - m_valDef.clear(); - ReInit(); -} - -//------------------------------------------------------------------------------ -/** \brief Clear all user defined postfix operators. - \throw nothrow - */ -void ParserXBase::ClearPostfixOprt() -{ - m_PostOprtDef.clear(); - ReInit(); -} - -//------------------------------------------------------------------------------ -/** \brief Clear all user defined binary operators. - \throw nothrow - */ -void ParserXBase::ClearOprt() -{ - m_OprtDef.clear(); - ReInit(); -} - -//------------------------------------------------------------------------------ -/** \brief Clear the user defined Prefix operators. - \throw nothrow - */ -void ParserXBase::ClearInfixOprt() -{ - m_InfixOprtDef.clear(); - ReInit(); -} - -//------------------------------------------------------------------------------ -void ParserXBase::EnableAutoCreateVar(bool bStat) -{ - m_bAutoCreateVar = bStat; -} - -//------------------------------------------------------------------------------ -void ParserXBase::EnableOptimizer(bool bStat) -{ - m_rpn.EnableOptimizer(bStat); -} - -//--------------------------------------------------------------------------- -/** \brief Enable the dumping of bytecode amd stack content on the console. - \param bDumpCmd Flag to enable dumping of the current bytecode to the console. - \param bDumpStack Flag to enable dumping of the stack content is written to the console. - - This function is for debug purposes only! - */ -void ParserXBase::EnableDebugDump(bool bDumpRPN, bool bDumpStack) -{ - ParserXBase::s_bDumpRPN = bDumpRPN; - ParserXBase::s_bDumpStack = bDumpStack; -} - -//------------------------------------------------------------------------------ -bool ParserXBase::IsAutoCreateVarEnabled() const -{ - return m_bAutoCreateVar; -} - -//------------------------------------------------------------------------------ -/** \brief Dump stack content. - - This function is used for debugging only. - */ -void ParserXBase::StackDump(const Stack &a_stOprt) const -{ - using std::cout; - Stack stOprt(a_stOprt); - - string_type sInfo = _T("StackDump> "); - console() << sInfo; - - if (stOprt.empty()) - console() << _T("\n") << sInfo << _T("Operator stack is empty.\n"); - else - console() << _T("\n") << sInfo << _T("Operator stack:\n"); - - while (!stOprt.empty()) - { - ptr_tok_type tok = stOprt.pop(); - console() << sInfo << _T(" ") << g_sCmdCode[tok->GetCode()] << _T(" \"") << tok->GetIdent() << _T("\" \n"); - } - - console() << endl; -} -} // namespace mu diff --git a/src/third-party/headers/muparserx/mpParserMessageProvider.cpp b/src/third-party/headers/muparserx/mpParserMessageProvider.cpp deleted file mode 100644 index dbd442743a..0000000000 --- a/src/third-party/headers/muparserx/mpParserMessageProvider.cpp +++ /dev/null @@ -1,181 +0,0 @@ -#include "mpParserMessageProvider.h" -#include -#include "mpError.h" - - -MUP_NAMESPACE_START - - //------------------------------------------------------------------------------------------------- - // - // class ParserMessageProviderBase - Base class for message providers - // - //------------------------------------------------------------------------------------------------- - - ParserMessageProviderBase::ParserMessageProviderBase() - :m_vErrMsg(0) - {} - - //----------------------------------------------------------------------------------------------- - ParserMessageProviderBase::~ParserMessageProviderBase() - {} - - //----------------------------------------------------------------------------------------------- - void ParserMessageProviderBase::Init() - { - InitErrorMessages(); - for (int i=0; i\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ - -#include -#include - -#include "mpRPN.h" -#include "mpIToken.h" -#include "mpICallback.h" -#include "mpError.h" -#include "mpStack.h" -#include "mpIfThenElse.h" -#include "mpScriptTokens.h" - -MUP_NAMESPACE_START - -//--------------------------------------------------------------------------- -RPN::RPN() - :m_vRPN() - , m_nStackPos(-1) - , m_nLine(0) - , m_nMaxStackPos(0) - , m_bEnableOptimizer(false) -{} - -//--------------------------------------------------------------------------- -RPN::~RPN() -{} - -//--------------------------------------------------------------------------- -void RPN::Add(ptr_tok_type tok) -{ - m_vRPN.push_back(tok); - if (tok->AsIValue() != nullptr) - { - m_nStackPos++; - } - else if (tok->AsICallback()) - { - ICallback *pFun = tok->AsICallback(); - MUP_VERIFY(pFun != nullptr); - m_nStackPos -= pFun->GetArgsPresent() - 1; - } - - MUP_VERIFY(m_nStackPos >= 0); - m_nMaxStackPos = std::max(m_nStackPos, m_nMaxStackPos); -} - -//--------------------------------------------------------------------------- -void RPN::AddNewline(ptr_tok_type tok, int n) -{ - static_cast(tok.Get())->SetStackOffset(n); - m_vRPN.push_back(tok); - m_nStackPos -= n; - m_nLine++; -} - -//--------------------------------------------------------------------------- -void RPN::Pop(int num) -{ - if (m_vRPN.size() == 0) - return; - - for (int i = 0; i < num; ++i) - { - ptr_tok_type tok = m_vRPN.back(); - - if (tok->AsIValue() != 0) - m_nStackPos--; - - m_vRPN.pop_back(); - } -} - -//--------------------------------------------------------------------------- -void RPN::Reset() -{ - m_vRPN.clear(); - m_nStackPos = -1; - m_nMaxStackPos = 0; - m_nLine = 0; -} - -//--------------------------------------------------------------------------- -/** \brief - - At the moment this will only ass the jump distances to the if-else clauses - found in the expression. -*/ -void RPN::Finalize() -{ - // Determine the if-then-else jump offsets - Stack stIf, stElse; - int idx; - for (int i = 0; i < static_cast(m_vRPN.size()); ++i) - { - switch (m_vRPN[i]->GetCode()) - { - case cmIF: - stIf.push(i); - break; - - case cmELSE: - stElse.push(i); - idx = stIf.pop(); - static_cast(m_vRPN[idx].Get())->SetOffset(i - idx); - break; - - case cmENDIF: - idx = stElse.pop(); - static_cast(m_vRPN[idx].Get())->SetOffset(i - idx); - break; - - default: - continue; - } - } -} - -//--------------------------------------------------------------------------- -void RPN::EnableOptimizer(bool bStat) -{ - m_bEnableOptimizer = bStat; -} - -//--------------------------------------------------------------------------- -std::size_t RPN::GetSize() const -{ - return m_vRPN.size(); -} - -//--------------------------------------------------------------------------- -const token_vec_type& RPN::GetData() const -{ - return m_vRPN; -} - -//--------------------------------------------------------------------------- -int RPN::GetRequiredStackSize() const -{ - return m_nMaxStackPos + 1; -} - -//--------------------------------------------------------------------------- -void RPN::AsciiDump() const -{ - console() << "Number of tokens: " << m_vRPN.size() << "\n"; - console() << "MaxStackPos: " << m_nMaxStackPos << "\n"; - for (std::size_t i = 0; i < m_vRPN.size(); ++i) - { - ptr_tok_type pTok = m_vRPN[i]; - console() << std::setw(2) << i << " : " - << std::setw(2) << pTok->GetExprPos() << " : " - << pTok->AsciiDump() << std::endl; - } -} - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpScriptTokens.cpp b/src/third-party/headers/muparserx/mpScriptTokens.cpp deleted file mode 100644 index d044032614..0000000000 --- a/src/third-party/headers/muparserx/mpScriptTokens.cpp +++ /dev/null @@ -1,74 +0,0 @@ -/* - __________ ____ ___ - _____ __ _\______ \_____ _______ ______ __________\ \/ / - / \| | \ ___/\__ \\_ __ \/ ___// __ \_ __ \ / - | Y Y \ | / | / __ \| | \/\___ \\ ___/| | \/ \ - |__|_| /____/|____| (____ /__| /____ >\___ >__| /___/\ \ - \/ \/ \/ \/ \_/ - Copyright (C) 2016, Ingo Berg - All rights reserved. - - Redistribution and use in source and binary forms, with or without - modification, are permitted provided that the following conditions are met: - - * Redistributions of source code must retain the above copyright notice, - this list of conditions and the following disclaimer. - * Redistributions in binary form must reproduce the above copyright notice, - this list of conditions and the following disclaimer in the documentation - and/or other materials provided with the distribution. - - THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND - ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED - WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. - IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, - INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT - NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR - PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, - WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) - ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE - POSSIBILITY OF SUCH DAMAGE. -*/ -#include "mpScriptTokens.h" -#include "mpTypes.h" - - -MUP_NAMESPACE_START - - //--------------------------------------------------------------------------- - TokenNewline::TokenNewline() - :IToken(cmSCRIPT_NEWLINE) - ,m_nOffset(0) - {} - - //--------------------------------------------------------------------------- - IToken* TokenNewline::Clone() const - { - return new TokenNewline(*this); - } - - //--------------------------------------------------------------------------- - void TokenNewline::SetStackOffset(int nOffset) - { - m_nOffset = nOffset; - } - - //--------------------------------------------------------------------------- - int TokenNewline::GetStackOffset() const - { - return m_nOffset; - } - - //--------------------------------------------------------------------------- - string_type TokenNewline::AsciiDump() const - { - stringstream_type ss; - - ss << g_sCmdCode[ GetCode() ]; - ss << _T(" [addr=0x") << std::hex << this << std::dec; - ss << _T("; pos=") << GetExprPos(); - ss << _T("; offset=") << m_nOffset; - ss << _T("]"); - return ss.str(); - } - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpTest.cpp b/src/third-party/headers/muparserx/mpTest.cpp deleted file mode 100644 index 7055c592d5..0000000000 --- a/src/third-party/headers/muparserx/mpTest.cpp +++ /dev/null @@ -1,1809 +0,0 @@ -/** \file - \brief Implementation of the unit test for muParserX. - -
          -				  __________                                 ____  ___
          -	  _____  __  _\______   \_____ _______  ______ __________\   \/  /
          -	 /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
          -	|  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
          -	|__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -		  \/                     \/           \/     \/           \_/
          -	Copyright (C) 2016 Ingo Berg
          -	All rights reserved.
          -
          -	muParserX - A C++ math parser library with array and string support
          -	Copyright (c) 2016, Ingo Berg
          -	All rights reserved.
          -
          -	Redistribution and use in source and binary forms, with or without
          -	modification, are permitted provided that the following conditions are met:
          -
          -	* Redistributions of source code must retain the above copyright notice,
          -	this list of conditions and the following disclaimer.
          -	* Redistributions in binary form must reproduce the above copyright notice,
          -	this list of conditions and the following disclaimer in the documentation
          -	and/or other materials provided with the distribution.
          -
          -	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
          -	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
          -	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
          -	IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
          -	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
          -	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
          -	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
          -	WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
          -	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
          -	POSSIBILITY OF SUCH DAMAGE.
          -	
          - */ -#include "mpTest.h" -#include "mpValue.h" - -#include -#include -#include -#include -#include -#include - -#define MUP_CONST_PI 3.141592653589793238462643 -#define MUP_CONST_E 2.718281828459045235360287 - -using namespace std; - -MUP_NAMESPACE_START - -//----------------------------------------------------------------------------------------------- -// -// class OprtStrAdd -// -//----------------------------------------------------------------------------------------------- - -class DbgSillyAdd : public IOprtBin -{ -public: - - DbgSillyAdd() - :IOprtBin(_T("++"), (int)prADD_SUB, oaLEFT) - {} - - //----------------------------------------------------------------------------------------------- - void Eval(ptr_val_type& ret, const ptr_val_type *arg, int argc) - { - assert(argc == 2); - float_type a = arg[0]->GetFloat(); - float_type b = arg[1]->GetFloat(); - *ret = a + b; - } - - //----------------------------------------------------------------------------------------------- - const char_type* GetDesc() const - { - return _T("internally used operator without special meaning for unit testing"); - } - - //----------------------------------------------------------------------------------------------- - IToken* Clone() const - { - return new DbgSillyAdd(*this); - } -}; - -//------------------------------------------------------------------------------ -class FunTest0 : public ICallback -{ -public: - FunTest0() : ICallback(cmFUNC, _T("test0"), 0) - {} - - virtual void Eval(ptr_val_type &ret, const ptr_val_type * /*a_pArg*/, int /*a_iArgc*/) - { - *ret = 0.0; - } - - virtual const char_type* GetDesc() const - { - return _T(""); - } - - virtual IToken* Clone() const - { - return new FunTest0(*this); - } -}; // class FunTest0 - -//--------------------------------------------------------------------------- -int ParserTester::c_iCount = 0; - -//--------------------------------------------------------------------------- -ParserTester::ParserTester() - :m_vTestFun() - , m_stream(&console()) -{ - AddTest(&ParserTester::TestParserValue); - AddTest(&ParserTester::TestUndefVar); - AddTest(&ParserTester::TestErrorCodes); - AddTest(&ParserTester::TestEqn); - AddTest(&ParserTester::TestIfElse); - AddTest(&ParserTester::TestStringFun); - AddTest(&ParserTester::TestMatrix); - AddTest(&ParserTester::TestComplex); - AddTest(&ParserTester::TestVector); - AddTest(&ParserTester::TestBinOp); - AddTest(&ParserTester::TestPostfix); - AddTest(&ParserTester::TestInfix); - AddTest(&ParserTester::TestMultiArg); - AddTest(&ParserTester::TestScript); - AddTest(&ParserTester::TestValReader); - AddTest(&ParserTester::TestIssueReports); - - ParserTester::c_iCount = 0; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestIssueReports() -{ - int iNumErr = 0; - *m_stream << _T("testing github issue reports..."); - - // Github: Issue 55 - iNumErr += ThrowTest(_T("{0,{0}}*{0,{0}}*{,{0}}*{0,{0}0,{0}}*{0,{0}}*{,{0}}*{0}*{000}"), ecUNEXPECTED_COMMA); - - // Github: Issue 56 - iNumErr += ThrowTest(_T("0M[,1][0/1M[0M]M]"), ecUNEXPECTED_COMMA); - - // Github Issue 57: - iNumErr += ThrowTest(_T("{?{{{{:44"), ecUNEXPECTED_CONDITIONAL); - - // Github Issue 60 - iNumErr += ThrowTest(_T("0<01?1=:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1<:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1>:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1-:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1+:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1*:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1/:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1&:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1<<:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("0<01?1>>:1"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("{ ? 0 : 7m}-{7, -00007m}-{7M}"), ecUNEXPECTED_CONDITIONAL); - iNumErr += ThrowTest(_T("{ { { ? 2 }, 7:2 }*7m }"), ecUNEXPECTED_CONDITIONAL); - - // Not too happy about the undefined code, but better than a crash of an assertion at runtime - iNumErr += ThrowTest(_T("{0<0?0,0:0<0}"), ecUNDEFINED); - - // Github Issue 63 - iNumErr += ThrowTest(_T("0<0-0--eye()"), ecINVALID_NUMBER_OF_PARAMETERS); - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestUndefVar() -{ - int iNumErr = 0; - *m_stream << _T("testing implicit definition of undefined variables..."); - - // Test 1: No variables defined, test detection of undefined variables - { - ParserX p; - p.SetExpr(_T("a+b+c+d")); - const mup::var_maptype &expr_var = p.GetExprVar(); - const mup::var_maptype &var = p.GetVar(); - - // The expression contains 4 undefined variables - if (expr_var.size() != 4) - iNumErr++; - - // There are no variables defined - if (var.size() != 0) - iNumErr++; - } - - // Test 2: Variables were defined explicitely, test detection of variables - { - ParserX p; - - // Now define the variables and perform the check again - Value vVarVal[] = { 1.0, 2.0, 3.0, 4.0 }; - p.DefineVar(_T("a"), Variable(&vVarVal[0])); - p.DefineVar(_T("b"), Variable(&vVarVal[1])); - p.DefineVar(_T("c"), Variable(&vVarVal[2])); - p.DefineVar(_T("d"), Variable(&vVarVal[3])); - - p.SetExpr(_T("a+b+c+d")); - const mup::var_maptype &expr_var = p.GetExprVar(); - const mup::var_maptype &var = p.GetVar(); - - // The expression contains 4 undefined variables - if (expr_var.size() != 4) - iNumErr++; - - // There are no variables defined - if (var.size() != 4) - iNumErr++; - } - - // Test 3: Variables were defined implicitels, test detection of undefined variables - { - ParserX p; - - // Now define the variables and perform the check again - p.EnableAutoCreateVar(true); - - p.SetExpr(_T("a+b+c+d")); - const mup::var_maptype &expr_var = p.GetExprVar(); - const mup::var_maptype &var = p.GetVar(); - - // The expression contains 4 undefined variables - if (expr_var.size() != 4) - iNumErr++; - - // There are no variables defined - if (var.size() != 4) - iNumErr++; - } - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestMatrix() -{ - int iNumErr = 0; - *m_stream << _T("testing matrix calculations..."); - - Value unity(3, 3, 0); - unity.At(0, 0) = 1.0; - unity.At(1, 1) = 1.0; - unity.At(2, 2) = 1.0; - - Value va(3, 0); - va.At(0) = 1.0; - va.At(1) = 2.0; - va.At(2) = 3.0; - - //Value m2(3, 3, 0); - //m2.At(0, 0) = 1; m2.At(0, 1) = 2; m2.At(0, 2) = 3; - //m2.At(1, 0) = 4; m2.At(1, 1) = 5; m2.At(1, 2) = 6; - //m2.At(2, 0) = 7; m2.At(2, 1) = 8; m2.At(2, 2) = 9; - - Value m1_plus_m2(3, 3, 0); - m1_plus_m2.At(0, 0) = 2.0; m1_plus_m2.At(0, 1) = 2.0; m1_plus_m2.At(0, 2) = 3.0; - m1_plus_m2.At(1, 0) = 4.0; m1_plus_m2.At(1, 1) = 6.0; m1_plus_m2.At(1, 2) = 6.0; - m1_plus_m2.At(2, 0) = 7.0; m1_plus_m2.At(2, 1) = 8.0; m1_plus_m2.At(2, 2) = 10.0; - - Value m2_minus_m1(3, 3, 0); - m2_minus_m1.At(0, 0) = 0.0; m2_minus_m1.At(0, 1) = 2.0; m2_minus_m1.At(0, 2) = 3.0; - m2_minus_m1.At(1, 0) = 4.0; m2_minus_m1.At(1, 1) = 4.0; m2_minus_m1.At(1, 2) = 6.0; - m2_minus_m1.At(2, 0) = 7.0; m2_minus_m1.At(2, 1) = 8.0; m2_minus_m1.At(2, 2) = 8.0; - - Value m2_times_10(3, 3, 0); - m2_times_10.At(0, 0) = 10.0; m2_times_10.At(0, 1) = 20.0; m2_times_10.At(0, 2) = 30.0; - m2_times_10.At(1, 0) = 40.0; m2_times_10.At(1, 1) = 50.0; m2_times_10.At(1, 2) = 60.0; - m2_times_10.At(2, 0) = 70.0; m2_times_10.At(2, 1) = 80.0; m2_times_10.At(2, 2) = 90.0; - - Value va_times_vb_transp(3, 3, 0); - va_times_vb_transp.At(0, 0) = 4.0; va_times_vb_transp.At(0, 1) = 3.0; va_times_vb_transp.At(0, 2) = 2.0; - va_times_vb_transp.At(1, 0) = 8.0; va_times_vb_transp.At(1, 1) = 6.0; va_times_vb_transp.At(1, 2) = 4.0; - va_times_vb_transp.At(2, 0) = 12.0; va_times_vb_transp.At(2, 1) = 9.0; va_times_vb_transp.At(2, 2) = 6.0; - - Value size_3x6(1, 2, 0); - size_3x6.At(0, 0) = 3.0; - size_3x6.At(0, 1) = 6.0; - - Value size_3x3(1, 2, 0); - size_3x3.At(0, 0) = 3.0; - size_3x3.At(0, 1) = 3.0; - - Value size_3x1(1, 2, 0); - size_3x1.At(0, 0) = 3.0; - size_3x1.At(0, 1) = 1.0; - - Value size_1x3(1, 2, 0); - size_1x3.At(0, 0) = 1.0; - size_1x3.At(0, 1) = 3.0; - - // Check matrix dimension mismatch error - iNumErr += ThrowTest(_T("\"hallo\"+m1"), ecEVAL); - iNumErr += ThrowTest(_T("m1+\"hallo\""), ecEVAL); - iNumErr += ThrowTest(_T("va+m1"), ecMATRIX_DIMENSION_MISMATCH); - iNumErr += ThrowTest(_T("m1+va"), ecMATRIX_DIMENSION_MISMATCH); - iNumErr += ThrowTest(_T("va-m1"), ecMATRIX_DIMENSION_MISMATCH); - iNumErr += ThrowTest(_T("m1-va"), ecMATRIX_DIMENSION_MISMATCH); - iNumErr += ThrowTest(_T("va*m1"), ecMATRIX_DIMENSION_MISMATCH); - iNumErr += ThrowTest(_T("va+eye(2)"), ecMATRIX_DIMENSION_MISMATCH); - - // Issue 63: - iNumErr += ThrowTest(_T("0-0-eye()"), ecINVALID_NUMBER_OF_PARAMETERS); - - iNumErr += ThrowTest(_T("m1[1]"), ecINDEX_DIMENSION); - iNumErr += ThrowTest(_T("m1[1,2,3]"), ecINDEX_DIMENSION); - iNumErr += ThrowTest(_T("va[1,2]"), ecINDEX_OUT_OF_BOUNDS); // va has 1 column, 3 rows -> the coulumn index is referencing the third column - iNumErr += ThrowTest(_T("a+m1"), ecEVAL); - iNumErr += ThrowTest(_T("m1+a"), ecEVAL); - iNumErr += ThrowTest(_T("a-m1"), ecEVAL); - iNumErr += ThrowTest(_T("m1-a"), ecEVAL); - iNumErr += ThrowTest(_T("va[,1]"), ecUNEXPECTED_COMMA); - iNumErr += ThrowTest(_T("va[{1]"), ecMISSING_CURLY_BRACKET); - iNumErr += ThrowTest(_T("{,1}"), ecUNEXPECTED_COMMA); - - // sample expressions - iNumErr += EqnTest(_T("m1"), unity, true); - iNumErr += EqnTest(_T("m1*m1"), unity, true); - iNumErr += EqnTest(_T("m1+m2"), m1_plus_m2, true); - iNumErr += EqnTest(_T("m2-m1"), m2_minus_m1, true); - iNumErr += EqnTest(_T("10*m2"), m2_times_10, true); - iNumErr += EqnTest(_T("m2*10"), m2_times_10, true); - iNumErr += EqnTest(_T("5*m2*b"), m2_times_10, true); - iNumErr += EqnTest(_T("b*m2*5"), m2_times_10, true); - iNumErr += EqnTest(_T("m1*va"), va, true); - - // ones - Value ones_3(3, 1.0); - Value ones_3x3(3, 3, 1.0); - iNumErr += ThrowTest(_T("ones(1,2,3)"), ecINVALID_NUMBER_OF_PARAMETERS); - iNumErr += ThrowTest(_T("ones()"), ecINVALID_NUMBER_OF_PARAMETERS); - iNumErr += EqnTest(_T("ones(1,1)"), 1.0, true); - iNumErr += EqnTest(_T("ones(1)"), 1.0, true); - iNumErr += EqnTest(_T("ones(3,3)"), ones_3x3, true); - iNumErr += EqnTest(_T("ones(3,1)"), ones_3, true); - iNumErr += EqnTest(_T("ones(3)"), ones_3, true); - - iNumErr += EqnTest(_T("size(ones(3,3))"), size_3x3, true); // check return value dimension - iNumErr += EqnTest(_T("size(ones(1,3))"), size_1x3, true); // check return value dimension - iNumErr += EqnTest(_T("size(ones(3,1))"), size_3x1, true); // check return value dimension - iNumErr += EqnTest(_T("size(ones(3))"), size_3x3, true); // check return value dimension - - // zeros - iNumErr += ThrowTest(_T("zeros()"), ecINVALID_NUMBER_OF_PARAMETERS); - iNumErr += EqnTest(_T("size(zeros(3,3))"), size_3x3, true); // check return value dimension - iNumErr += EqnTest(_T("size(zeros(1,3))"), size_1x3, true); // check return value dimension - iNumErr += EqnTest(_T("size(zeros(3,1))"), size_3x1, true); // check return value dimension - iNumErr += EqnTest(_T("size(zeros(3))"), size_3x3, true); // check return value dimension - - // eye - iNumErr += ThrowTest(_T("eye()"), ecINVALID_NUMBER_OF_PARAMETERS); - iNumErr += EqnTest(_T("size(eye(3,3))"), size_3x3, true); // check return value dimension - iNumErr += EqnTest(_T("size(eye(1,3))"), size_1x3, true); // check return value dimension - iNumErr += EqnTest(_T("size(eye(3,1))"), size_3x1, true); // check return value dimension - iNumErr += EqnTest(_T("size(eye(3))"), size_3x3, true); // check return value dimension - - iNumErr += EqnTest(_T("size(eye(3,6))"), size_3x6, true); // check return value dimension - - // transposition - iNumErr += EqnTest(_T("va'*vb"), 16.0, true); - iNumErr += EqnTest(_T("2*va'*vb"), 32.0, true); - iNumErr += EqnTest(_T("va*vb'"), va_times_vb_transp, true); - - // index operator - // erster index: Zeilenindex, zweiter index: Spaltenindex - iNumErr += EqnTest(_T("va[0]"), 1.0, true); - iNumErr += EqnTest(_T("va[1]"), 2.0, true); - iNumErr += EqnTest(_T("va[2]"), 3.0, true); - // Use two dimensional index operator on a vector - iNumErr += EqnTest(_T("va[0,0]"), 1.0, true); - iNumErr += EqnTest(_T("va[1,0]"), 2.0, true); - iNumErr += EqnTest(_T("va[2,0]"), 3.0, true); - - // Now test the same with a transposed vector: - iNumErr += EqnTest(_T("va'[0]"), 1.0, true); - iNumErr += EqnTest(_T("va'[1]"), 2.0, true); - iNumErr += EqnTest(_T("va'[2]"), 3.0, true); - // Use two dimensional index operator on a vector - iNumErr += EqnTest(_T("va'[0,0]"), 1.0, true); - iNumErr += EqnTest(_T("va'[0,1]"), 2.0, true); - iNumErr += EqnTest(_T("va'[0,2]"), 3.0, true); - iNumErr += EqnTest(_T("(va')[0,2]"), 3.0, true); // <- Index operator after closing bracket is ok - - // vector creation - iNumErr += EqnTest(_T("{1,2,3}'"), va, true); - iNumErr += EqnTest(_T("{a,2,3}'"), va, true); // that was an actual bug: variable a was overwritten - - // assignment to element: - iNumErr += ThrowTest(_T("va'[0]=123"), ecASSIGNEMENT_TO_VALUE); - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestComplex() -{ - int iNumErr = 0; - *m_stream << _T("testing complex calculations..."); - - // complex numbers - // ca=1+i, cb=2+3i, cc=3+4i - iNumErr += EqnTest(_T("ca==1+i"), true, true); - iNumErr += EqnTest(_T("ca==ca"), true, true); - iNumErr += EqnTest(_T("ca!=1+i"), false, true); - iNumErr += EqnTest(_T("ca!=ca"), false, true); - iNumErr += EqnTest(_T("ca!=cb"), true, true); - iNumErr += EqnTest(_T("ca!=va"), true, true); - iNumErr += EqnTest(_T("ca==va"), false, true); - - // When comparing complex number Matlab/Octave compare only the real part - // I'll do the same... - iNumErr += EqnTest(_T("ca<10+i"), true, true); - iNumErr += EqnTest(_T("ca>10+i"), false, true); - iNumErr += EqnTest(_T("ca<=10+i"), true, true); - iNumErr += EqnTest(_T("ca>=10+i"), false, true); - iNumErr += EqnTest(_T("ca<=1"), true, true); - iNumErr += EqnTest(_T("ca>=1"), true, true); - - // complex numbers - iNumErr += EqnTest(_T("i*i"), -1.0, true, 0); - iNumErr += EqnTest(_T("1i"), cmplx_type(0, 1), true, 0); - iNumErr += EqnTest(_T("norm(3+4i)"), 25.0, true, 0); - iNumErr += EqnTest(_T("norm(4i+3)"), 25.0, true, 0); - iNumErr += EqnTest(_T("norm(3i+4)"), 25.0, true, 0); - iNumErr += EqnTest(_T("real(4.1i+3.1)"), (float_type)3.1, true, 0); - iNumErr += EqnTest(_T("imag(3.1i+4.1)"), (float_type)3.1, true, 0); - iNumErr += EqnTest(_T("real(3.1)"), (float_type)3.1, true, 0); - iNumErr += EqnTest(_T("imag(2.1i)"), (float_type)2.1, true, 0); - iNumErr += EqnTest(_T("-(4i+5)"), cmplx_type(-5, -4), true, 0); - iNumErr += EqnTest(_T("sqrt(-1)"), cmplx_type(0, 1), true, 0); - iNumErr += EqnTest(_T("(-1)^0.5"), cmplx_type(0, 1), true, 0); - iNumErr += EqnTest(_T("(-3)^(4/3)"), std::pow(cmplx_type(-3, 0), - cmplx_type(4.0 / 3, 0)), true, 0); - - // Issue 41: Complex pow of small numbers zeros out the imaginary part - // https://code.google.com/p/muparserx/issues/detail?id=41 - iNumErr += EqnTest(_T("(1e-15 + 1e-15*i) ^ 2"), std::pow(cmplx_type(1e-15, 1e-15), 2), true, 0); - - iNumErr += EqnTest(_T("sqrt(i*i)"), cmplx_type(0, 1), true, 0); - iNumErr += EqnTest(_T("sqrt(f)"), cmplx_type(0, 1), true, 1); - iNumErr += EqnTest(_T("sqrt(2-3)"), cmplx_type(0, 1), true, 0); - iNumErr += EqnTest(_T("sqrt(a-b)"), cmplx_type(0, 1), true, 2); - iNumErr += EqnTest(_T("sqrt((2-3))"), cmplx_type(0, 1), true, 0); - iNumErr += EqnTest(_T("sqrt((a-b))"), cmplx_type(0, 1), true, 2); - iNumErr += EqnTest(_T("sqrt(-(1))"), cmplx_type(0, 1), true, 0); - iNumErr += EqnTest(_T("sqrt((-1))"), cmplx_type(0, 1), true, 0); - iNumErr += EqnTest(_T("sqrt(-(-1))"), cmplx_type(1, 0), true, 0); - iNumErr += EqnTest(_T("sqrt(1)"), cmplx_type(1, 0), true, 0); - iNumErr += EqnTest(_T("a=1+2i"), cmplx_type(1, 2), true, 1); - iNumErr += EqnTest(_T("-(1+2i)"), cmplx_type(-1, -2), true, 0); - iNumErr += EqnTest(_T("-(-1-2i)"), cmplx_type(1, 2), true, 0); - iNumErr += EqnTest(_T("a*i"), cmplx_type(0, 1), true, 1); - iNumErr += EqnTest(_T("-(a+b*i)"), cmplx_type(-1, -2), true, 2); - iNumErr += EqnTest(_T("-(-a-b*i)"), cmplx_type(1, 2), true, 2); - iNumErr += EqnTest(_T("(2+4i)*(8-6i)"), cmplx_type(40, 20), true, 0); - - // Issue 17: Wrong result on complex power. - iNumErr += EqnTest(_T("(-0.27 + 0.66*i)^2"), cmplx_type(-0.3627, -0.3564), true, 0); - iNumErr += EqnTest(_T("(-1+5i)^2"), cmplx_type(-24, -10), true, 0); - - iNumErr += EqnTest(_T("c=(a=1+2i)"), cmplx_type(1, 2), true, 2); - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestParserValue() -{ - int iNumErr = 0; - *m_stream << _T("testing parser value types..."); - - // Define values and variables for each type - Value bVal = true; - Value fVal = (float_type)3.14; - Value sVal = string_type(_T("hello world")); - Value sVal1 = _T("hello world"); // Test assignment from const char* to string - Value cVal = cmplx_type(1, 1); - Value aVal(2, 0); - aVal.At(0) = (float_type)2.0; - aVal.At(1) = (float_type)3.0; - - // Create a 3x3 matrix - Value matrix(3, 0); - matrix.At(0) = Value(3, 0); - matrix.At(1) = Value(3, 0); - matrix.At(2) = Value(3, 0); - - Variable bVar(&bVal), - fVar(&fVal), - sVar(&sVal), - sVar1(&sVal1), - cVar(&cVal), - aVar(&aVal); - - // Check the value types - try - { - // Test if matrix values do work - if (!matrix.IsMatrix() || matrix.GetRows() != 3) - iNumErr++; - - std::size_t sz = matrix.GetRows(); - for (std::size_t i = 0; i < sz; ++i) - { - std::size_t dim_row = matrix.At(static_cast(i)).GetRows(); - if (dim_row != 3) - { - iNumErr++; - console() << _T("\n Array dimension mismatch in matrix row ") << i - << _T(" (expected=3; dim=") << dim_row << _T(")"); - } - } - - // test type checking of values - if (!fVal.IsScalar() || fVal.IsMatrix() || fVal.GetType() != 'f') iNumErr++; - if (!cVal.IsScalar() || cVal.IsMatrix() || cVal.GetType() != 'c') iNumErr++; - if (aVal.IsScalar() || !aVal.IsMatrix() || aVal.GetType() != 'm') iNumErr++; - if (sVal.IsScalar() || sVal.IsMatrix() || sVal.GetType() != 's') iNumErr++; - if (sVal1.IsScalar() || sVal1.IsMatrix() || sVal1.GetType() != 's') iNumErr++; - if (bVal.IsScalar() || bVal.IsMatrix() || bVal.GetType() != 'b') iNumErr++; - - // test type checking of variables - if (!fVar.IsScalar() || fVar.IsMatrix() || fVar.GetType() != 'f') iNumErr++; - if (!cVar.IsScalar() || cVar.IsMatrix() || cVar.GetType() != 'c') iNumErr++; - if (aVar.IsScalar() || !aVar.IsMatrix() || aVar.GetType() != 'm') iNumErr++; - if (sVar.IsScalar() || sVar.IsMatrix() || sVar.GetType() != 's') iNumErr++; - if (sVar1.IsScalar() || sVar1.IsMatrix() || sVar1.GetType() != 's') iNumErr++; - if (bVar.IsScalar() || bVar.IsMatrix() || bVar.GetType() != 'b') iNumErr++; - - // Issue 33: https://code.google.com/p/muparserx/issues/detail?id=33 - // Remark: Type information was not properly set when invoking +=, -= operators - { - Value x = 1.0; - Value y = cmplx_type(0, 1); - x += y; - if (x.GetImag() != 1 || x.GetFloat() != 1 || x.GetType() != 'c') - { - *m_stream << _T("\nValue::operator+=(...) failed."); - iNumErr++; - } - - x = 1.0; - y = cmplx_type(0, 1); - x -= y; - if (x.GetImag() != -1 || x.GetFloat() != 1 || x.GetType() != 'c') - { - *m_stream << _T("\nValue::operator-=(...) failed."); - iNumErr++; - } - } - } - catch (...) - { - iNumErr++; - } - - bool bError; - -#define VALUE_THROWCHECK(VAR, FAIL, MEMBER) \ - bError = (FAIL); \ - try \ - { \ - VAR.MEMBER(); \ - } \ - catch (...) \ - { \ - bError ^= true; \ - } \ - iNumErr += (bError) ? 1 : 0; \ - c_iCount++; - - // Check if the getter functions really throw an exception - // when used with an incorrect value type - // Case 1: test float values - VALUE_THROWCHECK(fVal, false, GetFloat) - VALUE_THROWCHECK(fVal, false, GetImag) - VALUE_THROWCHECK(fVal, true, GetBool) - VALUE_THROWCHECK(fVal, true, GetString) - VALUE_THROWCHECK(fVal, true, GetArray) - // for variables - VALUE_THROWCHECK(fVar, false, GetFloat) - VALUE_THROWCHECK(fVar, false, GetImag) - VALUE_THROWCHECK(fVar, true, GetBool) - VALUE_THROWCHECK(fVar, true, GetString) - VALUE_THROWCHECK(fVar, true, GetArray) - - // Case 2: test bool values - VALUE_THROWCHECK(bVal, false, GetFloat) - VALUE_THROWCHECK(bVal, true, GetImag) - VALUE_THROWCHECK(bVal, false, GetBool) - VALUE_THROWCHECK(bVal, true, GetString) - VALUE_THROWCHECK(bVal, true, GetArray) - // for variables - VALUE_THROWCHECK(bVar, false, GetFloat) - VALUE_THROWCHECK(bVar, true, GetImag) - VALUE_THROWCHECK(bVar, false, GetBool) - VALUE_THROWCHECK(bVar, true, GetString) - VALUE_THROWCHECK(bVar, true, GetArray) - - // Case 3: test string values - // VALUE_THROWCHECK(sVal, true, GetFloat) - VALUE_THROWCHECK(sVal, true, GetImag) - VALUE_THROWCHECK(sVal, true, GetBool) - VALUE_THROWCHECK(sVal, false, GetString) - VALUE_THROWCHECK(sVal, true, GetArray) - // for variables - // VALUE_THROWCHECK(sVar, true, GetFloat) - VALUE_THROWCHECK(sVar, true, GetImag) - VALUE_THROWCHECK(sVar, true, GetBool) - VALUE_THROWCHECK(sVar, false, GetString) - VALUE_THROWCHECK(sVar, true, GetArray) - - // Case 4: test array values - // VALUE_THROWCHECK(aVal, true, GetFloat) - VALUE_THROWCHECK(aVal, true, GetImag) - VALUE_THROWCHECK(aVal, true, GetBool) - VALUE_THROWCHECK(aVal, true, GetString) - VALUE_THROWCHECK(aVal, false, GetArray) - // for variables - // VALUE_THROWCHECK(aVar, true, GetFloat) - VALUE_THROWCHECK(aVar, true, GetImag) - VALUE_THROWCHECK(aVar, true, GetBool) - VALUE_THROWCHECK(aVar, true, GetString) - VALUE_THROWCHECK(aVar, false, GetArray) - - // Case 5: test complex values - // VALUE_THROWCHECK(cVal, false, GetFloat) - VALUE_THROWCHECK(cVal, false, GetImag) - VALUE_THROWCHECK(cVal, true, GetBool) - VALUE_THROWCHECK(cVal, true, GetString) - VALUE_THROWCHECK(cVal, true, GetArray) - // for variables - // VALUE_THROWCHECK(cVar, false, GetFloat) - VALUE_THROWCHECK(cVar, false, GetImag) - VALUE_THROWCHECK(cVar, true, GetBool) - VALUE_THROWCHECK(cVar, true, GetString) - VALUE_THROWCHECK(cVar, true, GetArray) -#undef VALUE_THROWCHECK - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestErrorCodes() -{ - int iNumErr = 0; - *m_stream << _T("testing error codes..."); - - iNumErr += ThrowTest(_T("a,b"), ecUNEXPECTED_COMMA); - iNumErr += ThrowTest(_T("(a,b)"), ecUNEXPECTED_COMMA); - iNumErr += ThrowTest(_T("((a,b))"), ecUNEXPECTED_COMMA); - iNumErr += ThrowTest(_T("2*1,2"), ecUNEXPECTED_COMMA); - iNumErr += ThrowTest(_T("sin(1,2)"), ecTOO_MANY_PARAMS); - - // Invalid expression - // Issue 20: http://code.google.com/p/muparserx/issues/detail?id=20 - iNumErr += ThrowTest(_T(" "), ecUNEXPECTED_EOF); - - iNumErr += ThrowTest(_T("sin(nonexistent_var)"), ecUNASSIGNABLE_TOKEN, 4, _T("nonexistent_var")); - - // Invalid function argument types - iNumErr += ThrowTest(_T("sin(\"test\")"), ecEVAL, 0); - iNumErr += ThrowTest(_T("max(1, \"test\")"), ecEVAL, 0); - iNumErr += ThrowTest(_T("max(1,sin(8), \"t\")"), ecEVAL, 0); - iNumErr += ThrowTest(_T("str2dbl(sin(3.14))"), ecEVAL, 0); - - // Invalid unary operator argument types - iNumErr += ThrowTest(_T("\"test\"n"), ecEVAL, 6); // (nano can only be applied to floats) - iNumErr += ThrowTest(_T("(1+3i)/(8*9i)+\"hallo\""), ecEVAL); - iNumErr += ThrowTest(_T("(1+3i)/(8*9i)-\"hallo\""), ecEVAL); - iNumErr += ThrowTest(_T("(1+3i)/(8*9i)*\"hallo\""), ecEVAL); - iNumErr += ThrowTest(_T("(1+3i)/(8*9i)/\"hallo\""), ecEVAL); - iNumErr += ThrowTest(_T("10+va"), ecEVAL, 2); - - // Type conflicts in binary operators - iNumErr += ThrowTest(_T("\"test\" // 8"), ecEVAL, 7); - iNumErr += ThrowTest(_T("8//\"test\""), ecEVAL, 1); - iNumErr += ThrowTest(_T("5//8"), ecEVAL, 1); - iNumErr += ThrowTest(_T("\"t\"//sin(8)"), ecEVAL, 3); - iNumErr += ThrowTest(_T("sin(8)//\"t\""), ecEVAL, 6); - - // Unexpected end of expression - iNumErr += ThrowTest(_T("3+"), ecUNEXPECTED_EOF); - iNumErr += ThrowTest(_T("8*"), ecUNEXPECTED_EOF); - iNumErr += ThrowTest(_T("3+("), ecUNEXPECTED_EOF); - iNumErr += ThrowTest(_T("3+sin"), ecUNEXPECTED_EOF); - iNumErr += ThrowTest(_T("(2+"), ecUNEXPECTED_EOF); - - iNumErr += ThrowTest(_T("3+)"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("3)"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("(3))"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("()"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("(2+)"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("sin(cos)"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("sin(())"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("sin()"), ecTOO_FEW_PARAMS); - iNumErr += ThrowTest(_T("sin)"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("pi)"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("a)"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("2(-m)"), ecUNEXPECTED_PARENS); - iNumErr += ThrowTest(_T("2(m)"), ecUNEXPECTED_PARENS); - - iNumErr += ThrowTest(_T("(1+2"), ecMISSING_PARENS); - iNumErr += ThrowTest(_T("((3)"), ecMISSING_PARENS); - - // The behaviour in the next function depends on whether - // implicit variable creation is allowed or not. (momentarily its active) - iNumErr += ThrowTest(_T("5z)"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("sin(3)xyz"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("5t6"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("5 t 6"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("ksdfj"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("-m"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("m4"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("sin(m)"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("m m"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("m(8)"), ecUNASSIGNABLE_TOKEN); - iNumErr += ThrowTest(_T("4 + m"), ecUNASSIGNABLE_TOKEN); - - // unexpected operator - iNumErr += ThrowTest(_T("5+*3)"), ecUNEXPECTED_OPERATOR); - - // unexpected comma (used without a function) - iNumErr += ThrowTest(_T(",3"), ecUNEXPECTED_COMMA); - iNumErr += ThrowTest(_T("sin(,sin(8))"), ecUNEXPECTED_COMMA); - - // unexpected variable - iNumErr += ThrowTest(_T("a _xxx_ b"), ecUNASSIGNABLE_TOKEN, 2); // if a variable factory is installed ecUNEXPECTED_VAR - - iNumErr += ThrowTest(_T("sin(3)cos(3)"), ecUNEXPECTED_FUN); - iNumErr += ThrowTest(_T("sin(3)3"), ecUNEXPECTED_VAL); - iNumErr += ThrowTest(_T("sin(3)+"), ecUNEXPECTED_EOF); - - // value recognition - iNumErr += ThrowTest(_T("0x"), ecUNASSIGNABLE_TOKEN); // incomplete hex value - iNumErr += ThrowTest(_T("1+0x"), ecUNASSIGNABLE_TOKEN); // incomplete hex value - iNumErr += ThrowTest(_T("a+0x"), ecUNASSIGNABLE_TOKEN); // incomplete hex value - - // index operator - iNumErr += ThrowTest(_T("3n[1]"), ecINDEX_OUT_OF_BOUNDS); // Indexing a scalar is ok, but this index is out of bounds (0 would be ok) - iNumErr += ThrowTest(_T("min(3,]"), ecUNEXPECTED_SQR_BRACKET); - iNumErr += ThrowTest(_T("sin(]"), ecUNEXPECTED_SQR_BRACKET); - iNumErr += ThrowTest(_T("va[]"), ecUNEXPECTED_SQR_BRACKET); - iNumErr += ThrowTest(_T("3+]"), ecUNEXPECTED_SQR_BRACKET); - iNumErr += ThrowTest(_T("sin[a)"), ecUNEXPECTED_SQR_BRACKET); - iNumErr += ThrowTest(_T("1+[8]"), ecUNEXPECTED_SQR_BRACKET); - iNumErr += ThrowTest(_T("1[8]"), ecUNEXPECTED_SQR_BRACKET); - iNumErr += ThrowTest(_T("[1]"), ecUNEXPECTED_SQR_BRACKET); - iNumErr += ThrowTest(_T("]1"), ecUNEXPECTED_SQR_BRACKET); - iNumErr += ThrowTest(_T("va[[3]]"), ecUNEXPECTED_SQR_BRACKET); - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestStringFun() -{ - int iNumErr = 0; - *m_stream << _T("testing string functions..."); - - // escape sequences - iNumErr += EqnTest(_T("\"\\\"quoted_string\\\"\""), _T("\"quoted_string\""), true); // "\"quoted_string\"" -> "quoted_string" - iNumErr += EqnTest(_T("\"\\\"\\\"\""), _T("\"\""), true); // "\"\"" -> "" - iNumErr += EqnTest(_T("\"\\\\\""), _T("\\"), true); // "\\" -> \ (single backslash) - - // String functions - iNumErr += EqnTest(_T("strlen(\"12345\")"), 5.0, true); - iNumErr += EqnTest(_T("strlen(toupper(\"abcde\"))"), 5.0, true); - iNumErr += EqnTest(_T("sin(0)+(float)strlen(\"12345\")"), (float_type)5.0, true); - iNumErr += EqnTest(_T("10*(float)strlen(toupper(\"12345\"))"), (float_type)50.0, true); - iNumErr += EqnTest(_T("\"hello \"//\"world\""), string_type(_T("hello world")), true); - iNumErr += EqnTest(_T("toupper(\"hello \")//\"world\""), string_type(_T("HELLO world")), true); - iNumErr += EqnTest(_T("\"hello \"//toupper(\"world\")//\" !!!\""), string_type(_T("hello WORLD !!!")), true); - - Assessment(iNumErr); - - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestPostfix() -{ - int iNumErr = 0; - *m_stream << _T("testing postfix operators..."); - - // application - iNumErr += EqnTest(_T("1n"), (float_type)1e-9, true); - iNumErr += EqnTest(_T("8n"), (float_type)8e-9, true); - iNumErr += EqnTest(_T("8n"), (float_type)123.0, false); - iNumErr += EqnTest(_T("3m+5"), (float_type)5.003, true); - iNumErr += EqnTest(_T("1000m"), (float_type)1.0, true); - iNumErr += EqnTest(_T("1000 m"), (float_type)1.0, true); - iNumErr += EqnTest(_T("(a)m"), (float_type)1e-3, true); - iNumErr += EqnTest(_T("-(a)m"), (float_type)-1e-3, true); - iNumErr += EqnTest(_T("-2m"), (float_type)-2e-3, true); - iNumErr += EqnTest(_T("a++b"), 3.0, true); - iNumErr += EqnTest(_T("a ++ b"), 3.0, true); - iNumErr += EqnTest(_T("1++2"), 3.0, true); - iNumErr += EqnTest(_T("1 ++ 2"), 3.0, true); - iNumErr += EqnTest(_T("2+(a*1000)m"), (float_type)3.0, true); - // some incorrect results - iNumErr += EqnTest(_T("1000m"), (float_type)0.1, false); - iNumErr += EqnTest(_T("(a)m"), (float_type)2.0, false); - // factorial operator - iNumErr += EqnTest(_T("5!"), 120.0, true); - iNumErr += EqnTest(_T("-5!"), -120.0, true); - iNumErr += ThrowTest(_T("(-5)!"), ecDOMAIN_ERROR); - - // Special tests for systems not supporting IEEE 754 - if (!std::numeric_limits::is_iec559) - { - iNumErr += ThrowTest(_T("123456!"), ecOVERFLOW); - } - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestInfix() -{ - int iNumErr = 0; - *m_stream << _T("testing infix operators..."); - - float_type a = 1; - float_type b = 2; - - iNumErr += EqnTest(_T("-1"), (float_type)-1.0, true); - iNumErr += EqnTest(_T("-(-1)"), (float_type)1.0, true); - iNumErr += EqnTest(_T("-(-1)*2"), (float_type)2.0, true); - iNumErr += EqnTest(_T("-(-2)*sqrt(4)"), (float_type)4.0, true); - iNumErr += EqnTest(_T("-a"), -a, true); - iNumErr += EqnTest(_T("-(a)"), -(a), true); - iNumErr += EqnTest(_T("-(-a)"), -(-a), true); - iNumErr += EqnTest(_T("-(-a)*2"), -(-a) * 2, true); - iNumErr += EqnTest(_T("-(8)"), (float_type)-8.0, true); - iNumErr += EqnTest(_T("-8"), (float_type)-8.0, true); - iNumErr += EqnTest(_T("-(2+1)"), (float_type)-3.0, true); - //iNumErr += EqnTest("-(f1of1(1+2*3)+1*2)", -9.0, true); - //iNumErr += EqnTest("-(-f1of1(1+2*3)+1*2)", 5.0, true); - iNumErr += EqnTest(_T("-sin(8)"), (float_type)-0.989358, true); - iNumErr += EqnTest(_T("-sin(8)"), (float_type)0.989358, false); - iNumErr += EqnTest(_T("3-(-a)"), (float_type)4.0, true); - iNumErr += EqnTest(_T("3--a"), (float_type)4.0, true); - iNumErr += EqnTest(_T("2++4"), (float_type)6.0, true); - iNumErr += EqnTest(_T("--1"), (float_type)1.0, true); - - // sign precedence - // Issue 14: https://code.google.com/p/muparserx/issues/detail?id=14 - iNumErr += EqnTest(_T("-3^2"), -9.0, true); - iNumErr += EqnTest(_T("-b^2^3-b^8"), -std::pow(b, std::pow(2.0, 3.0)) - std::pow(b, 8), true); - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestMultiArg() -{ - int iNumErr = 0; - *m_stream << _T("testing multiarg functions..."); - - // Multiarg functions being called without any parameters - iNumErr += ThrowTest(_T("min()"), ecTOO_FEW_PARAMS); - iNumErr += ThrowTest(_T("max()"), ecTOO_FEW_PARAMS); - iNumErr += ThrowTest(_T("sum()"), ecTOO_FEW_PARAMS); - - // application - iNumErr += EqnTest(_T("max(1,8,9,(int)6)"), (float_type)9.0, true); - iNumErr += EqnTest(_T("max((int)6, 1+2, 4, -9)"), (float_type)6.0, true); - iNumErr += EqnTest(_T("min((int)6, 1+2, 4, -9)"), (float_type)-9.0, true); - - // - iNumErr += EqnTest(_T("a=test0()"), (float_type)0, true); - iNumErr += EqnTest(_T("b=a+test0()"), (float_type)1, true); - - // added as response to this bugreport: - // http://code.google.com/p/muparserx/issues/detail?id=1 - // cause of the error: Function tokens were not cloned in the tokenreader when beeing found. - // a pointer to the one and only function onject was returned instead - // consequently the argument counter was overwritten by the second function call - // causing an assertion later on. - iNumErr += EqnTest(_T("sum(1,2)/sum(3,4)"), (float_type)0.428571, true); - iNumErr += EqnTest(_T("3/sum(3,4,5)"), (float_type)0.25, true); - iNumErr += EqnTest(_T("sum(3)/sum(3,4,5)"), (float_type)0.25, true); - iNumErr += EqnTest(_T("sum(3)+sum(3,4,5)"), (float_type)15, true); - iNumErr += EqnTest(_T("sum(1,2)/sum(3,4,5)"), (float_type)0.25, true); - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestVector() -{ - int iNumErr = 0; - *m_stream << _T("testing vector operations..."); - - // Vector operations - iNumErr += ThrowTest(_T("10+2*va"), ecEVAL); // fail: number + vector - iNumErr += ThrowTest(_T("10+va*2"), ecEVAL); // fail: number + vector - iNumErr += ThrowTest(_T("va+vc"), ecMATRIX_DIMENSION_MISMATCH); // fail: vectors of different size - iNumErr += ThrowTest(_T("va-vc"), ecMATRIX_DIMENSION_MISMATCH); // fail: vectors of different size - iNumErr += ThrowTest(_T("va*vc"), ecMATRIX_DIMENSION_MISMATCH); // fail: vectors of different size - iNumErr += ThrowTest(_T("va*vb"), ecMATRIX_DIMENSION_MISMATCH); // fail: matrix dimension mismatch - iNumErr += ThrowTest(_T("va*va"), ecMATRIX_DIMENSION_MISMATCH); // fail: matrix dimension mismatch - iNumErr += ThrowTest(_T("(va*vb)*b"), ecMATRIX_DIMENSION_MISMATCH); // fail: matrix dimension mismatch - iNumErr += ThrowTest(_T("va[1.23]"), ecTYPE_CONFLICT_IDX, 7); // fail: float value used as index - iNumErr += ThrowTest(_T("va[sin(8)]"), ecTYPE_CONFLICT_IDX, 9); // fail: float value used as index - iNumErr += ThrowTest(_T("va[-1]"), ecINDEX_OUT_OF_BOUNDS); // fail: negative value used as an index - iNumErr += ThrowTest(_T("va[c]"), ecINDEX_OUT_OF_BOUNDS); - iNumErr += ThrowTest(_T("va[(3)]"), ecINDEX_OUT_OF_BOUNDS); - iNumErr += ThrowTest(_T("a[1]"), ecINDEX_OUT_OF_BOUNDS); // indexing a scalar is ok, but this index is out of bounds (0 would be ok...) - iNumErr += ThrowTest(_T("va[1"), ecMISSING_SQR_BRACKET); - iNumErr += ThrowTest(_T("va[1]]"), ecUNEXPECTED_SQR_BRACKET); - - //iNumErr += ThrowTest(_T("va==9"), ecEVAL); - //iNumErr += ThrowTest(_T("va==a"), ecEVAL); - //iNumErr += ThrowTest(_T("a==va"), ecEVAL); - //iNumErr += ThrowTest(_T("9==va"), ecEVAL); - - Value v(3, 0); - v.At(0) = (float_type)5.0; - v.At(1) = (float_type)5.0; - v.At(2) = (float_type)5.0; - iNumErr += EqnTest(_T("va+vb"), v, true); - - v.At(0) = (float_type)5.0; - v.At(1) = (float_type)5.0; - v.At(2) = (float_type)6.0; - iNumErr += EqnTest(_T("va+vb"), v, false); - - v.At(0) = (float_type)-1.0; - v.At(1) = (float_type)-2.0; - v.At(2) = (float_type)-3.0; - iNumErr += EqnTest(_T("-va"), v, true); - - iNumErr += EqnTest(_T("sizeof(va+vb)"), 3.0, true); - iNumErr += EqnTest(_T("sizeof(va-vb)"), 3.0, true); - - iNumErr += EqnTest(_T("va==vb"), false, true); - iNumErr += EqnTest(_T("va!=vb"), true, true); - //iNumErr += EqnTest(_T("vavb"), true, true); - //iNumErr += EqnTest(_T("va<=vb"), false, true); - //iNumErr += EqnTest(_T("va>=vb"), true, true); - - iNumErr += EqnTest(_T("vb[va[0]]"), 3.0, true); - iNumErr += EqnTest(_T("m1[0,0]+m1[1,1]+m1[2,2]"), 3.0, true); - iNumErr += EqnTest(_T("vb[m1[0,0]]"), 3.0, true); - - iNumErr += EqnTest(_T("m1[0,0]=2"), 2.0, true); - iNumErr += EqnTest(_T("m1[1,1]=2"), 2.0, true); - iNumErr += EqnTest(_T("m1[2,2]=2"), 2.0, true); - iNumErr += EqnTest(_T("va[0]=12.3"), (float_type)12.3, true); - iNumErr += EqnTest(_T("va[1]=12.3"), (float_type)12.3, true); - iNumErr += EqnTest(_T("va[2]=12.3"), (float_type)12.3, true); - - iNumErr += EqnTest(_T("va[0]"), 1.0, true); - iNumErr += EqnTest(_T("va[1]"), 2.0, true); - iNumErr += EqnTest(_T("va[2]"), 3.0, true); - iNumErr += EqnTest(_T("(va[2])"), 3.0, true); - iNumErr += EqnTest(_T("va[a]"), 2.0, true); - iNumErr += EqnTest(_T("(va[a])"), 2.0, true); - iNumErr += EqnTest(_T("va[b]"), 3.0, true); - iNumErr += EqnTest(_T("va[(2)]"), 3.0, true); - iNumErr += EqnTest(_T("va[-(-2)]"), 3.0, true); - iNumErr += EqnTest(_T("(va[(2)])"), 3.0, true); - iNumErr += EqnTest(_T("(va[-(-2)])"), 3.0, true); - iNumErr += EqnTest(_T("va[1+1]"), 3.0, true); - iNumErr += EqnTest(_T("va[(int)sin(8)+1]"), 2.0, true); - - iNumErr += EqnTest(_T("va[2]+4"), 7.0, true); - iNumErr += EqnTest(_T("4+va[2]"), 7.0, true); - iNumErr += EqnTest(_T("va[2]*4"), 12.0, true); - iNumErr += EqnTest(_T("4*va[2]"), 12.0, true); - iNumErr += EqnTest(_T("va[2]+a"), 4.0, true); - iNumErr += EqnTest(_T("a+va[2]"), 4.0, true); - iNumErr += EqnTest(_T("va[2]*b"), 6.0, true); - iNumErr += EqnTest(_T("b*va[2]"), 6.0, true); - - // Issue 68 (and related issues): - iNumErr += EqnTest(_T("(abs(-3)+2)>=min(6,5)"), true, true); - iNumErr += EqnTest(_T("(abs(-3))>abs(2)"), true, true); - iNumErr += EqnTest(_T("min(1,2,-3)>-4"), true, true); - iNumErr += EqnTest(_T("(abs(-3))>-2"), true, true); - iNumErr += EqnTest(_T("abs(-3)>abs(2)"), true, true); - - // Issue 42: - // https://code.google.com/p/muparserx/issues/detail?id=42 - v.At(0) = (float_type)1.0; - v.At(1) = (float_type)0.0; - v.At(2) = (float_type)0.0; - iNumErr += EqnTest(_T("{1,0,0}'"), v, true); - iNumErr += EqnTest(_T("{(1),0,0}'"), v, true); - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestBinOp() -{ - int iNumErr = 0; - *m_stream << _T("testing binary operators..."); - float_type a = 1; - - // standard aperators - iNumErr += EqnTest(_T("1+7"), (float_type)8.0, true); - iNumErr += EqnTest(_T("10-1"), (float_type)9.0, true); - iNumErr += EqnTest(_T("3*4"), (float_type)12.0, true); - iNumErr += EqnTest(_T("10/2"), (float_type)5.0, true); - // operator associativity - iNumErr += EqnTest(_T("2^2^3"), (float_type)256.0, true); - iNumErr += EqnTest(_T("3+4*2/(1-5)^2^3"), (float_type)3.0001220703125, true); - iNumErr += EqnTest(_T("1/2/3"), (float_type)1.0 / (float_type)6.0, true); - - // operator precedencs - iNumErr += EqnTest(_T("1+2-3*4/5^6"), (float_type)2.99923, true); - iNumErr += EqnTest(_T("a+b-c*4/5^6"), (float_type)2.99923, true); - iNumErr += EqnTest(_T("1^2/3*4-5+6"), (float_type)2.3333, true); - iNumErr += EqnTest(_T("a^b/c*4-5+6"), (float_type)2.3333, true); - iNumErr += EqnTest(_T("1+2*3"), (float_type)7.0, true); - iNumErr += EqnTest(_T("a+b*c"), (float_type)7.0, true); - iNumErr += EqnTest(_T("(1+2)*3"), (float_type)9.0, true); - iNumErr += EqnTest(_T("(a+b)*c"), (float_type)9.0, true); - iNumErr += EqnTest(_T("(1+2)*(-3)"), (float_type)-9.0, true); - iNumErr += EqnTest(_T("(a+b)*(-c)"), (float_type)-9.0, true); - iNumErr += EqnTest(_T("2/4"), (float_type)0.5, true); - iNumErr += EqnTest(_T("4&4"), 4.0, true); - iNumErr += EqnTest(_T("2+2&(a+b+c)"), 4.0, true); - iNumErr += EqnTest(_T("3&3"), 3.0, true); - iNumErr += EqnTest(_T("c&3"), 3.0, true); - iNumErr += EqnTest(_T("(c)&3"), 3.0, true); - iNumErr += EqnTest(_T("(a+b)&3"), 3.0, true); - iNumErr += EqnTest(_T("(a+b+c)&6"), 6.0, true); - iNumErr += EqnTest(_T("(1+2+3)&6"), 6.0, true); - iNumErr += EqnTest(_T("3&c"), 3.0, true); - iNumErr += EqnTest(_T("(a<<1)+2"), 4.0, true); - iNumErr += EqnTest(_T("(a<<2)+2"), 6.0, true); - iNumErr += EqnTest(_T("(a<<3)+2"), 10.0, true); - iNumErr += EqnTest(_T("(a<<4)+2"), 18.0, true); - iNumErr += EqnTest(_T("(a<<5)+2"), 34.0, true); - iNumErr += EqnTest(_T("1<<31"), (float_type)2147483648, true); - iNumErr += EqnTest(_T("-1<<31"), (float_type)-2147483648.0, true); - iNumErr += EqnTest(_T("1<<45"), (float_type)35184372088832.0, true); - iNumErr += EqnTest(_T("-1<<45"), (float_type)-35184372088832.0, true); - iNumErr += EqnTest(_T("8<<-2"), 2.0, true); - iNumErr += EqnTest(_T("8<<-4"), 0.0, true); - // Issue 25: http://code.google.com/p/muparserx/issues/detail?id=25 - iNumErr += ThrowTest(_T("55<<2222222"), ecOVERFLOW); - // Issue 16: http://code.google.com/p/muparserx/issues/detail?id=16 - iNumErr += EqnTest(_T("true == true && false"), true == true && false, true); - iNumErr += EqnTest(_T("false == true && false"), false == true && false, true); - iNumErr += EqnTest(_T("a==1.0 && a==1.0"), a == 1.0 && a == 1.0, true); - - // bool operators for comparing values - iNumErr += EqnTest(_T("aa"), true, true); - iNumErr += EqnTest(_T("a>a"), false, true); - iNumErr += EqnTest(_T("aa"), false, true); - iNumErr += EqnTest(_T("a<=a"), true, true); - iNumErr += EqnTest(_T("a<=b"), true, true); - iNumErr += EqnTest(_T("b<=a"), false, true); - iNumErr += EqnTest(_T("a>=a"), true, true); - iNumErr += EqnTest(_T("b>=a"), true, true); - iNumErr += EqnTest(_T("a>=b"), false, true); - // The following equations were raising type conflict errors once - // since the result of sqrt(1) is 1 which is an integer as fas as muParserX - // is concerned: - iNumErr += EqnTest(_T("sqrt(a)sin(8)"), true, true); - iNumErr += EqnTest(_T("sqrt(a)>=sin(8)"), true, true); - iNumErr += EqnTest(_T("sqrt(a)==sin(8)"), false, true); - iNumErr += EqnTest(_T("sqrt(a)!=sin(8)"), true, true); - iNumErr += EqnTest(_T("sqrt(a)+1.01"), (float_type)2.01, true); - iNumErr += EqnTest(_T("sqrt(a)-1.01"), (float_type)-0.01, true); - - // interaction with sign operator - iNumErr += EqnTest(_T("3-(-a)"), 4.0, true); - iNumErr += EqnTest(_T("3--a"), 4.0, true); - - // Problems with small bogus real/imag values introduced due to limited floating point accuracy - iNumErr += EqnTest(_T("(-2)^3"), -8.0, true); // may introduce incorrect imaginary value (When computed with the log/exp formula: -8 + 2.93e-15i) - iNumErr += EqnTest(_T("imag((-2)^3)==0"), true, true); // may introduce incorrect imaginary value (When computed with the log/exp formula: -8 + 2.93e-15i) - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestIfElse() -{ - int iNumErr = 0; - *m_stream << _T("testing if-else conditional..."); - - float_type a = 1; - - // Test error detection - iNumErr += ThrowTest(_T(": 2"), ecMISPLACED_COLON); - iNumErr += ThrowTest(_T("? 1 : 2"), ecUNEXPECTED_CONDITIONAL); - iNumErr += ThrowTest(_T("(ab) ? true : false) ? 1 : 2"), 2.0, true); - iNumErr += EqnTest(_T("((a>b) ? true : false) ? 1 : sum((a>b) ? 1 : 2)"), 2.0, true); - iNumErr += EqnTest(_T("((a>b) ? false : true) ? 1 : sum((a>b) ? 1 : 2)"), 1.0, true); - iNumErr += EqnTest(_T("(true) ? 10 : 11"), 10.0, true); - iNumErr += EqnTest(_T("(true) ? a+b : c+d"), 3.0, true); - iNumErr += EqnTest(_T("(true) ? false : true"), false, true); - iNumErr += EqnTest(_T("(false) ? 10 : 11"), 11.0, true); - iNumErr += EqnTest(_T("(false) ? a+b : c+d"), 1.0, true); - iNumErr += EqnTest(_T("(false) ? false : true"), true, true); - iNumErr += EqnTest(_T("(ab) ? 10 : 11"), 11.0, true); - iNumErr += EqnTest(_T("(ab) ? c : d"), -2.0, true); - iNumErr += EqnTest(_T("(a>b) ? true : false"), false, true); - - // With multiarg functions - iNumErr += EqnTest(_T("sum((a>b) ? 1 : 2)"), 2.0, true); - iNumErr += EqnTest(_T("sum((a>b) ? 1 : 2, 100)"), 102.0, true); - iNumErr += EqnTest(_T("sum((true) ? 1 : 2)"), 1.0, true); - iNumErr += EqnTest(_T("sum((true) ? 1 : 2, 100)"), 101.0, true); - iNumErr += EqnTest(_T("sum(3, (a>b) ? 3 : 10)"), 13.0, true); - iNumErr += EqnTest(_T("sum(3, (ab) ? 3 : 10)*10"), 130.0, true); - iNumErr += EqnTest(_T("sum(3, (ab) ? 3 : 10)"), 130.0, true); - iNumErr += EqnTest(_T("10*sum(3, (ab) ? sum(3, (ab) ? sum(3, (ab) ? sum(3, (ab)&&(a2)&&(1<2) ? 128 : 255"), 255.0, true); - iNumErr += EqnTest(_T("((1<2)&&(1<2)) ? 128 : 255"), 128.0, true); - iNumErr += EqnTest(_T("((1>2)&&(1<2)) ? 128 : 255"), 255.0, true); - iNumErr += EqnTest(_T("((ab)&&(ac) ? 1 : 2) : 3"), 2., true); - iNumErr += EqnTest(_T("(a>b) ? ((bb) ? ((b>c) ? 1 : 2) : 3"), 3., true); - - // nested conditionals without brackets - iNumErr += EqnTest(_T("(ac) ? 1 : 2 : 3"), 2., true); - iNumErr += EqnTest(_T("(a>b) ? (bb) ? (b>c) ? 1 : 2 : 3"), 3., true); - - // Neue Tests - iNumErr += EqnTest(_T("(ab)&&(a2)&&(1<2) ? 128 : 255"), 255., true); - iNumErr += EqnTest(_T("((1<2)&&(1<2)) ? 128 : 255"), 128., true); - iNumErr += EqnTest(_T("((1>2)&&(1<2)) ? 128 : 255"), 255., true); - iNumErr += EqnTest(_T("((ab)&&(a0 ? 1>2 ? 128 : 255 : 1>0 ? 32 : 64"), 255., true); - iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 :(1>0 ? 32 : 64)"), 255., true); - iNumErr += EqnTest(_T("1>0 ? 1>0 ? 128 : 255 : 1>2 ? 32 : 64"), 128., true); - iNumErr += EqnTest(_T("1>0 ? 1>0 ? 128 : 255 :(1>2 ? 32 : 64)"), 128., true); - iNumErr += EqnTest(_T("1>2 ? 1>2 ? 128 : 255 : 1>0 ? 32 : 64"), 32., true); - iNumErr += EqnTest(_T("1>2 ? 1>0 ? 128 : 255 : 1>2 ? 32 : 64"), 64., true); - iNumErr += EqnTest(_T("1>0 ? 50 : 1>0 ? 128 : 255"), 50., true); - iNumErr += EqnTest(_T("1>0 ? 50 : (1>0 ? 128 : 255)"), 50., true); - iNumErr += EqnTest(_T("1>0 ? 1>0 ? 128 : 255 : 50"), 128., true); - iNumErr += EqnTest(_T("1>2 ? 1>2 ? 128 : 255 : 1>0 ? 32 : 1>2 ? 64 : 16"), 32., true); - iNumErr += EqnTest(_T("1>2 ? 1>2 ? 128 : 255 : 1>0 ? 32 :(1>2 ? 64 : 16)"), 32., true); - iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 : 1>0 ? 32 :1>2 ? 64 : 16"), 255., true); - iNumErr += EqnTest(_T("1>0 ? 1>2 ? 128 : 255 : (1>0 ? 32 :1>2 ? 64 : 16)"), 255., true); - iNumErr += EqnTest(_T("true ? false ? 128 : 255 : true ? 32 : 64"), 255., true); - - // assignment operators - iNumErr += EqnTest(_T("a= false ? 128 : 255"), 255., true); - iNumErr += EqnTest(_T("a=((a>b)&&(a - - // long formula (Reference: Matlab) - iNumErr += EqnTest( - "(atan(sin((((((((((((((((pi/cos((a/((((0.53-b)-pi)*e)/b))))+2.51)+a)-0.54)/0.98)+b)*b)+e)/a)+b)+a)+b)+pi)/e" - ")+a)))*2.77)", -2.16995656, true); - */ - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestScript() -{ - int iNumErr = 0; - *m_stream << _T("testing script features..."); - - // Test error detection - iNumErr += ThrowTest(_T("sin(\n"), ecUNEXPECTED_NEWLINE); - iNumErr += ThrowTest(_T("1+\n"), ecUNEXPECTED_NEWLINE); - iNumErr += ThrowTest(_T("a*\n"), ecUNEXPECTED_NEWLINE); - iNumErr += ThrowTest(_T("va[\n"), ecUNEXPECTED_NEWLINE); - iNumErr += ThrowTest(_T("(true) ? \n"), ecUNEXPECTED_NEWLINE); - iNumErr += ThrowTest(_T("(true) ? 10:\n"), ecUNEXPECTED_NEWLINE); - - // Expressions spanning multiple lines - iNumErr += EqnTest(_T("a=1\n") - _T("b=2\n") - _T("c=3\n") - _T("a+b+c"), 6., true); - - // Ending an expression with a newline - iNumErr += EqnTest(_T("3\n"), 3., true); - iNumErr += EqnTest(_T("1+2\n"), 3., true); - iNumErr += EqnTest(_T("\n1+2\n"), 3., true); - iNumErr += EqnTest(_T("\n1+2\n\na+b"), 3., true); - - // Testing comments - /* 20130107 Not yet... - iNumErr += EqnTest(_T("a=10 % this is a comment\n") - _T("b=23 % this is another comment\n") - _T("a+b"), 33, true); - */ - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -int ParserTester::TestValReader() -{ - int iNumErr = 0; - *m_stream << _T("testing value reader..."); - - // Hex value reader - iNumErr += EqnTest(_T("0x1"), 1., true); - iNumErr += EqnTest(_T("0x1+0x2"), 3., true); - iNumErr += EqnTest(_T("0xff"), 255., true); - - // Reading of binary values - iNumErr += EqnTest(_T("0b1"), 1., true); - iNumErr += EqnTest(_T("0b01"), 1., true); - iNumErr += EqnTest(_T("0b11"), 3., true); - iNumErr += EqnTest(_T("0b011"), 3., true); - iNumErr += EqnTest(_T("0b11111111"), 255., true); - iNumErr += EqnTest(_T("b*0b011"), 6.0, true); - iNumErr += EqnTest(_T("0b1111111111111111111111111111111"), 2147483647., true); - iNumErr += EqnTest(_T("0b10000000000000000000000000000000"), -2147483647. - 1, true); - iNumErr += EqnTest(_T("0b11111111111111111111111111111111"), -1., true); - iNumErr += ThrowTest(_T("0b100000000000000000000000000000000"), ecUNDEFINED); - - // string value reader - iNumErr += EqnTest(_T("\"hallo\""), _T("hallo"), true); - - // boolean value reader - iNumErr += EqnTest(_T("true"), true, true); - iNumErr += EqnTest(_T("false"), false, true); - - // boolean value reader - iNumErr += EqnTest(_T("true"), true, true); - iNumErr += EqnTest(_T("false"), false, true); - - // mixed - iNumErr += EqnTest(_T("0b011+0xef"), 242., true); - - Assessment(iNumErr); - return iNumErr; -} - -//--------------------------------------------------------------------------- -void ParserTester::AddTest(testfun_type a_pFun) -{ - m_vTestFun.push_back(a_pFun); -} - -//--------------------------------------------------------------------------- -void ParserTester::Run() -{ - int iStat = 0; - try - { - for (int i = 0; i < (int)m_vTestFun.size(); ++i) - iStat += (this->*m_vTestFun[i])(); - } - catch (ParserError &e) - { - *m_stream << e.GetMsg() << endl; - *m_stream << e.GetToken() << endl; - Abort(); - } - catch (std::exception &e) - { - *m_stream << e.what() << endl; - Abort(); - } - catch (...) - { - *m_stream << _T("Internal error"); - Abort(); - } - - if (iStat == 0) - { - *m_stream << _T("Test passed (") << ParserTester::c_iCount << _T(" expressions)") << endl; - } - else - { - *m_stream << _T("Test failed with ") << iStat - << _T(" errors (") << ParserTester::c_iCount - << _T(" expressions)") << endl; - } - ParserTester::c_iCount = 0; - -#ifdef MUP_LEAKAGE_REPORT - // All tokens must have been destroyed by now, verify this - IToken::LeakageReport(); -#endif -} - -//--------------------------------------------------------------------------- -int ParserTester::ThrowTest(const string_type &a_sExpr, int a_nErrc, int a_nPos, string_type a_sIdent) -{ - ParserTester::c_iCount++; - - try - { - ParserX p; - - // Add variables - Value vVarVal[] = { 1., 2., 3., -2. }; - p.DefineVar(_T("a"), Variable(&vVarVal[0])); - p.DefineVar(_T("b"), Variable(&vVarVal[1])); - p.DefineVar(_T("c"), Variable(&vVarVal[2])); - p.DefineVar(_T("d"), Variable(&vVarVal[3])); - - // array variables - Value aVal1(3, 0); - aVal1.At(0) = (float_type)1.0; - aVal1.At(1) = (float_type)2.0; - aVal1.At(2) = (float_type)3.0; - - Value aVal2(3, 0); - aVal2.At(0) = (float_type)4.0; - aVal2.At(1) = (float_type)3.0; - aVal2.At(2) = (float_type)2.0; - - Value aVal3(4, 0); - aVal3.At(0) = (float_type)4.0; - aVal3.At(1) = (float_type)3.0; - aVal3.At(2) = (float_type)2.0; - aVal3.At(3) = (float_type)5.0; - - Value aVal4(4, 0); - aVal4.At(0) = (float_type)4.0; - aVal4.At(1) = false; - aVal4.At(2) = _T("hallo"); - - // Matrix variables - Value m1(3, 3, 0); - m1.At(0, 0) = 1.; - m1.At(1, 1) = 1.; - m1.At(2, 2) = 1.; - - Value m2(3, 3, 0); - m2.At(0, 0) = 1.; m2.At(0, 1) = 2.; m2.At(0, 2) = 3.; - m2.At(1, 0) = 4.; m2.At(1, 1) = 5.; m2.At(1, 2) = 6.; - m2.At(2, 0) = 7.; m2.At(2, 1) = 8.; m2.At(2, 2) = 9.; - - p.DefineVar(_T("m1"), Variable(&m1)); - p.DefineVar(_T("m2"), Variable(&m2)); - p.DefineVar(_T("va"), Variable(&aVal1)); - p.DefineVar(_T("vb"), Variable(&aVal2)); - p.DefineVar(_T("vc"), Variable(&aVal3)); - p.DefineVar(_T("vd"), Variable(&aVal4)); - - p.SetExpr(a_sExpr); - Value fRes = p.Eval(); - } - catch (ParserError &e) - { - // output the formula in case of an failed test - if (a_nErrc != e.GetCode()) - { - *m_stream << _T("\n ") - << _T("Expression: \"") << a_sExpr - << _T("\" Code:") << e.GetCode() - << _T(" Expected:") << a_nErrc; - } - - // Check whether the error is reported at the correct expression position - if (a_nPos != -1 && a_nPos != e.GetPos()) - { - *m_stream << _T("\n ") - << _T("Invalid error position: \"") << a_sExpr - << _T("\" Pos:") << e.GetPos() - << _T(" Expected:") << a_nPos; - } - - if (a_sIdent.length() && a_sIdent != e.GetContext().Ident) - { - *m_stream << _T("\n ") - << _T("Invalid identifier: \"") << a_sExpr - << _T("\" Ident:") << e.GetContext().Ident - << _T(" Expected:") << a_sIdent; - } - - return (a_nErrc == e.GetCode() && (a_nPos == -1 || a_nPos == e.GetPos())) ? 0 : 1; - } - - *m_stream << _T("\n ") - << _T("Expression failed: \"") - << a_sExpr - << _T("\" (no exception raised)."); - - return 1; -} - -//--------------------------------------------------------------------------- -int ParserTester::EqnTest(const string_type &a_str, Value a_val, bool a_fPass, int nExprVar) -{ - ParserTester::c_iCount++; - int iRet(1); - Value fVal[5]; - - try - { - // p1 is a pointer since I'm going to delete it in order to test if - // parsers after copy construction still refer to members of the deleted object. - // !! If this is the case this function will crash !! - std::unique_ptr p1(new ParserX()); - - // Add variables - Value vVarVal[] = { 1., 2., 3., -2., -1. }; - - // m1 ist die Einheitsmatrix - Value m1(3, 3, 0); - m1.At(0, 0) = 1.; - m1.At(1, 1) = 1.; - m1.At(2, 2) = 1.; - - // m2 ist die Einheitsmatrix - Value m2(3, 3, 0); - m2.At(0, 0) = 1.; m2.At(0, 1) = 2.; m2.At(0, 2) = 3.; - m2.At(1, 0) = 4.; m2.At(1, 1) = 5.; m2.At(1, 2) = 6.; - m2.At(2, 0) = 7.; m2.At(2, 1) = 8.; m2.At(2, 2) = 9.; - - p1->DefineOprt(new DbgSillyAdd); - p1->DefineFun(new FunTest0); - - p1->DefineVar(_T("a"), Variable(&vVarVal[0])); - p1->DefineVar(_T("b"), Variable(&vVarVal[1])); - p1->DefineVar(_T("c"), Variable(&vVarVal[2])); - p1->DefineVar(_T("d"), Variable(&vVarVal[3])); - p1->DefineVar(_T("f"), Variable(&vVarVal[4])); - p1->DefineVar(_T("m1"), Variable(&m1)); - p1->DefineVar(_T("m2"), Variable(&m2)); - - // Add constants - p1->DefineConst(_T("const"), 1.); - p1->DefineConst(_T("const1"), 2.); - p1->DefineConst(_T("const2"), 3.); - - // some vector variables - Value aVal1(3, 0); - aVal1.At(0) = (float_type)1.0; - aVal1.At(1) = (float_type)2.0; - aVal1.At(2) = (float_type)3.0; - - Value aVal2(3, 0); - aVal2.At(0) = (float_type)4.0; - aVal2.At(1) = (float_type)3.0; - aVal2.At(2) = (float_type)2.0; - p1->DefineVar(_T("va"), Variable(&aVal1)); - p1->DefineVar(_T("vb"), Variable(&aVal2)); - - // complex variables - Value cVal[3]; - cVal[0] = mup::cmplx_type(1, 1); - cVal[1] = mup::cmplx_type(2, 3); - cVal[2] = mup::cmplx_type(3, 4); - p1->DefineVar(_T("ca"), Variable(&cVal[0])); - p1->DefineVar(_T("cb"), Variable(&cVal[1])); - p1->DefineVar(_T("cc"), Variable(&cVal[2])); - - p1->SetExpr(a_str); - - fVal[0] = p1->Eval(); - - // Test copy and assignement operators - std::vector vParser; - vParser.push_back(*p1); // Push p1 into the vector - ParserX p2 = vParser[0]; // take parser from vector - - // destroy the originals from p2 - vParser.clear(); // delete the vector - p1.reset(0); // delete the original - - fVal[1] = p2.Eval(); // If copy constructions does not work - // we may see a crash here - - // Test assignement operator - // additionally disable Optimizer this time - ParserX p3; - p3 = p2; - fVal[2] = p3.Eval(); // If assignment does not work - // we may see a crash here - - // Calculating a second time will parse from rpn rather than from - // string. The result must be the same... - fVal[3] = p3.Eval(); - - // Calculate yet another time. There is the possibility of - // changing variables as a side effect of expression - // evaluation. So there are really bugs that could make this fail... - fVal[4] = p3.Eval(); - - // Check i number of used variables is correct - if (nExprVar != -1) - { - std::size_t n2 = p2.GetExprVar().size(); - std::size_t n3 = p3.GetExprVar().size(); - - if (n2 + n3 != 2 * n2 || int(n2) != nExprVar) - { - *m_stream << _T(" Number of expression variables is incorrect. (expected: ") - << nExprVar << _T("; detected: ") << n2 << _T(")"); - } - } - - // Check the three results - // 1.) computed results must have identic type - char_type cType = fVal[0].GetType(); - bool bStat = cType == fVal[1].GetType() && - cType == fVal[2].GetType() && - cType == fVal[3].GetType() && - cType == fVal[4].GetType(); - if (!bStat) - { - *m_stream << _T("\n ") << a_str << _T(" : inconsistent result type (") - << fVal[0].GetType() << _T(", ") - << fVal[1].GetType() << _T(", ") - << fVal[2].GetType() << _T(", ") - << fVal[3].GetType() << _T(", ") - << fVal[4].GetType() << _T(")"); - return 1; - } - - if ((cType == 'c' || a_val.GetType() == 'c') && cType != a_val.GetType()) - { - *m_stream << _T("\n ") << a_str << _T(" : Complex value sliced!"); - return 1; - } - - // Compare the results - switch (cType) - { - case 'i': - case 'b': - case 's': bStat = (a_val == fVal[0] && - a_val == fVal[1] && - a_val == fVal[2] && - a_val == fVal[3] && - a_val == fVal[4]); - break; - - // We need more attention for comaring float values due to floating point - // inaccuracies. - case 'f': - { - bStat = true; - int num = sizeof(fVal) / sizeof(Value); - for (int i = 0; i < num; ++i) - bStat &= (fabs(a_val.GetFloat() - fVal[i].GetFloat()) <= fabs(fVal[i].GetFloat()*0.0001)); - } - break; - - case 'c': - { - bStat = true; - int num = sizeof(fVal) / sizeof(Value); - for (int i = 0; i < num; ++i) - { - bStat &= (fabs(a_val.GetFloat() - fVal[i].GetFloat()) <= std::max((float_type)1e-15, fabs(fVal[i].GetFloat() * (float_type)0.0000001))); - bStat &= (fabs(a_val.GetImag() - fVal[i].GetImag()) <= std::max((float_type)1e-15, fabs(fVal[i].GetImag() * (float_type)0.0000001))); - } - } - break; - - case 'm': - { - bStat = true; - int num = sizeof(fVal) / sizeof(Value); - - for (int i = 0; i < num; ++i) - { - struct CheckArray - { - CheckArray() - {} - - bool Check(IValue &v1, IValue &v2) - { - if (v1.GetType() != v2.GetType()) - return false; - - if (v1.GetRows() != v2.GetRows()) - return false; - - if (v1.IsMatrix()) - { - for (int i = 0; i < v1.GetRows(); ++i) - { - for (int j = 0; j < v1.GetCols(); ++j) - { - if (!Check(v1.At(i, j), v2.At(i, j))) - return false; - } - } - - return true; - } - else - { - return (fabs(v1.GetFloat() - v2.GetFloat()) <= std::max((float_type)1e-15, fabs(v1.GetFloat() * (float_type)0.0000001))); - } - } - } checker; - - bStat = checker.Check(a_val, fVal[i]); - if (!bStat) - break; - } - } - break; - - default: - throw std::runtime_error("Parser return value has an unexpected typecode."); - } - - iRet = (bStat == a_fPass) ? 0 : 1; - } - catch (ParserError &e) - { - *m_stream << _T("\n ") << a_str << _T(" : ") << e.GetMsg(); - return 1; - } - catch (std::exception &e) - { - *m_stream << _T("\n ") << a_str << _T(" : ") << e.what() << _T("\n"); - return 1; - } - catch (...) - { - *m_stream << _T("\n \"") << a_str << _T("\" : ") << _T("Unexpected Eception"); - return 1; - } - - if (iRet) - { - *m_stream << _T("\n ") << a_str << _T(" : ") << _T("(at least one incorrect result ") - << fVal[0] << _T(", ") - << fVal[1] << _T(", ") - << fVal[2] << _T(", ") - << fVal[3] << _T(", ") - << fVal[4] << _T("; expected=") << a_val << _T(")"); - } - - return iRet; -} - -//--------------------------------------------------------------------------- -/** \brief Internal error in test class Test is going to be aborted. */ -void ParserTester::Abort() const -{ - *m_stream << _T("\nTest failed (internal error in test class)") << endl; - while (!getchar()); - exit(-1); -} - -//--------------------------------------------------------------------------- -void ParserTester::Assessment(int a_iNumErr) const -{ - if (a_iNumErr == 0) - *m_stream << _T("passed") << endl; - else - *m_stream << _T("\n failed with ") << a_iNumErr << _T(" errors") << endl; -} -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpTokenReader.cpp b/src/third-party/headers/muparserx/mpTokenReader.cpp deleted file mode 100644 index 87b698644d..0000000000 --- a/src/third-party/headers/muparserx/mpTokenReader.cpp +++ /dev/null @@ -1,1013 +0,0 @@ -/** \file - \brief Implementation of the token reader used to break the expression string up - into tokens. - -
          -				__________                                 ____  ___
          -	 _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -	/     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
          -	|  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
          -	|__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -		  \/                     \/           \/     \/           \_/
          -	Copyright (C) 2016, Ingo Berg
          -	All rights reserved.
          -
          -	Redistribution and use in source and binary forms, with or without
          -	modification, are permitted provided that the following conditions are met:
          -
          -	* Redistributions of source code must retain the above copyright notice,
          -	this list of conditions and the following disclaimer.
          -	* Redistributions in binary form must reproduce the above copyright notice,
          -	this list of conditions and the following disclaimer in the documentation
          -	and/or other materials provided with the distribution.
          -
          -	THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
          -	ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
          -	WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
          -	IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
          -	INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
          -	NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
          -	PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
          -	WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
          -	ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
          -	POSSIBILITY OF SUCH DAMAGE.
          -	
          - */ - -#include "mpTokenReader.h" - -#include - -#include "mpParserBase.h" -#include "mpIValReader.h" -#include "mpIfThenElse.h" -#include "mpScriptTokens.h" -#include "mpOprtIndex.h" -#include "mpOprtMatrix.h" - -MUP_NAMESPACE_START - -//--------------------------------------------------------------------------- -/** \brief Copy constructor. - \sa Assign - \throw nothrow - */ - TokenReader::TokenReader(const TokenReader &a_Reader) -{ - Assign(a_Reader); -} - -//--------------------------------------------------------------------------- -/** \brief Assignement operator. - \param a_Reader Object to copy to this token reader. - \throw nothrow - - Self assignement will be suppressed otherwise #Assign is called. - */ -TokenReader& TokenReader::operator=(const TokenReader &a_Reader) -{ - if (&a_Reader != this) - Assign(a_Reader); - - return *this; -} - -//--------------------------------------------------------------------------- -/** \brief Assign state of a token reader to this token reader. - \param a_Reader Object from which the state should be copied. - \throw nothrow - */ -void TokenReader::Assign(const TokenReader &obj) -{ - m_pParser = obj.m_pParser; - m_sExpr = obj.m_sExpr; - m_nPos = obj.m_nPos; - m_nNumBra = obj.m_nNumBra; - m_nNumIndex = obj.m_nNumIndex; - m_nNumCurly = obj.m_nNumCurly; - m_nNumIfElse = obj.m_nNumIfElse; - m_nSynFlags = obj.m_nSynFlags; - m_UsedVar = obj.m_UsedVar; - m_pVarDef = obj.m_pVarDef; - m_pPostOprtDef = obj.m_pPostOprtDef; - m_pInfixOprtDef = obj.m_pInfixOprtDef; - m_pOprtDef = obj.m_pOprtDef; - m_pFunDef = obj.m_pFunDef; - m_pConstDef = obj.m_pConstDef; - m_pDynVarShadowValues = obj.m_pDynVarShadowValues; - m_vTokens = obj.m_vTokens; - - // Reader klassen klonen - DeleteValReader(); - std::size_t i, iSize = obj.m_vValueReader.size(); - for (i = 0; i < iSize; ++i) - { - m_vValueReader.push_back(obj.m_vValueReader[i]->Clone(this)); - } -} - -//--------------------------------------------------------------------------- -/** \brief Constructor. - - Create a Token reader and bind it to a parser object. - - \pre [assert] a_pParser may not be nullptr - \post #m_pParser==a_pParser - \param a_pParent Parent parser object of the token reader. - */ -TokenReader::TokenReader(ParserXBase *a_pParent) - :m_pParser(a_pParent) - , m_sExpr() - , m_nPos(0) - , m_nNumBra(0) - , m_nNumIndex(0) - , m_nNumCurly(0) - , m_nNumIfElse(0) - , m_nSynFlags(0) - , m_vTokens() - , m_eLastTokCode(cmUNKNOWN) - , m_pFunDef(nullptr) - , m_pOprtDef(nullptr) - , m_pInfixOprtDef(nullptr) - , m_pPostOprtDef(nullptr) - , m_pConstDef(nullptr) - , m_pDynVarShadowValues(nullptr) - , m_pVarDef(nullptr) - , m_vValueReader() - , m_UsedVar() - , m_fZero(0) -{ - assert(m_pParser); - SetParent(m_pParser); -} - -//--------------------------------------------------------------------------- -/** \brief Destructor (trivial). - - \throw nothrow - */ -TokenReader::~TokenReader() -{ - DeleteValReader(); -} - -//--------------------------------------------------------------------------- -void TokenReader::DeleteValReader() -{ - int iSize = (int)m_vValueReader.size(); - for (int i = 0; i < iSize; ++i) - delete m_vValueReader[i]; - - m_vValueReader.clear(); -} - -//--------------------------------------------------------------------------- -/** \brief Create instance of a ParserTokenReader identical with this - and return its pointer. - - This is a factory method the calling function must take care of the object destruction. - - \return A new ParserTokenReader object. - \throw nothrow - */ -TokenReader* TokenReader::Clone(ParserXBase *a_pParent) const -{ - std::unique_ptr ptr(new TokenReader(*this)); - ptr->SetParent(a_pParent); - return ptr.release(); -} - -//--------------------------------------------------------------------------- -void TokenReader::AddValueReader(IValueReader *a_pReader) -{ - a_pReader->SetParent(this); - m_vValueReader.push_back(a_pReader); -} - -//--------------------------------------------------------------------------- -void TokenReader::AddSynFlags(int flag) -{ - m_nSynFlags |= flag; -} - -//--------------------------------------------------------------------------- -const TokenReader::token_buf_type& TokenReader::GetTokens() const -{ - return m_vTokens; -} - -//--------------------------------------------------------------------------- -/** \brief Return the current position of the token reader in the formula string. - - \return #m_nPos - \throw nothrow - */ -int TokenReader::GetPos() const -{ - return m_nPos; -} - -//--------------------------------------------------------------------------- -/** \brief Return a reference to the formula. - - \return #m_sExpr - \throw nothrow - */ -const string_type& TokenReader::GetExpr() const -{ - return m_sExpr; -} - -//--------------------------------------------------------------------------- -/** \brief Return a map containing the used variables only. */ -const var_maptype& TokenReader::GetUsedVar() const -{ - return m_UsedVar; -} - -//--------------------------------------------------------------------------- -/** \brief Initialize the token Reader. - - Sets the expression position index to zero and set Syntax flags to - default for initial parsing. - */ -void TokenReader::SetExpr(const string_type &a_sExpr) -{ - m_sExpr = a_sExpr; // + string_type(_T(" ")); - ReInit(); -} - -//--------------------------------------------------------------------------- -/** \brief Reset the token reader to the start of the formula. - \post #m_nPos==0, #m_nSynFlags = noOPT | noBC | noPOSTOP | noSTR - \throw nothrow - \sa ESynCodes - - The syntax flags will be reset to a value appropriate for the - start of a formula. - */ -void TokenReader::ReInit() -{ - m_nPos = 0; - m_nNumBra = 0; - m_nNumIndex = 0; - m_nNumCurly = 0; - m_nNumIfElse = 0; - m_nSynFlags = noOPT | noBC | noCBC | noPFX | noCOMMA | noIO | noIC | noIF | noELSE; - m_UsedVar.clear(); - m_eLastTokCode = cmUNKNOWN; - m_vTokens.clear(); -} - -//--------------------------------------------------------------------------- -const ptr_tok_type& TokenReader::Store(const ptr_tok_type &t, int token_pos) -{ - m_eLastTokCode = t->GetCode(); - t->SetExprPos(token_pos); - m_vTokens.push_back(t); - return t; -} - -//--------------------------------------------------------------------------- -void TokenReader::SkipCommentsAndWhitespaces() -{ - bool bSkip = true; - while (m_nPos < static_cast(m_sExpr.length()) && bSkip) - { - switch (m_sExpr[m_nPos]) - { - // skip comments - case '#': - { - std::size_t i = m_sExpr.find_first_of('\n', m_nPos + 1); - m_nPos = static_cast((i != string_type::npos) ? i : m_sExpr.length()); - } - break; - - // skip whitespaces - case ' ': - ++m_nPos; - break; - - default: - bSkip = false; - } // switch - } // while comment or whitespace -} - -//--------------------------------------------------------------------------- -/** \brief Read the next token from the string. */ -ptr_tok_type TokenReader::ReadNextToken() -{ - assert(m_pParser); - - SkipCommentsAndWhitespaces(); - - int token_pos = m_nPos; - ptr_tok_type pTok; - - // Check for end of expression - if (IsEOF(pTok)) - return Store(pTok, token_pos); - - if (IsNewline(pTok)) - return Store(pTok, token_pos); - - if (!(m_nSynFlags & noOPT) && IsOprt(pTok)) - return Store(pTok, token_pos); // Check for user defined binary operator - - if (!(m_nSynFlags & noIFX) && IsInfixOpTok(pTok)) - return Store(pTok, token_pos); // Check for unary operators - - if (IsValTok(pTok)) - return Store(pTok, token_pos); // Check for values / constant tokens - - if (IsBuiltIn(pTok)) - return Store(pTok, token_pos); // Check built in operators / tokens - - if (IsVarOrConstTok(pTok)) - return Store(pTok, token_pos); // Check for variable tokens - - if (IsFunTok(pTok)) - return Store(pTok, token_pos); - - if (!(m_nSynFlags & noPFX) && IsPostOpTok(pTok)) - return Store(pTok, token_pos); // Check for unary operators - - // 2.) We have found no token, maybe there is a token that we don't expect here. - // Again call the Identifier functions but this time only those we don't expect - // to find. - if ((m_nSynFlags & noOPT) && IsOprt(pTok)) - return Store(pTok, token_pos); // Check for user defined binary operator - - if ((m_nSynFlags & noIFX) && IsInfixOpTok(pTok)) - return Store(pTok, token_pos); // Check for unary operators - - if ((m_nSynFlags & noPFX) && IsPostOpTok(pTok)) - return Store(pTok, token_pos); // Check for unary operators - // - - // Now we are in trouble because there is something completely unknown.... - - // Check the string for an undefined variable token. This is done - // only if a flag is set indicating to ignore undefined variables. - // This is a way to conditionally avoid an error if undefined variables - // occur. The GetExprVar function must supress the error for undefined - // variables in order to collect all variable names including the - // undefined ones. - if ((m_pParser->m_bIsQueryingExprVar || m_pParser->m_bAutoCreateVar) && IsUndefVarTok(pTok)) - return Store(pTok, token_pos); - - // Check for unknown token - // - // !!! From this point on there is no exit without an exception possible... - // - string_type sTok; - int iEnd = ExtractToken(m_pParser->ValidNameChars(), sTok, m_nPos); - - ErrorContext err; - err.Errc = ecUNASSIGNABLE_TOKEN; - err.Expr = m_sExpr; - err.Pos = m_nPos; - - if (iEnd != m_nPos) - err.Ident = sTok; - else - err.Ident = m_sExpr.substr(m_nPos); - - throw ParserError(err); -} - -//--------------------------------------------------------------------------- -void TokenReader::SetParent(ParserXBase *a_pParent) -{ - m_pParser = a_pParent; - m_pFunDef = &a_pParent->m_FunDef; - m_pOprtDef = &a_pParent->m_OprtDef; - m_pInfixOprtDef = &a_pParent->m_InfixOprtDef; - m_pPostOprtDef = &a_pParent->m_PostOprtDef; - m_pVarDef = &a_pParent->m_varDef; - m_pConstDef = &a_pParent->m_valDef; - m_pDynVarShadowValues = &a_pParent->m_valDynVarShadow; -} - -//--------------------------------------------------------------------------- -/** \brief Extract all characters that belong to a certain charset. - \param a_szCharSet [in] Const char array of the characters allowed in the token. - \param a_strTok [out] The string that consists entirely of characters listed in a_szCharSet. - \param a_iPos [in] Position in the string from where to start reading. - \return The Position of the first character not listed in a_szCharSet. - \throw nothrow - */ -int TokenReader::ExtractToken(const char_type *a_szCharSet, - string_type &a_sTok, - int a_iPos) const -{ - int iEnd = (int)m_sExpr.find_first_not_of(a_szCharSet, a_iPos); - - if (iEnd == (int)string_type::npos) - iEnd = (int)m_sExpr.length(); - - if (iEnd != a_iPos) - a_sTok.assign(m_sExpr.begin() + a_iPos, m_sExpr.begin() + iEnd); - - return iEnd; -} - -//--------------------------------------------------------------------------- -/** \brief Check if a built in operator or other token can be found. -*/ -bool TokenReader::IsBuiltIn(ptr_tok_type &a_Tok) -{ - const char_type **pOprtDef = m_pParser->GetOprtDef(), - *szFormula = m_sExpr.c_str(); - int i; - - try - { - // Compare token with function and operator strings - // check string for operator/function - for (i = 0; pOprtDef[i]; i++) - { - std::size_t len(std::char_traits::length(pOprtDef[i])); - if (string_type(pOprtDef[i]) == string_type(szFormula + m_nPos, szFormula + m_nPos + len)) - { - switch (i) - { - case cmARG_SEP: - if (m_nSynFlags & noCOMMA) - throw ecUNEXPECTED_COMMA; - - m_nSynFlags = noBC | noCBC | noOPT | noEND | noNEWLINE | noCOMMA | noPFX | noIC | noIO | noIF | noELSE; - a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); - break; - - case cmELSE: - if (m_nSynFlags & noELSE) - throw ecMISPLACED_COLON; - - m_nNumIfElse--; - if (m_nNumIfElse < 0) - throw ecMISPLACED_COLON; - - m_nSynFlags = noBC | noCBC | noIO | noIC | noPFX | noEND | noNEWLINE | noCOMMA | noOPT | noIF | noELSE; - a_Tok = ptr_tok_type(new TokenIfThenElse(cmELSE)); - break; - - case cmIF: - if (m_nSynFlags & noIF) - throw ecUNEXPECTED_CONDITIONAL; - - m_nNumIfElse++; - m_nSynFlags = noBC | noCBC | noIO | noPFX | noIC | noEND | noNEWLINE | noCOMMA | noOPT | noIF | noELSE; - a_Tok = ptr_tok_type(new TokenIfThenElse(cmIF)); - break; - - case cmBO: - if (m_nSynFlags & noBO) - throw ecUNEXPECTED_PARENS; - - if (m_eLastTokCode == cmFUNC) - { - m_nSynFlags = noOPT | noEND | noNEWLINE | noCOMMA | noPFX | noIC | noIO | noIF | noELSE | noCBC; - } - else - { - m_nSynFlags = noBC | noOPT | noEND | noNEWLINE | noCOMMA | noPFX | noIC | noIO | noIF | noELSE | noCBC; - } - - m_nNumBra++; - a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); - break; - - case cmBC: - if (m_nSynFlags & noBC) - throw ecUNEXPECTED_PARENS; - - m_nSynFlags = noBO | noVAR | noVAL | noFUN | noIFX | noCBO; - m_nNumBra--; - - if (m_nNumBra < 0) - throw ecUNEXPECTED_PARENS; - - a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); - break; - - case cmIO: - if (m_nSynFlags & noIO) - throw ecUNEXPECTED_SQR_BRACKET; - - m_nSynFlags = noIC | noIO | noOPT | noPFX | noBC | noNEWLINE | noCBC | noCOMMA; - m_nNumIndex++; - a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); - break; - - case cmIC: - if (m_nSynFlags & noIC) - throw ecUNEXPECTED_SQR_BRACKET; - - m_nSynFlags = noBO | noIFX | noCBO; - m_nNumIndex--; - - if (m_nNumIndex < 0) - throw ecUNEXPECTED_SQR_BRACKET; - - a_Tok = ptr_tok_type(new OprtIndex()); - break; - - case cmCBO: - if (m_nSynFlags & noVAL) - throw ecUNEXPECTED_CURLY_BRACKET; - - m_nSynFlags = noCBC | noIC | noIO | noOPT | noPFX | noBC | noNEWLINE | noCOMMA | noIF; - m_nNumCurly++; - a_Tok = ptr_tok_type(new GenericToken((ECmdCode)i, pOprtDef[i])); - break; - - case cmCBC: - if (m_nSynFlags & noIC) - throw ecUNEXPECTED_CURLY_BRACKET; - - m_nSynFlags = noBO | noCBO | noIFX; - m_nNumCurly--; - - if (m_nNumCurly < 0) - throw ecUNEXPECTED_CURLY_BRACKET; - - a_Tok = ptr_tok_type(new OprtCreateArray()); - break; - - default: // The operator is listed in c_DefaultOprt, but not here. This is a bad thing... - throw ecINTERNAL_ERROR; - } // switch operator id - - m_nPos += (int)len; - return true; - } // if operator string found - } // end of for all operator strings - } - catch (EErrorCodes e) - { - ErrorContext err; - err.Errc = e; - err.Expr = m_sExpr; - err.Ident = pOprtDef[i]; - err.Pos = m_nPos; - throw ParserError(err); - } - - return false; -} - -//--------------------------------------------------------------------------- -/** \brief Check for End of expression -*/ -bool TokenReader::IsNewline(ptr_tok_type &a_Tok) -{ - // nicht nach: bionop, infixop, argumentseparator, - // erlaubt nach: Werten, variablen, schließenden klammern, schliessendem index - bool bRet(false); - try - { - if (m_sExpr[m_nPos] == '\n') - { - // Check if all brackets were closed - if (m_nSynFlags & noNEWLINE) - throw ecUNEXPECTED_NEWLINE; - - if (m_nNumBra > 0) - throw ecMISSING_PARENS; - - if (m_nNumIndex > 0) - throw ecMISSING_SQR_BRACKET; - - if (m_nNumCurly > 0) - throw ecMISSING_CURLY_BRACKET; - - if (m_nNumIfElse > 0) - throw(ecMISSING_ELSE_CLAUSE); - - m_nPos++; - m_nSynFlags = sfSTART_OF_LINE; - a_Tok = ptr_tok_type(new TokenNewline()); - bRet = true; - } - } - catch (EErrorCodes e) - { - ErrorContext err; - err.Errc = e; - err.Ident = _T(""); - err.Expr = m_sExpr; - err.Pos = m_nPos; - throw ParserError(err); - } - - return bRet; -} - -//--------------------------------------------------------------------------- -/** \brief Check for End of expression -*/ -bool TokenReader::IsEOF(ptr_tok_type &a_Tok) -{ - bool bRet(false); - try - { - if (m_sExpr.length() && m_nPos >= (int)m_sExpr.length()) - { - if (m_nSynFlags & noEND) - throw ecUNEXPECTED_EOF; - - if (m_nNumBra > 0) - throw ecMISSING_PARENS; - - if (m_nNumCurly > 0) - throw ecMISSING_CURLY_BRACKET; - - if (m_nNumIndex > 0) - throw ecMISSING_SQR_BRACKET; - - if (m_nNumIfElse > 0) - throw ecMISSING_ELSE_CLAUSE; - - m_nSynFlags = 0; - a_Tok = ptr_tok_type(new GenericToken(cmEOE)); - bRet = true; - } - } - catch (EErrorCodes e) - { - ErrorContext err; - err.Errc = e; - err.Ident = _T(""); - err.Expr = m_sExpr; - err.Pos = m_nPos; - throw ParserError(err); - } - - return bRet; -} - -//--------------------------------------------------------------------------- -/** \brief Check if a string position contains a unary infix operator. - \return true if a function token has been found false otherwise. - */ -bool TokenReader::IsInfixOpTok(ptr_tok_type &a_Tok) -{ - string_type sTok; - int iEnd = ExtractToken(m_pParser->ValidInfixOprtChars(), sTok, m_nPos); - - if (iEnd == m_nPos) - return false; - - try - { - // iteraterate over all infix operator strings - oprt_ifx_maptype::const_iterator item = m_pInfixOprtDef->begin(); - for (item = m_pInfixOprtDef->begin(); item != m_pInfixOprtDef->end(); ++item) - { - if (sTok.find(item->first) != 0) - continue; - - a_Tok = ptr_tok_type(item->second->Clone()); - m_nPos += (int)item->first.length(); - - if (m_nSynFlags & noIFX) - throw ecUNEXPECTED_OPERATOR; - - m_nSynFlags = noPFX | noIFX | noOPT | noBC | noIC | noIO | noEND | noCOMMA | noNEWLINE | noIF | noELSE; - return true; - } - - return false; - } - catch (EErrorCodes e) - { - ErrorContext err; - err.Errc = e; - err.Pos = m_nPos; - err.Ident = a_Tok->GetIdent(); - err.Expr = m_sExpr; - throw ParserError(err); - } -} - -//--------------------------------------------------------------------------- -/** \brief Check expression for function tokens. */ -bool TokenReader::IsFunTok(ptr_tok_type &a_Tok) -{ - if (m_pFunDef->size() == 0) - return false; - - string_type sTok; - int iEnd = ExtractToken(m_pParser->ValidNameChars(), sTok, m_nPos); - if (iEnd == m_nPos) - return false; - - try - { - fun_maptype::iterator item = m_pFunDef->find(sTok); - if (item == m_pFunDef->end()) - return false; - - m_nPos = (int)iEnd; - a_Tok = ptr_tok_type(item->second->Clone()); - a_Tok->Compile(_T("xxx")); - - if (m_nSynFlags & noFUN) - throw ecUNEXPECTED_FUN; - - m_nSynFlags = sfALLOW_NONE ^ noBO; - return true; - } - catch (EErrorCodes e) - { - ErrorContext err; - err.Errc = e; - err.Pos = m_nPos - (int)a_Tok->GetIdent().length(); - err.Ident = a_Tok->GetIdent(); - err.Expr = m_sExpr; - throw ParserError(err); - } -} - -//--------------------------------------------------------------------------- -/** \brief Check if a string position contains a unary post value operator. */ -bool TokenReader::IsPostOpTok(ptr_tok_type &a_Tok) -{ - if (m_nSynFlags & noPFX) - { - // Only look for postfix operators if they are allowed at the given position. - // This will prevent conflicts with variable names such as: - // "sin(n)" where n is the postfix for "nano" - return false; - // - } - - // Tricky problem with equations like "3m+5": - // m is a postfix operator, + is a valid sign for postfix operators and - // for binary operators parser detects "m+" as operator string and - // finds no matching postfix operator. - // - // This is a special case so this routine slightly differs from the other - // token readers. - - // Test if there could be a postfix operator - string_type sTok; - int iEnd = ExtractToken(m_pParser->ValidOprtChars(), sTok, m_nPos); - if (iEnd == m_nPos) - return false; - - try - { - // iteraterate over all postfix operator strings - oprt_pfx_maptype::const_iterator item; - for (item = m_pPostOprtDef->begin(); item != m_pPostOprtDef->end(); ++item) - { - if (sTok.find(item->first) != 0) - continue; - - a_Tok = ptr_tok_type(item->second->Clone()); - m_nPos += (int)item->first.length(); - - if (m_nSynFlags & noPFX) - throw ecUNEXPECTED_OPERATOR; - - m_nSynFlags = noVAL | noVAR | noFUN | noBO | noPFX /*| noIO*/ | noIF; - return true; - } - - return false; - } - catch (EErrorCodes e) - { - ErrorContext err; - err.Errc = e; - err.Pos = m_nPos - (int)a_Tok->GetIdent().length(); - err.Ident = a_Tok->GetIdent(); - err.Expr = m_sExpr; - throw ParserError(err); - } -} - -//--------------------------------------------------------------------------- -/** \brief Check if a string position contains a binary operator. */ -bool TokenReader::IsOprt(ptr_tok_type &a_Tok) -{ - string_type sTok; - int iEnd = ExtractToken(m_pParser->ValidOprtChars(), sTok, m_nPos); - if (iEnd == m_nPos) - return false; - - oprt_bin_maptype::reverse_iterator item; - try - { - // Note: - // All tokens in oprt_bin_maptype are have been sorted by their length - // Long operators must come first! Otherwise short names (like: "add") that - // are part of long token names (like: "add123") will be found instead - // of the long ones. - // Length sorting is done with ascending length so we use a reverse iterator here. - for (item = m_pOprtDef->rbegin(); item != m_pOprtDef->rend(); ++item) - { - if (sTok.find(item->first) != 0) - continue; - - // operator found, check if we expect one... - if (m_nSynFlags & noOPT) - { - // An operator was found but is not expected to occur at - // this position of the formula, maybe it is an infix - // operator, not a binary operator. Both operator types - // can use the same characters in their identifiers. - if (IsInfixOpTok(a_Tok)) - return true; - - // nope, it's no infix operator and we dont expect - // an operator - throw ecUNEXPECTED_OPERATOR; - } - else - { - a_Tok = ptr_tok_type(item->second->Clone()); - - m_nPos += (int)a_Tok->GetIdent().length(); - m_nSynFlags = noBC | noIO | noIC | noOPT | noCOMMA | noEND | noNEWLINE | noPFX | noIF | noELSE; - return true; - } - } - - return false; - } - catch (EErrorCodes e) - { - ErrorContext err; - err.Errc = e; - err.Pos = m_nPos; // - (int)item->first.length(); - err.Ident = item->first; - err.Expr = m_sExpr; - throw ParserError(err); - } -} - -//--------------------------------------------------------------------------- -/** \brief Check whether the token at a given position is a value token. - - Value tokens are either values or constants. - - \param a_Tok [out] If a value token is found it will be placed here. - \return true if a value token has been found. - */ -bool TokenReader::IsValTok(ptr_tok_type &a_Tok) -{ - if (m_vValueReader.size() == 0) - return false; - - stringstream_type stream(m_sExpr.c_str() + m_nPos); - string_type sTok; - - try - { - // call the value recognition functions provided by the user - // Call user defined value recognition functions - int iSize = (int)m_vValueReader.size(); - Value val; - for (int i = 0; i < iSize; ++i) - { - int iStart = m_nPos; - if (m_vValueReader[i]->IsValue(m_sExpr.c_str(), m_nPos, val)) - { - sTok.assign(m_sExpr.c_str(), iStart, m_nPos); - if (m_nSynFlags & noVAL) - throw ecUNEXPECTED_VAL; - - m_nSynFlags = noVAL | noVAR | noFUN | noBO | noIFX | noIO; - a_Tok = ptr_tok_type(val.Clone()); - a_Tok->SetIdent(string_type(sTok.begin(), sTok.begin() + (m_nPos - iStart))); - return true; - } - } - } - catch (EErrorCodes e) - { - ErrorContext err; - err.Errc = e; - err.Pos = m_nPos; - err.Ident = sTok; - err.Expr = m_sExpr; - err.Pos = m_nPos - (int)sTok.length(); - throw ParserError(err); - } - - return false; -} - -//--------------------------------------------------------------------------- -/** \brief Check wheter a token at a given position is a variable token. - \param a_Tok [out] If a variable token has been found it will be placed here. - \return true if a variable token has been found. - */ -bool TokenReader::IsVarOrConstTok(ptr_tok_type &a_Tok) -{ - if (!m_pVarDef->size() && !m_pConstDef->size() && !m_pFunDef->size()) - return false; - - string_type sTok; - int iEnd; - try - { - iEnd = ExtractToken(m_pParser->ValidNameChars(), sTok, m_nPos); - if (iEnd == m_nPos || (sTok.size() > 0 && sTok[0] >= _T('0') && sTok[0] <= _T('9'))) - return false; - - // Check for variables - var_maptype::const_iterator item = m_pVarDef->find(sTok); - if (item != m_pVarDef->end()) - { - if (m_nSynFlags & noVAR) - throw ecUNEXPECTED_VAR; - - m_nPos = iEnd; - m_nSynFlags = noVAL | noVAR | noFUN | noBO | noIFX; - a_Tok = ptr_tok_type(item->second->Clone()); - a_Tok->SetIdent(sTok); - m_UsedVar[item->first] = item->second; // Add variable to used-var-list - return true; - } - - // Check for constants - item = m_pConstDef->find(sTok); - if (item != m_pConstDef->end()) - { - if (m_nSynFlags & noVAL) - throw ecUNEXPECTED_VAL; - - m_nPos = iEnd; - m_nSynFlags = noVAL | noVAR | noFUN | noBO | noIFX | noIO; - a_Tok = ptr_tok_type(item->second->Clone()); - a_Tok->SetIdent(sTok); - return true; - } - } - catch (EErrorCodes e) - { - ErrorContext err; - err.Errc = e; - err.Pos = m_nPos; - err.Ident = sTok; - err.Expr = m_sExpr; - throw ParserError(err); - } - - return false; -} - -//--------------------------------------------------------------------------- -bool TokenReader::IsComment() -{ - return false; -} - -//--------------------------------------------------------------------------- -/** \brief Check wheter a token at a given position is an undefined variable. - \param a_Tok [out] If a variable tom_pParser->m_vStringBufken has been found it will be placed here. - \return true if a variable token has been found. - \throw nothrow - */ -bool TokenReader::IsUndefVarTok(ptr_tok_type &a_Tok) -{ - string_type sTok; - int iEnd = ExtractToken(m_pParser->ValidNameChars(), sTok, m_nPos); - if (iEnd == m_nPos || (sTok.size() > 0 && sTok[0] >= _T('0') && sTok[0] <= _T('9'))) - return false; - - if (m_nSynFlags & noVAR) - { - ErrorContext err; - err.Errc = ecUNEXPECTED_VAR; - err.Ident = sTok; - err.Expr = m_sExpr; - err.Pos = m_nPos; - throw ParserError(err); - } - - // Create a variable token - if (m_pParser->m_bAutoCreateVar) - { - ptr_val_type val(new Value); // Create new value token - m_pDynVarShadowValues->push_back(val); // push to the vector of shadow values - a_Tok = ptr_tok_type(new Variable(val.Get())); // bind variable to the new value item - (*m_pVarDef)[sTok] = a_Tok; // add new variable to the variable list - } - else - a_Tok = ptr_tok_type(new Variable(nullptr)); // bind variable to empty variable - - a_Tok->SetIdent(sTok); - m_UsedVar[sTok] = a_Tok; // add new variable to used-var-list - - m_nPos = iEnd; - m_nSynFlags = noVAL | noVAR | noFUN | noBO | noIFX; - return true; -} -} // namespace mu diff --git a/src/third-party/headers/muparserx/mpValReader.cpp b/src/third-party/headers/muparserx/mpValReader.cpp deleted file mode 100644 index 8add7b0095..0000000000 --- a/src/third-party/headers/muparserx/mpValReader.cpp +++ /dev/null @@ -1,347 +0,0 @@ -/** \file - \brief Implementation of classes that interpret values in a string. - -
          -                 __________                                 ____  ___
          -      _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -     /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
          -    |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
          -    |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -          \/                     \/           \/     \/           \_/
          -    Copyright (C) 2016, Ingo Berg
          -    All rights reserved.
          -
          -    Redistribution and use in source and binary forms, with or without
          -    modification, are permitted provided that the following conditions are met:
          -
          -    * Redistributions of source code must retain the above copyright notice,
          -    this list of conditions and the following disclaimer.
          -    * Redistributions in binary form must reproduce the above copyright notice,
          -    this list of conditions and the following disclaimer in the documentation
          -    and/or other materials provided with the distribution.
          -
          -    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
          -    ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
          -    WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
          -    IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
          -    INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
          -    NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
          -    PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
          -    WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
          -    ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
          -    POSSIBILITY OF SUCH DAMAGE.
          -    
          - */ -#include "mpValReader.h" -#include "mpError.h" - - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------ -// -// Reader for floating point values -// -//------------------------------------------------------------------------------ - -DblValReader::DblValReader() -:IValueReader() -{} - -//------------------------------------------------------------------------------ -DblValReader::~DblValReader() -{} - -//------------------------------------------------------------------------------ -bool DblValReader::IsValue(const char_type *a_szExpr, int &a_iPos, Value &a_Val) -{ - stringstream_type stream(a_szExpr + a_iPos); - float_type fVal(0); - std::streamoff iEnd(0); - - stream >> fVal; - - if (stream.fail()) - return false; - - if (stream.eof()) - { - // This part sucks but tellg will return -1 if eof is set, - // so i need a special treatment for the case that the number - // just read here is the last part of the string - for (; a_szExpr[a_iPos] != 0; ++a_iPos); - } - else - { - iEnd = stream.tellg(); // Position after reading - assert(iEnd > 0); - a_iPos += (int)iEnd; - } - - // Finally i have to check if the next sign is the "i" for a imaginary unit - // if so this is an imaginary value - if (a_szExpr[a_iPos] == 'i') - { - a_Val = cmplx_type(0.0, fVal); - a_iPos++; - } - else - { - a_Val = cmplx_type(fVal, 0.0); - } - - return true; -} - -//------------------------------------------------------------------------------ -IValueReader* DblValReader::Clone(TokenReader *pTokenReader) const -{ - IValueReader *pReader = new DblValReader(*this); - pReader->SetParent(pTokenReader); - - return pReader; -} - -//------------------------------------------------------------------------------ -// -// Reader for boolean values -// -//------------------------------------------------------------------------------ - -BoolValReader::BoolValReader() - :IValueReader() -{} - -//------------------------------------------------------------------------------ -BoolValReader::~BoolValReader() -{} - -//------------------------------------------------------------------------------ -bool BoolValReader::IsValue(const char_type *a_szExpr, int &a_iPos, Value &a_Val) -{ - string_type sExpr(a_szExpr + a_iPos); - - if (sExpr.find(_T("true")) == 0) - { - a_Val = true; - a_iPos += 4; - return true; - } - else if (sExpr.find(_T("false")) == 0) - { - a_Val = false; - a_iPos += 5; - return true; - } - - return false; -} - -//------------------------------------------------------------------------------ -IValueReader* BoolValReader::Clone(TokenReader *pTokenReader) const -{ - IValueReader *pReader = new BoolValReader(*this); - pReader->SetParent(pTokenReader); - - return pReader; -} - -//------------------------------------------------------------------------------ -// -// Reader for hex values -// -//------------------------------------------------------------------------------ - -HexValReader::HexValReader() - :IValueReader() -{} - -//------------------------------------------------------------------------------ -/** \brief Try to read a hex value from a given position in the expression. - \param a_szExpr The Expression - \param [in/out] a_iPos The current position in the expression - \param [out] a_val The value that was read - - Hex values must start with a "0x" characters. The position a_iPos is advanded in case - a hex value was found. - */ -bool HexValReader::IsValue(const char_type *a_szExpr, int &a_iPos, Value &a_val) -{ - std::size_t len = std::char_traits::length(a_szExpr); - if (a_iPos >= (int)len || a_szExpr[a_iPos + 1] != 'x' || a_szExpr[a_iPos + 1] == 0 || a_szExpr[a_iPos] != '0') - return 0; - - unsigned iVal(0); - - stringstream_type::pos_type nPos(0); - stringstream_type ss(a_szExpr + a_iPos + 2); - ss >> std::hex >> iVal; - - if (ss.fail()) - return false; - - if (ss.eof()) - { - // This part sucks but tellg will return -1 if eof is set, - // so i need a special treatment for those cases. - for (; a_szExpr[a_iPos] != 0; ++a_iPos); - } - else - { - nPos = ss.tellg(); - assert(nPos > 0); - a_iPos += (int)(2 + nPos); - } - - a_val = (float_type)iVal; - return true; -} - -//------------------------------------------------------------------------------ -IValueReader* HexValReader::Clone(TokenReader *pTokenReader) const -{ - IValueReader *pReader = new HexValReader(*this); - pReader->SetParent(pTokenReader); - return pReader; -} - -//------------------------------------------------------------------------------ -// -// Reader for binary values -// -//------------------------------------------------------------------------------ - -BinValReader::BinValReader() - :IValueReader() -{} - -//------------------------------------------------------------------------------ -BinValReader::~BinValReader() -{} - -//------------------------------------------------------------------------------ -bool BinValReader::IsValue(const char_type *a_szExpr, int &a_iPos, Value &a_Val) -{ - const char_type *szExpr = a_szExpr + a_iPos; - - if (szExpr[0] != '0' || (szExpr[1] != 'b' && szExpr[1] != 'B')) - return false; - - // Number of bits hardcoded to 32, i can't - // store 64 bit integers in double values without - // loss. There is no point in accepting them. - unsigned iVal = 0, iBits = 32 /*sizeof(iVal)*8*/, i; - for (i = 0; (szExpr[i + 2] == '0' || szExpr[i + 2] == '1') && i <= iBits; ++i) - { - iVal |= (unsigned)(szExpr[i + 2] == '1') << ((iBits - 1) - i); - } - - if (i == 0) - return false; - - if (i > iBits) - { - throw ParserError(_T("Binary to integer conversion error (overflow).")); - } - - a_Val = (float_type)((int)(iVal >> (iBits - i))); - a_iPos += i + 2; - - return true; -} - -//------------------------------------------------------------------------------ -IValueReader* BinValReader::Clone(TokenReader *pTokenReader) const -{ - IValueReader *pReader = new BinValReader(*this); - pReader->SetParent(pTokenReader); - - return pReader; -} - -//------------------------------------------------------------------------------ -// -// Reader for string values -// -//------------------------------------------------------------------------------ - -StrValReader::StrValReader() - :IValueReader() -{} - -//------------------------------------------------------------------------------ -StrValReader::~StrValReader() -{} - -//------------------------------------------------------------------------------ -string_type StrValReader::Unescape(const char_type *szExpr, int &nPos) -{ - string_type out; - bool bEscape = false; - - for (char_type c = szExpr[nPos]; c != 0; c = szExpr[++nPos]) - { - switch (c) - { - case '\\': - if (!bEscape) - { - bEscape = true; - break; - } - [[gnu::fallthrough]]; - - case '"': - if (!bEscape) - { - ++nPos; - return out; - } - [[gnu::fallthrough]]; - - default: - if (bEscape) - { - switch (c) - { - case 'n': out += '\n'; break; - case 'r': out += '\r'; break; - case 't': out += '\t'; break; - case '"': out += '\"'; break; - case '\\': out += '\\'; break; - default: - throw ParserError(ErrorContext(ecUNKNOWN_ESCAPE_SEQUENCE, nPos)); - } - - bEscape = false; - } - else - { - out += c; - } - } - } - - throw ParserError(ErrorContext(ecUNTERMINATED_STRING, nPos)); -} - -//------------------------------------------------------------------------------ -bool StrValReader::IsValue(const char_type *a_pszExpr, int &a_iPos, Value &a_Val) -{ - const char_type *szExpr = a_pszExpr + a_iPos; - if (szExpr[0] != '"') - return false; - - a_Val = Unescape(a_pszExpr, ++a_iPos); - return true; -} - -//------------------------------------------------------------------------------ -IValueReader* StrValReader::Clone(TokenReader *pTokenReader) const -{ - IValueReader *pReader = new StrValReader(*this); - pReader->SetParent(pTokenReader); - - return pReader; -} -} // namespace mu diff --git a/src/third-party/headers/muparserx/mpValue.cpp b/src/third-party/headers/muparserx/mpValue.cpp deleted file mode 100644 index 69b39227cb..0000000000 --- a/src/third-party/headers/muparserx/mpValue.cpp +++ /dev/null @@ -1,804 +0,0 @@ -/* -
          -             __________                                 ____  ___
          -  _____  __ _\______   \_____ _______  ______ __________\   \/  /
          - /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     /
          -|  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \
          -|__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -      \/                     \/           \/     \/           \_/
          -Copyright (C) 2016, Ingo Berg
          -All rights reserved.
          -
          -Redistribution and use in source and binary forms, with or without
          -modification, are permitted provided that the following conditions are met:
          -
          -* Redistributions of source code must retain the above copyright notice,
          -this list of conditions and the following disclaimer.
          -* Redistributions in binary form must reproduce the above copyright notice,
          -this list of conditions and the following disclaimer in the documentation
          -and/or other materials provided with the distribution.
          -
          -THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
          -ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
          -WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
          -IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT,
          -INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
          -NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
          -PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
          -WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
          -ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
          -POSSIBILITY OF SUCH DAMAGE.
          -
          -*/ -#include "mpValue.h" -#include "mpError.h" -#include "mpValueCache.h" - - -MUP_NAMESPACE_START - -//------------------------------------------------------------------------------ -/** \brief Construct an empty value object of a given type. - \param cType The type of the value to construct (default='v'). - */ - Value::Value(char_type cType) - :IValue(cmVAL) - , m_val(0, 0) - , m_psVal(nullptr) - , m_pvVal(nullptr) - , m_cType(cType) - , m_iFlags(flNONE) - , m_pCache(nullptr) -{ - // strings and arrays must allocate their memory - switch (cType) - { - case 's': m_psVal = new string_type(); break; - case 'm': m_pvVal = new matrix_type(0, Value(0.0)); break; - } -} - -//--------------------------------------------------------------------------- -Value::Value(int_type a_iVal) - :IValue(cmVAL) - ,m_val((float_type)a_iVal, 0) - ,m_psVal(nullptr) - ,m_pvVal(nullptr) - ,m_cType('i') - ,m_iFlags(flNONE) - ,m_pCache(nullptr) -{} - -//--------------------------------------------------------------------------- -Value::Value(bool_type a_bVal) - :IValue(cmVAL) - , m_val((float_type)a_bVal, 0) - , m_psVal(nullptr) - , m_pvVal(nullptr) - , m_cType('b') - , m_iFlags(flNONE) - , m_pCache(nullptr) -{} - -//--------------------------------------------------------------------------- -Value::Value(string_type a_sVal) - :IValue(cmVAL) - , m_val() - , m_psVal(new string_type(a_sVal)) - , m_pvVal(nullptr) - , m_cType('s') - , m_iFlags(flNONE) - , m_pCache(nullptr) -{} - -//--------------------------------------------------------------------------- -Value::Value(int_type array_size, float_type v) - :IValue(cmVAL) - , m_val() - , m_psVal(nullptr) - , m_pvVal(new matrix_type(array_size, Value(v))) - , m_cType('m') - , m_iFlags(flNONE) - , m_pCache(nullptr) -{} - -//--------------------------------------------------------------------------- -/** \brief Create a m x n matrix -*/ -Value::Value(int_type m, int_type n, float_type v) - :IValue(cmVAL) - , m_val() - , m_psVal(nullptr) - , m_pvVal(new matrix_type(m, n, Value(v))) - , m_cType('m') - , m_iFlags(flNONE) - , m_pCache(nullptr) -{} - -//--------------------------------------------------------------------------- -Value::Value(const char_type *a_szVal) - :IValue(cmVAL) - , m_val() - , m_psVal(new string_type(a_szVal)) - , m_pvVal(nullptr) - , m_cType('s') - , m_iFlags(flNONE) - , m_pCache(nullptr) -{} - -//--------------------------------------------------------------------------- -Value::Value(const cmplx_type &v) - :IValue(cmVAL) - , m_val(v) - , m_psVal(nullptr) - , m_pvVal(nullptr) - , m_cType('c') - , m_iFlags(flNONE) - , m_pCache(nullptr) -{ - if ((m_val.real() == (int_type)m_val.real()) && (m_val.imag() == 0)) - m_cType = 'i'; - else - m_cType = (m_val.imag() == 0) ? 'f' : 'c'; -} - -//--------------------------------------------------------------------------- -Value::Value(float_type val) - :IValue(cmVAL) - , m_val(val, 0) - , m_psVal(nullptr) - , m_pvVal(nullptr) - , m_cType((val == (int_type)val) ? 'i' : 'f') - , m_iFlags(flNONE) - , m_pCache(nullptr) -{} - -//--------------------------------------------------------------------------- -Value::Value(const matrix_type &val) - :IValue(cmVAL) - , m_val() - , m_psVal(nullptr) - , m_pvVal(new matrix_type(val)) - , m_cType('m') - , m_iFlags(flNONE) - , m_pCache(nullptr) -{} - -//--------------------------------------------------------------------------- -Value::Value(const Value &a_Val) - :IValue(cmVAL) - , m_psVal(nullptr) - , m_pvVal(nullptr) - , m_pCache(nullptr) -{ - Assign(a_Val); -} - -//--------------------------------------------------------------------------- -Value::Value(const IValue &a_Val) - :IValue(cmVAL) - , m_psVal(nullptr) - , m_pvVal(nullptr) - , m_pCache(nullptr) -{ - Reset(); - - switch (a_Val.GetType()) - { - case 'i': - case 'f': - case 'b': m_val = cmplx_type(a_Val.GetFloat(), 0); - break; - - - case 'c': m_val = cmplx_type(a_Val.GetFloat(), a_Val.GetImag()); - break; - - case 's': if (!m_psVal) - m_psVal = new string_type(a_Val.GetString()); - else - *m_psVal = a_Val.GetString(); - break; - - case 'm': if (!m_pvVal) - m_pvVal = new matrix_type(a_Val.GetArray()); - else - *m_pvVal = a_Val.GetArray(); - break; - - case 'v': break; - default: MUP_FAIL(INVALID_TYPE_CODE); - } - - m_cType = a_Val.GetType(); -} - -//--------------------------------------------------------------------------- -Value& Value::operator=(const Value &a_Val) -{ - Assign(a_Val); - return *this; -} - -//--------------------------------------------------------------------------- -/** \brief Return the matrix element at row col. - - Row and col are the indices of the matrix. If this element does not - represent a matrix row and col must be 0 otherwise an index out of bound error - is thrown. - */ -IValue& Value::At(const IValue &row, const IValue &col) -{ - if (!row.IsInteger() || !col.IsInteger()) - { - ErrorContext errc(ecTYPE_CONFLICT_IDX, GetExprPos()); - errc.Type1 = (!row.IsInteger()) ? row.GetType() : col.GetType(); - errc.Type2 = 'i'; - throw ParserError(errc); - } - - int_type nRow = row.GetInteger(), - nCol = col.GetInteger(); - return At(nRow, nCol); -} - -//--------------------------------------------------------------------------- -IValue& Value::At(int nRow, int nCol) -{ - if (IsMatrix()) - { - if (nRow >= m_pvVal->GetRows() || nCol >= m_pvVal->GetCols() || nRow < 0 || nCol < 0) - throw ParserError(ErrorContext(ecINDEX_OUT_OF_BOUNDS, -1, GetIdent())); - - return m_pvVal->At(nRow, nCol); - } - else if (nRow == 0 && nCol == 0) - { - return *this; - } - else - throw ParserError(ErrorContext(ecINDEX_OUT_OF_BOUNDS)); -} - -//--------------------------------------------------------------------------- -Value::~Value() -{ - delete m_psVal; - delete m_pvVal; -} - -//--------------------------------------------------------------------------- -IToken* Value::Clone() const -{ - return new Value(*this); -} - -//--------------------------------------------------------------------------- -Value* Value::AsValue() -{ - return this; -} - -//--------------------------------------------------------------------------- -/** \brief Copy constructor. */ -void Value::Assign(const Value &ref) -{ - if (this == &ref) - return; - - m_val = ref.m_val; - m_cType = ref.m_cType; - m_iFlags = ref.m_iFlags; - - // allocate room for a string - if (ref.m_psVal) - { - if (!m_psVal) - m_psVal = new string_type(*ref.m_psVal); - else - *m_psVal = *ref.m_psVal; - } - else - { - delete m_psVal; - m_psVal = nullptr; - } - - // allocate room for a vector - if (ref.m_pvVal) - { - if (m_pvVal == nullptr) - m_pvVal = new matrix_type(*ref.m_pvVal); - else - *m_pvVal = *ref.m_pvVal; - } - else - { - delete m_pvVal; - m_pvVal = nullptr; - } - - // Do NOT access ref beyound this point! If you do, "unboxing" of - // a 1 x 1 matrix using: - // - // this->Assign(m_pvVal->At(0,0)); - // - // will blow up in your face since ref will become invalid at them very - // moment you delete m_pvVal! -} - -//--------------------------------------------------------------------------- -void Value::Reset() -{ - m_val = cmplx_type(0, 0); - - delete m_psVal; - m_psVal = nullptr; - - delete m_pvVal; - m_pvVal = nullptr; - - m_cType = 'f'; - m_iFlags = flNONE; -} - -//--------------------------------------------------------------------------- -IValue& Value::operator=(bool val) -{ - m_val = cmplx_type((float_type)val, 0); - - delete m_psVal; - m_psVal = nullptr; - - delete m_pvVal; - m_pvVal = nullptr; - - m_cType = 'b'; - m_iFlags = flNONE; - return *this; -} - -//--------------------------------------------------------------------------- -IValue& Value::operator=(int_type a_iVal) -{ - m_val = cmplx_type(a_iVal,0); - - delete m_psVal; - m_psVal = nullptr; - - delete m_pvVal; - m_pvVal = nullptr; - - m_cType = 'i'; - m_iFlags = flNONE; - return *this; -} - -//--------------------------------------------------------------------------- -IValue& Value::operator=(float_type val) -{ - m_val = cmplx_type(val, 0); - - delete m_psVal; - m_psVal = nullptr; - - delete m_pvVal; - m_pvVal = nullptr; - - m_cType = (val == (int_type)val) ? 'i' : 'f'; - m_iFlags = flNONE; - return *this; -} - -//--------------------------------------------------------------------------- -IValue& Value::operator=(string_type a_sVal) -{ - m_val = cmplx_type(); - - if (!m_psVal) - m_psVal = new string_type(a_sVal); - else - *m_psVal = a_sVal; - - delete m_pvVal; - m_pvVal = nullptr; - - m_cType = 's'; - m_iFlags = flNONE; - return *this; -} - -//--------------------------------------------------------------------------- -IValue& Value::operator=(const char_type *a_szVal) -{ - m_val = cmplx_type(); - - if (!m_psVal) - m_psVal = new string_type(a_szVal); - else - *m_psVal = a_szVal; - - delete m_pvVal; - m_pvVal = nullptr; - - m_cType = 's'; - m_iFlags = flNONE; - return *this; -} - -//--------------------------------------------------------------------------- -IValue& Value::operator=(const matrix_type &a_vVal) -{ - m_val = cmplx_type(0, 0); - - delete m_psVal; - m_psVal = nullptr; - - if (m_pvVal == nullptr) - m_pvVal = new matrix_type(a_vVal); - else - *m_pvVal = a_vVal; - - m_cType = 'm'; - m_iFlags = flNONE; - - return *this; -} - -//--------------------------------------------------------------------------- -IValue& Value::operator=(const cmplx_type &val) -{ - m_val = val; - - delete m_psVal; - m_psVal = nullptr; - - delete m_pvVal; - m_pvVal = nullptr; - - m_cType = (m_val.imag() == 0) ? ((m_val.real() == (int)m_val.real()) ? 'i' : 'f') : 'c'; - m_iFlags = flNONE; - - return *this; -} - -//--------------------------------------------------------------------------- -IValue& Value::operator+=(const IValue &val) -{ - if (IsScalar() && val.IsScalar()) - { - // Scalar/Scalar addition - m_val += val.GetComplex(); - m_cType = (m_val.imag() == 0) ? ((m_val.real() == (int)m_val.real()) ? 'i' : 'f') : 'c'; - } - else if (IsMatrix() && val.IsMatrix()) - { - // Matrix/Matrix addition - assert(m_pvVal); - *m_pvVal += val.GetArray(); - } - else if (IsString() && val.IsString()) - { - // string/string addition - assert(m_psVal); - *m_psVal += val.GetString(); - } - else - { - // Type conflict - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, _T("+"), GetType(), val.GetType(), 2)); - } - - return *this; -} - -//--------------------------------------------------------------------------- -IValue& Value::operator-=(const IValue &val) -{ - if (IsScalar() && val.IsScalar()) - { - // Scalar/Scalar addition - m_val -= val.GetComplex(); - m_cType = (m_val.imag() == 0) ? ((m_val.real() == (int)m_val.real()) ? 'i' : 'f') : 'c'; - } - else if (IsMatrix() && val.IsMatrix()) - { - // Matrix/Matrix addition - assert(m_pvVal); - *m_pvVal -= val.GetArray(); - } - else - { - // There is a typeconflict: - throw ParserError(ErrorContext(ecTYPE_CONFLICT_FUN, -1, _T("-"), GetType(), val.GetType(), 2)); - } - - return *this; -} - -//--------------------------------------------------------------------------- -/** \brief Assign a value with multiplication - \param val The value to multiply to this - - When multiplying to values with each value representing a matrix type - the result is checked whether it is a 1 x 1 matrix. If so the value is - "unboxed" and stored directly in this value object. It is no longer - treated as a matrix internally. - */ -IValue& Value::operator*=(const IValue &val) -{ - if (IsScalar() && val.IsScalar()) - { - // Scalar/Scalar multiplication - m_val *= val.GetComplex(); - m_cType = (m_val.imag() == 0) ? ((m_val.real() == (int)m_val.real()) ? 'i' : 'f') : 'c'; - } - else if (IsMatrix() && val.IsMatrix()) - { - // Matrix/Matrix addition - assert(m_pvVal); - *m_pvVal *= val.GetArray(); - - // The result may actually be a scalar value, i.e. the scalar product of - // two vectors. - if (m_pvVal->GetCols() == 1 && m_pvVal->GetRows() == 1) - { - Assign(m_pvVal->At(0, 0)); - } - } - else if (IsMatrix() && val.IsScalar()) - { - *m_pvVal *= val; - } - else if (IsScalar() && val.IsMatrix()) - { - // transform this into a matrix and multiply with rhs - Value prod = val * (*this); - Assign(prod); - } - else - { - // Type conflict - ErrorContext errc(ecTYPE_CONFLICT_FUN, -1, _T("*")); - errc.Type1 = GetType(); - errc.Type2 = 'm'; //val.GetType(); - errc.Arg = 2; - throw ParserError(errc); - } - - return *this; -} - -//--------------------------------------------------------------------------- -/** \brief Returns a character representing the type of this value instance. - \return m_cType Either one of 'c' for comlex, 'i' for integer, - 'f' for floating point, 'b' for boolean, 's' for string or - 'm' for matrix values. - */ -char_type Value::GetType() const -{ - return m_cType; -} - -//--------------------------------------------------------------------------- -/** \brief Return the value as an integer. - - This function should only be called if you really need an integer value and - want to make sure your either get one or throw an exception if the value - can not be implicitely converted into an integer. - */ -int_type Value::GetInteger() const -{ - float_type v = m_val.real(); - - if (m_cType != 'i') - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT; - err.Type1 = m_cType; - err.Type2 = 'i'; - - if (GetIdent().length()) - { - err.Ident = GetIdent(); - } - else - { - stringstream_type ss; - ss << *this; - err.Ident = ss.str(); - } - - throw ParserError(err); - } - - return (int_type)v; -} - -//--------------------------------------------------------------------------- -float_type Value::GetFloat() const -{ - return m_val.real(); -} - -//--------------------------------------------------------------------------- -/** \brief Get the imaginary part of the value. - \throw ParserError in case this value represents a string or a matrix - */ -float_type Value::GetImag() const -{ - if (!IsScalar()) - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT; - err.Type1 = m_cType; - err.Type2 = 'c'; - - if (GetIdent().length()) - { - err.Ident = GetIdent(); - } - else - { - stringstream_type ss; - ss << *this; - err.Ident = ss.str(); - } - - throw ParserError(err); - } - - return m_val.imag(); -} - -//--------------------------------------------------------------------------- -/** \brief Returns this value as a complex number. - \throw nothrow - - If the value instance does not represent a complex value the returned value - is undefined. No exception is triggered. If you are unsure about the type - use IsComplex() or GetType() to verify the type. - */ -const cmplx_type& Value::GetComplex() const -{ - return m_val; -} - -//--------------------------------------------------------------------------- -const string_type& Value::GetString() const -{ - CheckType('s'); - assert(m_psVal != nullptr); - return *m_psVal; -} - -//--------------------------------------------------------------------------- -bool Value::GetBool() const -{ - CheckType('b'); - return m_val.real() == 1; -} - -//--------------------------------------------------------------------------- -const matrix_type& Value::GetArray() const -{ - CheckType('m'); - assert(m_pvVal != nullptr); - return *m_pvVal; -} - -//--------------------------------------------------------------------------- -int Value::GetRows() const -{ - return (GetType() != 'm') ? 1 : GetArray().GetRows(); -} - -//--------------------------------------------------------------------------- -int Value::GetCols() const -{ - return (GetType() != 'm') ? 1 : GetArray().GetCols(); -} - -//--------------------------------------------------------------------------- -void Value::CheckType(char_type a_cType) const -{ - if (m_cType != a_cType) - { - ErrorContext err; - err.Errc = ecTYPE_CONFLICT; - err.Type1 = m_cType; - err.Type2 = a_cType; - - if (GetIdent().length()) - { - err.Ident = GetIdent(); - } - else - { - stringstream_type ss; - ss << *this; - err.Ident = ss.str(); - } - - throw ParserError(err); - } -} - -//--------------------------------------------------------------------------- -bool Value::IsVariable() const -{ - return false; -} - -//--------------------------------------------------------------------------- -string_type Value::AsciiDump() const -{ - stringstream_type ss; - - ss << g_sCmdCode[GetCode()]; - ss << _T(" [addr=0x") << std::hex << this << std::dec; - ss << _T("; pos=") << GetExprPos(); - ss << _T("; type=\"") << GetType() << _T("\""); - ss << _T("; val="); - - switch (m_cType) - { - case 'i': ss << (int_type)m_val.real(); break; - case 'f': ss << m_val.real(); break; - case 'm': ss << _T("(matrix)"); break; - case 's': - assert(m_psVal != nullptr); - ss << _T("\"") << m_psVal << _T("\""); break; - } - - ss << ((IsFlagSet(IToken::flVOLATILE)) ? _T("; ") : _T("; not ")) << _T("vol"); - ss << _T("]"); - - return ss.str(); -} - -//----------------------------------------------------------------------------------------------- -void Value::Release() -{ - if (m_pCache) - m_pCache->ReleaseToCache(this); - else - delete this; -} - -//----------------------------------------------------------------------------------------------- -void Value::BindToCache(ValueCache *pCache) -{ - m_pCache = pCache; -} - -//----------------------------------------------------------------------------------------------- -Value::operator cmplx_type () -{ - return GetComplex(); -} - -//----------------------------------------------------------------------------------------------- -Value::operator int_type() -{ - return GetInteger(); -} - -//----------------------------------------------------------------------------------------------- -Value::operator string_type() -{ - return GetString(); -} - -//----------------------------------------------------------------------------------------------- -Value::operator float_type() -{ - return GetFloat(); -} - -//----------------------------------------------------------------------------------------------- -Value::operator bool() -{ - return GetBool(); -} -} // namespace mu diff --git a/src/third-party/headers/muparserx/mpValueCache.cpp b/src/third-party/headers/muparserx/mpValueCache.cpp deleted file mode 100644 index b8cfd63aca..0000000000 --- a/src/third-party/headers/muparserx/mpValueCache.cpp +++ /dev/null @@ -1,105 +0,0 @@ -/** \file - \brief Definition of a class for caching unused value items and recycling them. - -
          -               __________                                 ____  ___
          -    _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
          -  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
          -  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -        \/                     \/           \/     \/           \_/
          -                                       Copyright (C) 2016, Ingo Berg
          -                                       All rights reserved.
          -
          -  Redistribution and use in source and binary forms, with or without 
          -  modification, are permitted provided that the following conditions are met:
          -
          -   * Redistributions of source code must retain the above copyright notice, 
          -     this list of conditions and the following disclaimer.
          -   * Redistributions in binary form must reproduce the above copyright notice, 
          -     this list of conditions and the following disclaimer in the documentation 
          -     and/or other materials provided with the distribution.
          -
          -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
          -  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
          -  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
          -  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
          -  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
          -  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
          -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
          -  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
          -  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
          -  POSSIBILITY OF SUCH DAMAGE.
          -
          -*/ -#include "mpValueCache.h" - -#include "mpValue.h" - - -MUP_NAMESPACE_START - - //------------------------------------------------------------------------------ - ValueCache::ValueCache(int size) - :m_nIdx(-1) - ,m_vCache(size, (mup::Value*)0) // hint to myself: don't use nullptr gcc will go postal... - {} - - //------------------------------------------------------------------------------ - ValueCache::~ValueCache() - { - ReleaseAll(); - } - - //------------------------------------------------------------------------------ - void ValueCache::ReleaseAll() - { - for (std::size_t i=0; iGetRef()==0); - - // Add the value to the cache if the cache has room for it - // otherwise release the value item instantly - if ( m_nIdx < ((int)m_vCache.size()-1) ) - { - m_nIdx++; - m_vCache[m_nIdx] = pValue; - } - else - delete pValue; - } - - //------------------------------------------------------------------------------ - Value* ValueCache::CreateFromCache() - { - Value *pValue = nullptr; - if (m_nIdx>=0) - { - pValue = m_vCache[m_nIdx]; - m_vCache[m_nIdx] = nullptr; - m_nIdx--; - } - else - { - pValue = new Value(); - pValue->BindToCache(this); - } - - return pValue; - } - -MUP_NAMESPACE_END diff --git a/src/third-party/headers/muparserx/mpVariable.cpp b/src/third-party/headers/muparserx/mpVariable.cpp deleted file mode 100644 index a0c56c0b3d..0000000000 --- a/src/third-party/headers/muparserx/mpVariable.cpp +++ /dev/null @@ -1,395 +0,0 @@ -/** \file - \brief Implementation of the muParserX variable class. - -
          -               __________                                 ____  ___
          -    _____  __ _\______   \_____ _______  ______ __________\   \/  /
          -   /     \|  |  \     ___/\__  \\_  __ \/  ___// __ \_  __ \     / 
          -  |  Y Y  \  |  /    |     / __ \|  | \/\___ \\  ___/|  | \/     \ 
          -  |__|_|  /____/|____|    (____  /__|  /____  >\___  >__| /___/\  \
          -        \/                     \/           \/     \/           \_/
          -                                       Copyright (C) 2016, Ingo Berg
          -                                       All rights reserved.
          -
          -  Redistribution and use in source and binary forms, with or without 
          -  modification, are permitted provided that the following conditions are met:
          -
          -   * Redistributions of source code must retain the above copyright notice, 
          -     this list of conditions and the following disclaimer.
          -   * Redistributions in binary form must reproduce the above copyright notice, 
          -     this list of conditions and the following disclaimer in the documentation 
          -     and/or other materials provided with the distribution.
          -
          -  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND 
          -  ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
          -  WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 
          -  IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, 
          -  INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 
          -  NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR 
          -  PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, 
          -  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) 
          -  ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE 
          -  POSSIBILITY OF SUCH DAMAGE.
          -
          -*/ -#include "mpVariable.h" -#include "mpError.h" - -#include "mpValue.h" - - -MUP_NAMESPACE_START - - //----------------------------------------------------------------------------------------------- - /** \brief Create a variable and bind a value to it. - \param pVal Pointer of the value to bind to this variable. - - It is possible to create an empty variable object by setting pVal to nullptr. - Such variable objects must be bound later in order to be of any use. The parser - does NOT assume ownership over the pointer! - */ - Variable::Variable(IValue *pVal) - :IValue(cmVAL) - ,m_pVal(pVal) - { - AddFlags(IToken::flVOLATILE); - } - - //----------------------------------------------------------------------------------------------- - Variable::Variable(const Variable &obj) - :IValue(cmVAL) - { - Assign(obj); - AddFlags(IToken::flVOLATILE); - } - - //----------------------------------------------------------------------------------------------- - Variable& Variable::operator=(const Variable &obj) - { - Assign(obj); - return *this; - } - - //----------------------------------------------------------------------------------------------- - /** \brief Assign a value to the variable. - \param ref Reference to the value to be assigned - */ - IValue& Variable::operator=(const Value &ref) - { - assert(m_pVal); - *m_pVal = ref; - return *this; - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::operator=(int_type val) - { - assert(m_pVal); - return m_pVal->operator=(val); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::operator=(float_type val) - { - assert(m_pVal); - return m_pVal->operator=(val); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::operator=(string_type val) - { - assert(m_pVal); - return m_pVal->operator=(val); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::operator=(bool_type val) - { - assert(m_pVal); - return m_pVal->operator=(val); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::operator=(const matrix_type &val) - { - assert(m_pVal); - return m_pVal->operator=(val); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::operator=(const cmplx_type &val) - { - assert(m_pVal); - return m_pVal->operator=(val); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::operator+=(const IValue &val) - { - assert(m_pVal); - return m_pVal->operator+=(val); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::operator-=(const IValue &val) - { - assert(m_pVal); - return m_pVal->operator-=(val); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::operator*=(const IValue &val) - { - assert(m_pVal); - return m_pVal->operator*=(val); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::At(int nRow, int nCol) - { - return m_pVal->At(nRow, nCol); - } - - //----------------------------------------------------------------------------------------------- - IValue& Variable::At(const IValue &row, const IValue &col) - { - try - { - return m_pVal->At(row, col); - } - catch(ParserError &exc) - { - // add the identifier to the error context - exc.GetContext().Ident = GetIdent(); - throw exc; - } - } - - //----------------------------------------------------------------------------------------------- - Variable::~Variable() - {} - - //----------------------------------------------------------------------------------------------- - void Variable::Assign(const Variable &ref) - { - if (this==&ref) - return; - - m_pVal = ref.m_pVal; - } - - //----------------------------------------------------------------------------------------------- - /** \brief Returns a character representing the type of the variable. - \throw nothrow - */ - char_type Variable::GetType() const - { - return (m_pVal) ? m_pVal->GetType() : 'v'; - } - - //----------------------------------------------------------------------------------------------- - /** \brief Returns the Value pointer bound to this variable. - \throw nothrow - */ - IValue* Variable::GetPtr() const - { - return m_pVal; - } - - //----------------------------------------------------------------------------------------------- - int_type Variable::GetInteger() const - { - try - { - return m_pVal->GetInteger(); - } - catch (ParserError &exc) - { - exc.GetContext().Ident = GetIdent(); - throw; - } - } - - //----------------------------------------------------------------------------------------------- - float_type Variable::GetFloat() const - { - try - { - return m_pVal->GetFloat(); - } - catch (ParserError &exc) - { - exc.GetContext().Ident = GetIdent(); - throw; - } - } - - //----------------------------------------------------------------------------------------------- - float_type Variable::GetImag() const - { - try - { - return m_pVal->GetImag(); - } - catch (ParserError &exc) - { - exc.GetContext().Ident = GetIdent(); - throw; - } - } - - //----------------------------------------------------------------------------------------------- - const cmplx_type& Variable::GetComplex() const - { - try - { - return m_pVal->GetComplex(); - } - catch (ParserError &exc) - { - exc.GetContext().Ident = GetIdent(); - throw; - } - } - - //----------------------------------------------------------------------------------------------- - const string_type& Variable::GetString() const - { - try - { - return m_pVal->GetString(); - } - catch (ParserError &exc) - { - exc.GetContext().Ident = GetIdent(); - throw; - } - } - - //----------------------------------------------------------------------------------------------- - bool Variable::GetBool() const - { - try - { - return m_pVal->GetBool(); - } - catch (ParserError &exc) - { - exc.GetContext().Ident = GetIdent(); - throw; - } - } - - //----------------------------------------------------------------------------------------------- - const matrix_type& Variable::GetArray() const - { - try - { - return m_pVal->GetArray(); - } - catch (ParserError &exc) - { - exc.GetContext().Ident = GetIdent(); - throw; - } - } - - //----------------------------------------------------------------------------------------------- - int Variable::GetRows() const - { - try - { - return m_pVal->GetRows(); - } - catch (ParserError &exc) - { - exc.GetContext().Ident = GetIdent(); - throw; - } - } - - //----------------------------------------------------------------------------------------------- - int Variable::GetCols() const - { - try - { - return m_pVal->GetCols(); - } - catch (ParserError &exc) - { - exc.GetContext().Ident = GetIdent(); - throw; - } - } - - //----------------------------------------------------------------------------------------------- - void Variable::SetFloat(float_type a_fVal) - { - assert(m_pVal); - *m_pVal = a_fVal; - } - - //----------------------------------------------------------------------------------------------- - void Variable::SetString(const string_type &a_sVal) - { - assert(m_pVal); - *m_pVal = a_sVal; - } - - //----------------------------------------------------------------------------------------------- - void Variable::SetBool(bool a_bVal) - { - assert(m_pVal); - *m_pVal = a_bVal; - } - - //----------------------------------------------------------------------------------------------- - void Variable::Bind(IValue *pValue) - { - m_pVal = pValue; - } - - //--------------------------------------------------------------------------- - bool Variable::IsVariable() const - { - return true; - } - - //----------------------------------------------------------------------------------------------- - IToken* Variable::Clone() const - { - return new Variable(*this); - } - - //----------------------------------------------------------------------------------------------- - Value* Variable::AsValue() - { - return nullptr; - } - - //----------------------------------------------------------------------------------------------- - string_type Variable::AsciiDump() const - { - stringstream_type ss; - - ss << g_sCmdCode[ GetCode() ]; - ss << _T(" [addr=0x") << std::hex << this << std::dec; - ss << _T("; pos=") << GetExprPos(); - ss << _T("; id=\"") << GetIdent() << _T("\""); - ss << _T("; type=\"") << GetType() << _T("\""); - ss << _T("; val="); - - switch(GetType()) - { - case 'i': ss << (int_type)GetFloat(); break; - case 'f': ss << GetFloat(); break; - case 'm': ss << _T("(array)"); break; - case 's': ss << _T("\"") << GetString() << _T("\""); break; - } - - ss << ((IsFlagSet(IToken::flVOLATILE)) ? _T("; ") : _T("; not ")) << _T("vol"); - ss << _T("]"); - - return ss.str(); - } -MUP_NAMESPACE_END
      2. J5tOWDnH;F$`jtt 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

      bacMl?*$Zze%|H#}(#i(!u)1g}CqPurQnfCfQC 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