diff --git a/notebooks/test_addm.ipynb b/notebooks/test_addm.ipynb new file mode 100644 index 0000000..b2425b8 --- /dev/null +++ b/notebooks/test_addm.ipynb @@ -0,0 +1,624 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "id": "1abbb58b", + "metadata": {}, + "outputs": [], + "source": [ + "import ssms\n", + "from matplotlib import pyplot as plt\n", + "from ssms.basic_simulators import simulator\n", + "import numpy as np\n", + "import pickle as pkl " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "49b2869c", + "metadata": {}, + "outputs": [], + "source": [ + "# list(ssms.config.model_config.keys())" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7c25d946", + "metadata": {}, + "outputs": [], + "source": [ + "from ssms import Simulator \n", + "\n", + "addm = Simulator(\"addm\")\n", + "addm_out = addm.simulate(theta={\"eta\": 0.7, \"kappa\": 0.5, \"a\": 2.1, \"z\": -0.2, \"b\": 0, \"t\": 0.0},\n", + " n_samples=500)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "0275863b", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "array([[ 2.7550092 ],\n", + " [ 1.5832645 ],\n", + " [ 2.316614 ],\n", + " [ 2.013361 ],\n", + " [ 2.863048 ],\n", + " [ 2.3676932 ],\n", + " [ 8.54545 ],\n", + " [ 0.4339615 ],\n", + " [ 2.4800413 ],\n", + " [ 0.5782542 ],\n", + " [ 1.8103294 ],\n", + " [ 0.50840986],\n", + " [ 3.1422462 ],\n", + " [ 2.033549 ],\n", + " [ 0.44667113],\n", + " [ 1.3008145 ],\n", + " [ 1.4417139 ],\n", + " [ 2.3638709 ],\n", + " [ 0.50560933],\n", + " [ 0.82918483],\n", + " [ 0.45396274],\n", + " [ 0.45900458],\n", + " [ 1.8232957 ],\n", + " [ 1.6787384 ],\n", + " [ 0.7269571 ],\n", + " [ 0.81018996],\n", + " [ 0.63936913],\n", + " [ 0.8294591 ],\n", + " [ 1.5486253 ],\n", + " [ 0.93635 ],\n", + " [ 0.6423114 ],\n", + " [ 0.54740775],\n", + " [ 0.7240765 ],\n", + " [ 0.81545264],\n", + " [ 2.7868788 ],\n", + " [ 2.7711442 ],\n", + " [ 8.516631 ],\n", + " [ 0.7649046 ],\n", + " [ 2.877039 ],\n", + " [ 1.0480453 ],\n", + " [ 3.2811196 ],\n", + " [ 1.145941 ],\n", + " [ 0.8492891 ],\n", + " [ 1.2495344 ],\n", + " [ 0.7367473 ],\n", + " [ 7.1451406 ],\n", + " [ 0.94503933],\n", + " [ 3.2164779 ],\n", + " [ 0.517577 ],\n", + " [ 4.072411 ],\n", + " [ 0.5357329 ],\n", + " [ 5.3148093 ],\n", + " [ 2.0769362 ],\n", + " [ 2.718248 ],\n", + " [ 1.295921 ],\n", + " [ 1.6029624 ],\n", + " [ 6.8115816 ],\n", + " [ 2.0809214 ],\n", + " [ 1.2851784 ],\n", + " [ 5.08319 ],\n", + " [ 0.95677125],\n", + " [ 1.4290384 ],\n", + " [ 1.4025079 ],\n", + " [ 4.821423 ],\n", + " [ 4.8458533 ],\n", + " [ 1.4281621 ],\n", + " [ 2.0944846 ],\n", + " [ 1.4179357 ],\n", + " [ 2.617874 ],\n", + " [ 1.976557 ],\n", + " [ 3.7462807 ],\n", + " [ 1.871623 ],\n", + " [ 1.1586014 ],\n", + " [ 1.6902591 ],\n", + " [ 1.7409947 ],\n", + " [ 6.7457814 ],\n", + " [ 0.6742923 ],\n", + " [ 9.245989 ],\n", + " [ 1.0756658 ],\n", + " [ 4.14568 ],\n", + " [ 9.55395 ],\n", + " [ 1.4863019 ],\n", + " [ 3.1541889 ],\n", + " [ 6.999312 ],\n", + " [ 3.3644176 ],\n", + " [11.840909 ],\n", + " [ 3.9733028 ],\n", + " [ 1.3439279 ],\n", + " [ 0.30639473],\n", + " [ 0.41361627],\n", + " [ 0.9684001 ],\n", + " [ 1.3022655 ],\n", + " [ 1.5365146 ],\n", + " [ 1.0813559 ],\n", + " [ 1.2783769 ],\n", + " [ 1.3013629 ],\n", + " [ 0.4140725 ],\n", + " [ 1.5572712 ],\n", + " [ 1.1406559 ],\n", + " [ 1.5703402 ],\n", + " [ 0.95634156],\n", + " [ 1.3062764 ],\n", + " [ 1.2778736 ],\n", + " [ 4.056496 ],\n", + " [ 3.1175363 ],\n", + " [ 1.785675 ],\n", + " [ 4.854434 ],\n", + " [ 1.9670123 ],\n", + " [ 4.9618006 ],\n", + " [ 1.9633766 ],\n", + " [ 0.7128475 ],\n", + " [ 2.8038766 ],\n", + " [ 1.5302092 ],\n", + " [ 1.3599901 ],\n", + " [18.134483 ],\n", + " [ 7.3933654 ],\n", + " [ 1.0370729 ],\n", + " [ 2.9157357 ],\n", + " [ 2.3148816 ],\n", + " [ 7.389206 ],\n", + " [ 5.839894 ],\n", + " [ 1.4015311 ],\n", + " [ 6.730601 ],\n", + " [ 8.990075 ],\n", + " [ 1.3746406 ],\n", + " [ 3.7968905 ],\n", + " [ 1.018276 ],\n", + " [ 1.0148282 ],\n", + " [ 3.2564106 ],\n", + " [ 1.9786456 ],\n", + " [20.000637 ],\n", + " [ 1.055675 ],\n", + " [ 7.275497 ],\n", + " [ 2.0258813 ],\n", + " [ 1.7566216 ],\n", + " [ 1.0466868 ],\n", + " [ 0.44887453],\n", + " [ 4.5929766 ],\n", + " [ 1.0680661 ],\n", + " [ 2.370545 ],\n", + " [ 0.8085884 ],\n", + " [ 4.5404296 ],\n", + " [ 2.0992248 ],\n", + " [ 0.8847508 ],\n", + " [ 4.5486093 ],\n", + " [ 0.8846143 ],\n", + " [ 3.0106392 ],\n", + " [ 1.8515719 ],\n", + " [ 1.9177569 ],\n", + " [ 1.4823842 ],\n", + " [ 1.6471105 ],\n", + " [ 1.5688268 ],\n", + " [ 1.479542 ],\n", + " [ 1.8934485 ],\n", + " [ 4.2129235 ],\n", + " [ 1.6497469 ],\n", + " [ 1.1475954 ],\n", + " [ 1.5291072 ],\n", + " [ 2.7878616 ],\n", + " [ 0.8291507 ],\n", + " [ 0.89191216],\n", + " [ 0.8228438 ],\n", + " [13.611006 ],\n", + " [ 1.8081654 ],\n", + " [ 8.188163 ],\n", + " [ 3.590089 ],\n", + " [ 9.028559 ],\n", + " [11.075285 ],\n", + " [ 2.1968274 ],\n", + " [ 2.3022447 ],\n", + " [ 0.86533713],\n", + " [ 1.1602964 ],\n", + " [ 1.3206004 ],\n", + " [ 0.6616954 ],\n", + " [ 1.8578764 ],\n", + " [ 0.7706305 ],\n", + " [ 3.2053106 ],\n", + " [ 1.8584027 ],\n", + " [ 0.8061676 ],\n", + " [ 0.97666377],\n", + " [ 1.1186852 ],\n", + " [ 0.97682273],\n", + " [ 1.5372804 ],\n", + " [ 0.83750266],\n", + " [ 1.6121885 ],\n", + " [ 2.7574477 ],\n", + " [ 3.9240227 ],\n", + " [ 0.40254617],\n", + " [ 3.0281827 ],\n", + " [ 0.531423 ],\n", + " [ 1.7171056 ],\n", + " [ 0.39579666],\n", + " [ 0.7272381 ],\n", + " [ 0.47928265],\n", + " [ 1.8624889 ],\n", + " [ 0.5311368 ],\n", + " [ 3.9200141 ],\n", + " [ 6.5276256 ],\n", + " [ 2.0103848 ],\n", + " [ 2.6464245 ],\n", + " [ 2.651716 ],\n", + " [ 1.8242728 ],\n", + " [ 1.7661988 ],\n", + " [ 3.7884228 ],\n", + " [ 1.5787728 ],\n", + " [ 4.54377 ],\n", + " [ 2.062966 ],\n", + " [ 2.5856166 ],\n", + " [ 2.342294 ],\n", + " [ 4.362768 ],\n", + " [ 4.5422635 ],\n", + " [ 5.8836575 ],\n", + " [ 3.3121896 ],\n", + " [12.512758 ],\n", + " [ 2.0425603 ],\n", + " [ 0.91448045],\n", + " [ 7.195936 ],\n", + " [ 0.53856295],\n", + " [ 1.6311226 ],\n", + " [ 2.4817266 ],\n", + " [ 2.043471 ],\n", + " [ 0.4333894 ],\n", + " [ 0.87693506],\n", + " [ 3.555309 ],\n", + " [ 1.268813 ],\n", + " [ 4.1972456 ],\n", + " [ 0.5985091 ],\n", + " [ 1.1692067 ],\n", + " [ 1.2766017 ],\n", + " [ 1.2725483 ],\n", + " [ 1.3652898 ],\n", + " [ 2.8949292 ],\n", + " [ 2.894515 ],\n", + " [ 4.9782023 ],\n", + " [ 1.1902344 ],\n", + " [ 6.622975 ],\n", + " [ 2.9268854 ],\n", + " [ 1.5391902 ],\n", + " [ 3.3788314 ],\n", + " [ 1.4368111 ],\n", + " [ 5.0891066 ],\n", + " [ 1.560312 ],\n", + " [ 1.5808964 ],\n", + " [ 1.7990918 ],\n", + " [ 2.1584795 ],\n", + " [ 3.379156 ],\n", + " [ 1.5850692 ],\n", + " [ 5.255836 ],\n", + " [ 7.3362017 ],\n", + " [ 1.0543594 ],\n", + " [ 1.254187 ],\n", + " [ 5.343556 ],\n", + " [14.618673 ],\n", + " [ 1.0392672 ],\n", + " [ 3.3964763 ],\n", + " [ 0.39756113],\n", + " [ 1.0424058 ],\n", + " [ 2.3526978 ],\n", + " [ 6.364393 ],\n", + " [ 2.7608893 ],\n", + " [ 4.4525266 ],\n", + " [ 2.4364493 ],\n", + " [ 7.6278915 ],\n", + " [ 2.9379315 ],\n", + " [ 1.8570924 ],\n", + " [ 0.9948722 ],\n", + " [ 0.90138954],\n", + " [ 2.2360294 ],\n", + " [ 1.3858263 ],\n", + " [ 2.8446739 ],\n", + " [ 6.446662 ],\n", + " [ 1.4363655 ],\n", + " [ 1.630072 ],\n", + " [ 5.2032437 ],\n", + " [ 0.86421406],\n", + " [ 3.6783776 ],\n", + " [ 0.8231482 ],\n", + " [ 2.0160654 ],\n", + " [ 1.7861836 ],\n", + " [ 1.9868176 ],\n", + " [ 2.100098 ],\n", + " [ 3.7277093 ],\n", + " [ 5.2606936 ],\n", + " [ 3.8535354 ],\n", + " [ 0.879136 ],\n", + " [ 4.342368 ],\n", + " [ 0.86230695],\n", + " [ 1.4070506 ],\n", + " [ 1.9185334 ],\n", + " [ 7.026744 ],\n", + " [18.617077 ],\n", + " [ 2.00595 ],\n", + " [ 0.76634717],\n", + " [ 6.40978 ],\n", + " [ 1.4138904 ],\n", + " [ 0.997763 ],\n", + " [ 1.2628094 ],\n", + " [ 1.2086968 ],\n", + " [ 0.9738975 ],\n", + " [ 5.6855516 ],\n", + " [ 1.8107692 ],\n", + " [ 1.2222009 ],\n", + " [ 1.7343258 ],\n", + " [ 3.9204123 ],\n", + " [ 4.14963 ],\n", + " [ 1.9574579 ],\n", + " [ 0.75305617],\n", + " [ 2.3216698 ],\n", + " [ 5.438086 ],\n", + " [10.698581 ],\n", + " [ 4.6343746 ],\n", + " [ 1.0919538 ],\n", + " [ 1.3558335 ],\n", + " [ 1.3155376 ],\n", + " [ 1.0934014 ],\n", + " [ 1.7327746 ],\n", + " [ 7.5551443 ],\n", + " [ 7.985781 ],\n", + " [ 1.3155922 ],\n", + " [ 1.2914776 ],\n", + " [15.861505 ],\n", + " [ 2.0727766 ],\n", + " [10.594187 ],\n", + " [ 1.282769 ],\n", + " [ 1.690722 ],\n", + " [ 3.7062883 ],\n", + " [ 0.9917158 ],\n", + " [ 1.483999 ],\n", + " [ 1.2862909 ],\n", + " [ 3.2060554 ],\n", + " [ 2.0351193 ],\n", + " [ 0.8270693 ],\n", + " [ 3.8692133 ],\n", + " [ 3.732747 ],\n", + " [ 1.4540204 ],\n", + " [ 1.7059568 ],\n", + " [ 1.724529 ],\n", + " [ 2.430532 ],\n", + " [ 1.8703544 ],\n", + " [ 0.411772 ],\n", + " [ 0.41090766],\n", + " [ 0.41967866],\n", + " [ 0.96382123],\n", + " [ 3.9568236 ],\n", + " [ 3.6256964 ],\n", + " [ 0.40975815],\n", + " [ 0.40302798],\n", + " [ 0.40312144],\n", + " [ 0.5893676 ],\n", + " [ 0.4575238 ],\n", + " [ 0.41135806],\n", + " [ 0.95062345],\n", + " [ 0.41703668],\n", + " [ 0.4037074 ],\n", + " [ 4.97184 ],\n", + " [ 9.554308 ],\n", + " [ 2.670758 ],\n", + " [ 2.8567364 ],\n", + " [ 3.251144 ],\n", + " [ 2.1109967 ],\n", + " [ 6.1163893 ],\n", + " [ 1.9784424 ],\n", + " [ 0.9526342 ],\n", + " [ 6.0080667 ],\n", + " [ 2.0850687 ],\n", + " [ 7.107095 ],\n", + " [ 0.7605449 ],\n", + " [ 7.776825 ],\n", + " [ 1.6814029 ],\n", + " [ 2.3996406 ],\n", + " [ 0.74314344],\n", + " [ 4.1899967 ],\n", + " [ 1.448756 ],\n", + " [ 4.885189 ],\n", + " [ 3.4025235 ],\n", + " [ 2.340537 ],\n", + " [ 2.0841603 ],\n", + " [ 2.3413813 ],\n", + " [ 3.6968107 ],\n", + " [ 3.6925356 ],\n", + " [ 2.1551578 ],\n", + " [ 3.6591995 ],\n", + " [ 6.176405 ],\n", + " [ 1.9663934 ],\n", + " [ 1.7573549 ],\n", + " [ 0.7905397 ],\n", + " [ 4.0450177 ],\n", + " [ 4.0484657 ],\n", + " [ 1.8174596 ],\n", + " [ 3.1204395 ],\n", + " [ 4.1537657 ],\n", + " [ 4.984723 ],\n", + " [ 1.1703973 ],\n", + " [ 3.1183178 ],\n", + " [16.18447 ],\n", + " [ 0.9181004 ],\n", + " [ 3.9001288 ],\n", + " [ 0.4869246 ],\n", + " [ 0.78868854],\n", + " [ 3.2599475 ],\n", + " [13.612342 ],\n", + " [ 2.8419478 ],\n", + " [ 2.334117 ],\n", + " [ 4.719529 ],\n", + " [ 1.5165315 ],\n", + " [ 2.2148898 ],\n", + " [ 3.2456212 ],\n", + " [ 3.2247596 ],\n", + " [ 3.1033044 ],\n", + " [ 0.99396336],\n", + " [ 1.6994987 ],\n", + " [ 5.3363276 ],\n", + " [ 1.120416 ],\n", + " [ 4.218065 ],\n", + " [ 6.8807445 ],\n", + " [ 6.880515 ],\n", + " [ 1.6202227 ],\n", + " [ 2.671305 ],\n", + " [ 0.30816358],\n", + " [ 0.29207036],\n", + " [ 2.9565432 ],\n", + " [ 1.5945841 ],\n", + " [ 7.443284 ],\n", + " [10.285436 ],\n", + " [ 1.1157187 ],\n", + " [ 2.0948777 ],\n", + " [ 2.053473 ],\n", + " [ 2.0951254 ],\n", + " [ 1.8621621 ],\n", + " [ 5.558052 ],\n", + " [ 1.2892832 ],\n", + " [ 0.86309725],\n", + " [ 0.52333724],\n", + " [ 0.8229323 ],\n", + " [ 1.2239994 ],\n", + " [ 0.85776466],\n", + " [ 1.2898203 ],\n", + " [ 1.3388394 ],\n", + " [ 0.9807551 ],\n", + " [ 1.0802604 ],\n", + " [ 1.2917222 ],\n", + " [ 1.2315935 ],\n", + " [ 2.059417 ],\n", + " [ 1.4133507 ],\n", + " [ 1.8981754 ],\n", + " [ 0.98216933],\n", + " [ 6.2024326 ],\n", + " [ 0.6888584 ],\n", + " [ 2.1582472 ],\n", + " [ 5.123294 ],\n", + " [ 3.6636767 ],\n", + " [ 3.041645 ],\n", + " [ 2.0500636 ],\n", + " [ 5.4329147 ],\n", + " [ 5.4487553 ],\n", + " [ 1.1640164 ],\n", + " [ 5.5883026 ],\n", + " [ 1.0028092 ],\n", + " [ 5.2980742 ],\n", + " [ 3.1494849 ],\n", + " [ 3.1098797 ],\n", + " [ 5.329139 ],\n", + " [ 1.0357571 ],\n", + " [14.942529 ],\n", + " [ 7.1694193 ],\n", + " [ 1.6894854 ],\n", + " [ 3.6461961 ],\n", + " [ 1.5585557 ],\n", + " [ 2.1935937 ],\n", + " [ 4.6029124 ],\n", + " [ 3.972043 ],\n", + " [ 1.5228554 ],\n", + " [ 1.5231175 ],\n", + " [ 2.203843 ],\n", + " [ 1.1116849 ],\n", + " [ 1.5846958 ],\n", + " [ 2.5311852 ],\n", + " [ 1.4033388 ],\n", + " [ 1.0321034 ],\n", + " [ 1.1457384 ],\n", + " [ 2.4381342 ],\n", + " [ 2.5468102 ],\n", + " [ 1.1074545 ],\n", + " [ 7.7982707 ],\n", + " [ 2.1952565 ],\n", + " [ 0.76992583],\n", + " [ 8.2573 ],\n", + " [ 2.654416 ],\n", + " [ 1.8356915 ],\n", + " [ 0.8683515 ],\n", + " [ 2.1264858 ],\n", + " [ 1.5125443 ],\n", + " [20.000637 ],\n", + " [ 1.7780876 ],\n", + " [ 1.2183691 ],\n", + " [ 0.69639623],\n", + " [ 2.2200289 ],\n", + " [ 3.2851915 ],\n", + " [ 9.695026 ],\n", + " [ 2.3792129 ]], dtype=float32)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "addm_out['rts']" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "3bb0f9c3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Text(0, 0.5, 'Density')" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plt.hist(\n", + " addm_out[\"rts\"][addm_out[\"rts\"] != -999],\n", + " bins=50,\n", + " histtype=\"step\",\n", + " color=\"black\",\n", + " label=\"Weibull Deadline\",\n", + " density=True,\n", + ")\n", + "\n", + "plt.xlabel(\"Reaction Times (neg RTs are errors)\")\n", + "plt.ylabel(\"Density\")" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "ssm-simulators", + "language": "python", + "name": "ssm-simulators" + }, + "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.11.13" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/setup.py b/setup.py index 03420bc..dd0f2b6 100644 --- a/setup.py +++ b/setup.py @@ -30,6 +30,7 @@ CYTHON_MODULES = [ "_utils", "lba_models", + "addm_models" ] # Modules that benefit from OpenMP (will still build without it, but with OpenMP flags) diff --git a/src/cssm.cpp b/src/cssm.cpp new file mode 100644 index 0000000..fe1888e --- /dev/null +++ b/src/cssm.cpp @@ -0,0 +1,92254 @@ +/* Generated by Cython 3.2.0 */ + +/* BEGIN: Cython Metadata +{ + "distutils": { + "depends": [], + "language": "c++", + "name": "cssm", + "sources": [ + "src/cssm.pyx" + ] + }, + "module_name": "cssm" +} +END: Cython Metadata */ + +#ifndef PY_SSIZE_T_CLEAN +#define PY_SSIZE_T_CLEAN +#endif /* PY_SSIZE_T_CLEAN */ +/* InitLimitedAPI */ +#if defined(Py_LIMITED_API) + #if !defined(CYTHON_LIMITED_API) + #define CYTHON_LIMITED_API 1 + #endif +#elif defined(CYTHON_LIMITED_API) + #ifdef _MSC_VER + #pragma message ("Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead.") + #else + #warning Limited API usage is enabled with 'CYTHON_LIMITED_API' but 'Py_LIMITED_API' does not define a Python target version. Consider setting 'Py_LIMITED_API' instead. + #endif +#endif + +#include "Python.h" +#ifndef Py_PYTHON_H + #error Python headers needed to compile C extensions, please install development version of Python. +#elif PY_VERSION_HEX < 0x03080000 + #error Cython requires Python 3.8+. +#else +#define __PYX_ABI_VERSION "3_2_0" +#define CYTHON_HEX_VERSION 0x030200F0 +#define CYTHON_FUTURE_DIVISION 1 +/* CModulePreamble */ +#include +#ifndef offsetof + #define offsetof(type, member) ( (size_t) & ((type*)0) -> member ) +#endif +#if !defined(_WIN32) && !defined(WIN32) && !defined(MS_WINDOWS) + #ifndef __stdcall + #define __stdcall + #endif + #ifndef __cdecl + #define __cdecl + #endif + #ifndef __fastcall + #define __fastcall + #endif +#endif +#ifndef DL_IMPORT + #define DL_IMPORT(t) t +#endif +#ifndef DL_EXPORT + #define DL_EXPORT(t) t +#endif +#define __PYX_COMMA , +#ifndef PY_LONG_LONG + #define PY_LONG_LONG LONG_LONG +#endif +#ifndef Py_HUGE_VAL + #define Py_HUGE_VAL HUGE_VAL +#endif +#define __PYX_LIMITED_VERSION_HEX PY_VERSION_HEX +#if defined(GRAALVM_PYTHON) + /* For very preliminary testing purposes. Most variables are set the same as PyPy. + The existence of this section does not imply that anything works or is even tested */ + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 1 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #undef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 +#elif defined(PYPY_VERSION) + #define CYTHON_COMPILING_IN_PYPY 1 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #undef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 1 + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 0 + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #if PY_VERSION_HEX < 0x03090000 + #undef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 0 + #elif !defined(CYTHON_PEP489_MULTI_PHASE_INIT) + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #undef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE (PYPY_VERSION_NUM >= 0x07030C00) + #endif + #undef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 0 + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC (PYPY_VERSION_NUM >= 0x07031100) + #endif + #undef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 0 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 +#elif defined(CYTHON_LIMITED_API) + #ifdef Py_LIMITED_API + #undef __PYX_LIMITED_VERSION_HEX + #define __PYX_LIMITED_VERSION_HEX Py_LIMITED_API + #endif + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 0 + #define CYTHON_COMPILING_IN_LIMITED_API 1 + #define CYTHON_COMPILING_IN_GRAAL 0 + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 0 + #undef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 1 + #undef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 0 + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #undef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 0 + #ifndef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #endif + #undef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 0 + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #ifndef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #undef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 0 + #undef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 0 + #undef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 0 + #undef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 0 + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #undef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) + #undef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 0 + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #undef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING 0 + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 0 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND (__PYX_LIMITED_VERSION_HEX >= 0x030A0000) + #endif + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #undef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 0 + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 0 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS 1 + #endif + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 +#else + #define CYTHON_COMPILING_IN_PYPY 0 + #define CYTHON_COMPILING_IN_CPYTHON 1 + #define CYTHON_COMPILING_IN_LIMITED_API 0 + #define CYTHON_COMPILING_IN_GRAAL 0 + #ifdef Py_GIL_DISABLED + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 1 + #else + #define CYTHON_COMPILING_IN_CPYTHON_FREETHREADING 0 + #endif + #if PY_VERSION_HEX < 0x030A0000 + #undef CYTHON_USE_TYPE_SLOTS + #define CYTHON_USE_TYPE_SLOTS 1 + #elif !defined(CYTHON_USE_TYPE_SLOTS) + #define CYTHON_USE_TYPE_SLOTS 1 + #endif + #ifndef CYTHON_USE_TYPE_SPECS + #define CYTHON_USE_TYPE_SPECS 0 + #endif + #ifndef CYTHON_USE_PYTYPE_LOOKUP + #define CYTHON_USE_PYTYPE_LOOKUP 1 + #endif + #ifndef CYTHON_USE_PYLONG_INTERNALS + #define CYTHON_USE_PYLONG_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_PYLIST_INTERNALS + #define CYTHON_USE_PYLIST_INTERNALS 0 + #elif !defined(CYTHON_USE_PYLIST_INTERNALS) + #define CYTHON_USE_PYLIST_INTERNALS 1 + #endif + #ifndef CYTHON_USE_UNICODE_INTERNALS + #define CYTHON_USE_UNICODE_INTERNALS 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING || PY_VERSION_HEX >= 0x030B00A2 + #undef CYTHON_USE_UNICODE_WRITER + #define CYTHON_USE_UNICODE_WRITER 0 + #elif !defined(CYTHON_USE_UNICODE_WRITER) + #define CYTHON_USE_UNICODE_WRITER 1 + #endif + #ifndef CYTHON_AVOID_BORROWED_REFS + #define CYTHON_AVOID_BORROWED_REFS 0 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 1 + #elif !defined(CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS) + #define CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS 0 + #endif + #ifndef CYTHON_ASSUME_SAFE_MACROS + #define CYTHON_ASSUME_SAFE_MACROS 1 + #endif + #ifndef CYTHON_ASSUME_SAFE_SIZE + #define CYTHON_ASSUME_SAFE_SIZE 1 + #endif + #ifndef CYTHON_UNPACK_METHODS + #define CYTHON_UNPACK_METHODS 1 + #endif + #ifndef CYTHON_FAST_THREAD_STATE + #define CYTHON_FAST_THREAD_STATE 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_FAST_GIL + #define CYTHON_FAST_GIL 0 + #elif !defined(CYTHON_FAST_GIL) + #define CYTHON_FAST_GIL (PY_VERSION_HEX < 0x030C00A6) + #endif + #ifndef CYTHON_METH_FASTCALL + #define CYTHON_METH_FASTCALL 1 + #endif + #ifndef CYTHON_FAST_PYCALL + #define CYTHON_FAST_PYCALL 1 + #endif + #ifndef CYTHON_PEP487_INIT_SUBCLASS + #define CYTHON_PEP487_INIT_SUBCLASS 1 + #endif + #ifndef CYTHON_PEP489_MULTI_PHASE_INIT + #define CYTHON_PEP489_MULTI_PHASE_INIT 1 + #endif + #ifndef CYTHON_USE_MODULE_STATE + #define CYTHON_USE_MODULE_STATE 0 + #endif + #ifndef CYTHON_USE_SYS_MONITORING + #define CYTHON_USE_SYS_MONITORING (PY_VERSION_HEX >= 0x030d00B1) + #endif + #ifndef CYTHON_USE_TP_FINALIZE + #define CYTHON_USE_TP_FINALIZE 1 + #endif + #ifndef CYTHON_USE_AM_SEND + #define CYTHON_USE_AM_SEND 1 + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #undef CYTHON_USE_DICT_VERSIONS + #define CYTHON_USE_DICT_VERSIONS 0 + #elif !defined(CYTHON_USE_DICT_VERSIONS) + #define CYTHON_USE_DICT_VERSIONS (PY_VERSION_HEX < 0x030C00A5 && !CYTHON_USE_MODULE_STATE) + #endif + #ifndef CYTHON_USE_EXC_INFO_STACK + #define CYTHON_USE_EXC_INFO_STACK 1 + #endif + #ifndef CYTHON_UPDATE_DESCRIPTOR_DOC + #define CYTHON_UPDATE_DESCRIPTOR_DOC 1 + #endif + #ifndef CYTHON_USE_FREELISTS + #define CYTHON_USE_FREELISTS (!CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif + #if defined(CYTHON_IMMORTAL_CONSTANTS) && PY_VERSION_HEX < 0x030C0000 + #undef CYTHON_IMMORTAL_CONSTANTS + #define CYTHON_IMMORTAL_CONSTANTS 0 // definitely won't work + #elif !defined(CYTHON_IMMORTAL_CONSTANTS) + #define CYTHON_IMMORTAL_CONSTANTS (PY_VERSION_HEX >= 0x030C0000 && !CYTHON_USE_MODULE_STATE && CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) + #endif +#endif +#ifndef CYTHON_COMPRESS_STRINGS + #define CYTHON_COMPRESS_STRINGS 1 +#endif +#ifndef CYTHON_FAST_PYCCALL +#define CYTHON_FAST_PYCCALL CYTHON_FAST_PYCALL +#endif +#ifndef CYTHON_VECTORCALL +#if CYTHON_COMPILING_IN_LIMITED_API +#define CYTHON_VECTORCALL (__PYX_LIMITED_VERSION_HEX >= 0x030C0000) +#else +#define CYTHON_VECTORCALL (CYTHON_FAST_PYCCALL) +#endif +#endif +#if CYTHON_USE_PYLONG_INTERNALS + #undef SHIFT + #undef BASE + #undef MASK + #ifdef SIZEOF_VOID_P + enum { __pyx_check_sizeof_voidp = 1 / (int)(SIZEOF_VOID_P == sizeof(void*)) }; + #endif +#endif +#ifndef __has_attribute + #define __has_attribute(x) 0 +#endif +#ifndef __has_cpp_attribute + #define __has_cpp_attribute(x) 0 +#endif +#ifndef CYTHON_RESTRICT + #if defined(__GNUC__) + #define CYTHON_RESTRICT __restrict__ + #elif defined(_MSC_VER) && _MSC_VER >= 1400 + #define CYTHON_RESTRICT __restrict + #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define CYTHON_RESTRICT restrict + #else + #define CYTHON_RESTRICT + #endif +#endif +#ifndef CYTHON_UNUSED + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(maybe_unused) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(maybe_unused) + #define CYTHON_UNUSED [[maybe_unused]] + #endif + #endif + #endif +#endif +#ifndef CYTHON_UNUSED +# if defined(__GNUC__) +# if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER)) +# define CYTHON_UNUSED __attribute__ ((__unused__)) +# else +# define CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_UNUSED_VAR +# if defined(__cplusplus) + template void CYTHON_UNUSED_VAR( const T& ) { } +# else +# define CYTHON_UNUSED_VAR(x) (void)(x) +# endif +#endif +#ifndef CYTHON_MAYBE_UNUSED_VAR + #define CYTHON_MAYBE_UNUSED_VAR(x) CYTHON_UNUSED_VAR(x) +#endif +#ifndef CYTHON_NCP_UNUSED +# if CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +# define CYTHON_NCP_UNUSED +# else +# define CYTHON_NCP_UNUSED CYTHON_UNUSED +# endif +#endif +#ifndef CYTHON_USE_CPP_STD_MOVE + #if defined(__cplusplus) && (\ + __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)) + #define CYTHON_USE_CPP_STD_MOVE 1 + #else + #define CYTHON_USE_CPP_STD_MOVE 0 + #endif +#endif +#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None) +#include +typedef uintptr_t __pyx_uintptr_t; +#ifndef CYTHON_FALLTHROUGH + #if defined(__cplusplus) + /* for clang __has_cpp_attribute(fallthrough) is true even before C++17 + * but leads to warnings with -pedantic, since it is a C++17 feature */ + #if ((defined(_MSVC_LANG) && _MSVC_LANG >= 201703L) || __cplusplus >= 201703L) + #if __has_cpp_attribute(fallthrough) + #define CYTHON_FALLTHROUGH [[fallthrough]] + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_cpp_attribute(clang::fallthrough) + #define CYTHON_FALLTHROUGH [[clang::fallthrough]] + #elif __has_cpp_attribute(gnu::fallthrough) + #define CYTHON_FALLTHROUGH [[gnu::fallthrough]] + #endif + #endif + #endif + #ifndef CYTHON_FALLTHROUGH + #if __has_attribute(fallthrough) + #define CYTHON_FALLTHROUGH __attribute__((fallthrough)) + #else + #define CYTHON_FALLTHROUGH + #endif + #endif + #if defined(__clang__) && defined(__apple_build_version__) + #if __apple_build_version__ < 7000000 + #undef CYTHON_FALLTHROUGH + #define CYTHON_FALLTHROUGH + #endif + #endif +#endif +#ifndef Py_UNREACHABLE + #define Py_UNREACHABLE() assert(0); abort() +#endif +#ifdef __cplusplus + template + struct __PYX_IS_UNSIGNED_IMPL {static const bool value = T(0) < T(-1);}; + #define __PYX_IS_UNSIGNED(type) (__PYX_IS_UNSIGNED_IMPL::value) +#else + #define __PYX_IS_UNSIGNED(type) (((type)-1) > 0) +#endif +#if CYTHON_COMPILING_IN_PYPY == 1 + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x030A0000) +#else + #define __PYX_NEED_TP_PRINT_SLOT (PY_VERSION_HEX < 0x03090000) +#endif +#define __PYX_REINTERPRET_FUNCION(func_pointer, other_pointer) ((func_pointer)(void(*)(void))(other_pointer)) + +/* CppInitCode */ +#ifndef __cplusplus + #error "Cython files generated with the C++ option must be compiled with a C++ compiler." +#endif +#ifndef CYTHON_INLINE + #if defined(__clang__) + #define CYTHON_INLINE __inline__ __attribute__ ((__unused__)) + #else + #define CYTHON_INLINE inline + #endif +#endif +template +void __Pyx_call_destructor(T& x) { + x.~T(); +} +template +class __Pyx_FakeReference { + public: + __Pyx_FakeReference() : ptr(NULL) { } + __Pyx_FakeReference(const T& ref) : ptr(const_cast(&ref)) { } + T *operator->() { return ptr; } + T *operator&() { return ptr; } + operator T&() { return *ptr; } + template bool operator ==(const U& other) const { return *ptr == other; } + template bool operator !=(const U& other) const { return *ptr != other; } + template bool operator==(const __Pyx_FakeReference& other) const { return *ptr == *other.ptr; } + template bool operator!=(const __Pyx_FakeReference& other) const { return *ptr != *other.ptr; } + private: + T *ptr; +}; + +/* PythonCompatibility */ +#define __PYX_BUILD_PY_SSIZE_T "n" +#define CYTHON_FORMAT_SSIZE_T "z" +#define __Pyx_BUILTIN_MODULE_NAME "builtins" +#define __Pyx_DefaultClassType PyType_Type +#if CYTHON_COMPILING_IN_LIMITED_API + #ifndef CO_OPTIMIZED + static int CO_OPTIMIZED; + #endif + #ifndef CO_NEWLOCALS + static int CO_NEWLOCALS; + #endif + #ifndef CO_VARARGS + static int CO_VARARGS; + #endif + #ifndef CO_VARKEYWORDS + static int CO_VARKEYWORDS; + #endif + #ifndef CO_ASYNC_GENERATOR + static int CO_ASYNC_GENERATOR; + #endif + #ifndef CO_GENERATOR + static int CO_GENERATOR; + #endif + #ifndef CO_COROUTINE + static int CO_COROUTINE; + #endif +#else + #ifndef CO_COROUTINE + #define CO_COROUTINE 0x80 + #endif + #ifndef CO_ASYNC_GENERATOR + #define CO_ASYNC_GENERATOR 0x200 + #endif +#endif +static int __Pyx_init_co_variables(void); +#if PY_VERSION_HEX >= 0x030900A4 || defined(Py_IS_TYPE) + #define __Pyx_IS_TYPE(ob, type) Py_IS_TYPE(ob, type) +#else + #define __Pyx_IS_TYPE(ob, type) (((const PyObject*)ob)->ob_type == (type)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_Is) + #define __Pyx_Py_Is(x, y) Py_Is(x, y) +#else + #define __Pyx_Py_Is(x, y) ((x) == (y)) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsNone) + #define __Pyx_Py_IsNone(ob) Py_IsNone(ob) +#else + #define __Pyx_Py_IsNone(ob) __Pyx_Py_Is((ob), Py_None) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsTrue) + #define __Pyx_Py_IsTrue(ob) Py_IsTrue(ob) +#else + #define __Pyx_Py_IsTrue(ob) __Pyx_Py_Is((ob), Py_True) +#endif +#if PY_VERSION_HEX >= 0x030A00B1 || defined(Py_IsFalse) + #define __Pyx_Py_IsFalse(ob) Py_IsFalse(ob) +#else + #define __Pyx_Py_IsFalse(ob) __Pyx_Py_Is((ob), Py_False) +#endif +#define __Pyx_NoneAsNull(obj) (__Pyx_Py_IsNone(obj) ? NULL : (obj)) +#if PY_VERSION_HEX >= 0x030900F0 && !CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_GC_IsFinalized(o) PyObject_GC_IsFinalized(o) +#else + #define __Pyx_PyObject_GC_IsFinalized(o) _PyGC_FINALIZED(o) +#endif +#ifndef Py_TPFLAGS_CHECKTYPES + #define Py_TPFLAGS_CHECKTYPES 0 +#endif +#ifndef Py_TPFLAGS_HAVE_INDEX + #define Py_TPFLAGS_HAVE_INDEX 0 +#endif +#ifndef Py_TPFLAGS_HAVE_NEWBUFFER + #define Py_TPFLAGS_HAVE_NEWBUFFER 0 +#endif +#ifndef Py_TPFLAGS_HAVE_FINALIZE + #define Py_TPFLAGS_HAVE_FINALIZE 0 +#endif +#ifndef Py_TPFLAGS_SEQUENCE + #define Py_TPFLAGS_SEQUENCE 0 +#endif +#ifndef Py_TPFLAGS_MAPPING + #define Py_TPFLAGS_MAPPING 0 +#endif +#ifndef Py_TPFLAGS_IMMUTABLETYPE + #define Py_TPFLAGS_IMMUTABLETYPE (1UL << 8) +#endif +#ifndef Py_TPFLAGS_DISALLOW_INSTANTIATION + #define Py_TPFLAGS_DISALLOW_INSTANTIATION (1UL << 7) +#endif +#ifndef METH_STACKLESS + #define METH_STACKLESS 0 +#endif +#ifndef METH_FASTCALL + #ifndef METH_FASTCALL + #define METH_FASTCALL 0x80 + #endif + typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs); + typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args, + Py_ssize_t nargs, PyObject *kwnames); +#else + #if PY_VERSION_HEX >= 0x030d00A4 + # define __Pyx_PyCFunctionFast PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords PyCFunctionFastWithKeywords + #else + # define __Pyx_PyCFunctionFast _PyCFunctionFast + # define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords + #endif +#endif +#if CYTHON_METH_FASTCALL + #define __Pyx_METH_FASTCALL METH_FASTCALL + #define __Pyx_PyCFunction_FastCall __Pyx_PyCFunctionFast + #define __Pyx_PyCFunction_FastCallWithKeywords __Pyx_PyCFunctionFastWithKeywords +#else + #define __Pyx_METH_FASTCALL METH_VARARGS + #define __Pyx_PyCFunction_FastCall PyCFunction + #define __Pyx_PyCFunction_FastCallWithKeywords PyCFunctionWithKeywords +#endif +#if CYTHON_VECTORCALL + #define __pyx_vectorcallfunc vectorcallfunc + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET PY_VECTORCALL_ARGUMENTS_OFFSET + #define __Pyx_PyVectorcall_NARGS(n) PyVectorcall_NARGS((size_t)(n)) +#else + #define __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET 0 + #define __Pyx_PyVectorcall_NARGS(n) ((Py_ssize_t)(n)) +#endif +#if PY_VERSION_HEX >= 0x030900B1 +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_CheckExact(func) +#else +#define __Pyx_PyCFunction_CheckExact(func) PyCFunction_Check(func) +#endif +#define __Pyx_CyOrPyCFunction_Check(func) PyCFunction_Check(func) +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) (((PyCFunctionObject*)(func))->m_ml->ml_meth) +#elif !CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyOrPyCFunction_GET_FUNCTION(func) PyCFunction_GET_FUNCTION(func) +#endif +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_CyOrPyCFunction_GET_FLAGS(func) (((PyCFunctionObject*)(func))->m_ml->ml_flags) +static CYTHON_INLINE PyObject* __Pyx_CyOrPyCFunction_GET_SELF(PyObject *func) { + return (__Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_STATIC) ? NULL : ((PyCFunctionObject*)func)->m_self; +} +#endif +static CYTHON_INLINE int __Pyx__IsSameCFunction(PyObject *func, void (*cfunc)(void)) { +#if CYTHON_COMPILING_IN_LIMITED_API + return PyCFunction_Check(func) && PyCFunction_GetFunction(func) == (PyCFunction) cfunc; +#else + return PyCFunction_Check(func) && PyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; +#endif +} +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCFunction(func, cfunc) +#if PY_VERSION_HEX < 0x03090000 || (CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000) + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) ((void)m, PyType_FromSpecWithBases(s, b)) + typedef PyObject *(*__Pyx_PyCMethod)(PyObject *, PyTypeObject *, PyObject *const *, size_t, PyObject *); +#else + #define __Pyx_PyType_FromModuleAndSpec(m, s, b) PyType_FromModuleAndSpec(m, s, b) + #define __Pyx_PyCMethod PyCMethod +#endif +#ifndef METH_METHOD + #define METH_METHOD 0x200 +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc) + #define PyObject_Malloc(s) PyMem_Malloc(s) + #define PyObject_Free(p) PyMem_Free(p) + #define PyObject_Realloc(p) PyMem_Realloc(p) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) +#elif CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) GraalPyFrame_SetLineNumber((frame), (lineno)) +#elif CYTHON_COMPILING_IN_GRAAL + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) _PyFrame_SetLineNumber((frame), (lineno)) +#else + #define __Pyx_PyCode_HasFreeVars(co) (PyCode_GetNumFree(co) > 0) + #define __Pyx_PyFrame_SetLineNumber(frame, lineno) (frame)->f_lineno = (lineno) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyThreadState_Current PyThreadState_Get() +#elif !CYTHON_FAST_THREAD_STATE + #define __Pyx_PyThreadState_Current PyThreadState_GET() +#elif PY_VERSION_HEX >= 0x030d00A1 + #define __Pyx_PyThreadState_Current PyThreadState_GetUnchecked() +#else + #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet() +#endif +#if CYTHON_USE_MODULE_STATE +static CYTHON_INLINE void *__Pyx__PyModule_GetState(PyObject *op) +{ + void *result; + result = PyModule_GetState(op); + if (!result) + Py_FatalError("Couldn't find the module state"); + return result; +} +#define __Pyx_PyModule_GetState(o) (__pyx_mstatetype *)__Pyx__PyModule_GetState(o) +#else +#define __Pyx_PyModule_GetState(op) ((void)op,__pyx_mstate_global) +#endif +#define __Pyx_PyObject_GetSlot(obj, name, func_ctype) __Pyx_PyType_GetSlot(Py_TYPE((PyObject *) obj), name, func_ctype) +#define __Pyx_PyObject_TryGetSlot(obj, name, func_ctype) __Pyx_PyType_TryGetSlot(Py_TYPE(obj), name, func_ctype) +#define __Pyx_PyObject_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#define __Pyx_PyObject_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSubSlot(Py_TYPE(obj), sub, name, func_ctype) +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((type)->name) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype) __Pyx_PyType_GetSlot(type, name, func_ctype) + #define __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) (((type)->sub) ? ((type)->sub->name) : NULL) + #define __Pyx_PyType_TryGetSubSlot(type, sub, name, func_ctype) __Pyx_PyType_GetSubSlot(type, sub, name, func_ctype) +#else + #define __Pyx_PyType_GetSlot(type, name, func_ctype) ((func_ctype) PyType_GetSlot((type), Py_##name)) + #define __Pyx_PyType_TryGetSlot(type, name, func_ctype)\ + ((__PYX_LIMITED_VERSION_HEX >= 0x030A0000 ||\ + (PyType_GetFlags(type) & Py_TPFLAGS_HEAPTYPE) || __Pyx_get_runtime_version() >= 0x030A0000) ?\ + __Pyx_PyType_GetSlot(type, name, func_ctype) : NULL) + #define __Pyx_PyType_GetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_GetSlot(obj, name, func_ctype) + #define __Pyx_PyType_TryGetSubSlot(obj, sub, name, func_ctype) __Pyx_PyType_TryGetSlot(obj, name, func_ctype) +#endif +#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized) +#define __Pyx_PyDict_NewPresized(n) ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n)) +#else +#define __Pyx_PyDict_NewPresized(n) PyDict_New() +#endif +#define __Pyx_PyNumber_Divide(x,y) PyNumber_TrueDivide(x,y) +#define __Pyx_PyNumber_InPlaceDivide(x,y) PyNumber_InPlaceTrueDivide(x,y) +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_UNICODE_INTERNALS +#define __Pyx_PyDict_GetItemStrWithError(dict, name) _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash) +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStr(PyObject *dict, PyObject *name) { + PyObject *res = __Pyx_PyDict_GetItemStrWithError(dict, name); + if (res == NULL) PyErr_Clear(); + return res; +} +#elif !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000 +#define __Pyx_PyDict_GetItemStrWithError PyDict_GetItemWithError +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#else +static CYTHON_INLINE PyObject * __Pyx_PyDict_GetItemStrWithError(PyObject *dict, PyObject *name) { +#if CYTHON_COMPILING_IN_PYPY + return PyDict_GetItem(dict, name); +#else + PyDictEntry *ep; + PyDictObject *mp = (PyDictObject*) dict; + long hash = ((PyStringObject *) name)->ob_shash; + assert(hash != -1); + ep = (mp->ma_lookup)(mp, name, hash); + if (ep == NULL) { + return NULL; + } + return ep->me_value; +#endif +} +#define __Pyx_PyDict_GetItemStr PyDict_GetItem +#endif +#if CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyType_GetFlags(tp) (((PyTypeObject *)tp)->tp_flags) + #define __Pyx_PyType_HasFeature(type, feature) ((__Pyx_PyType_GetFlags(type) & (feature)) != 0) +#else + #define __Pyx_PyType_GetFlags(tp) (PyType_GetFlags((PyTypeObject *)tp)) + #define __Pyx_PyType_HasFeature(type, feature) PyType_HasFeature(type, feature) +#endif +#define __Pyx_PyObject_GetIterNextFunc(iterator) __Pyx_PyObject_GetSlot(iterator, tp_iternext, iternextfunc) +#if CYTHON_USE_TYPE_SPECS +#define __Pyx_PyHeapTypeObject_GC_Del(obj) {\ + PyTypeObject *type = Py_TYPE((PyObject*)obj);\ + assert(__Pyx_PyType_HasFeature(type, Py_TPFLAGS_HEAPTYPE));\ + PyObject_GC_Del(obj);\ + Py_DECREF(type);\ +} +#else +#define __Pyx_PyHeapTypeObject_GC_Del(obj) PyObject_GC_Del(obj) +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_PyUnicode_READY(op) (0) + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_ReadChar(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) ((void)u, 1114111U) + #define __Pyx_PyUnicode_KIND(u) ((void)u, (0)) + #define __Pyx_PyUnicode_DATA(u) ((void*)u) + #define __Pyx_PyUnicode_READ(k, d, i) ((void)k, PyUnicode_ReadChar((PyObject*)(d), i)) + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GetLength(u)) +#else + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_READY(op) (0) + #else + #define __Pyx_PyUnicode_READY(op) (likely(PyUnicode_IS_READY(op)) ?\ + 0 : _PyUnicode_Ready((PyObject *)(op))) + #endif + #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i) + #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u) PyUnicode_MAX_CHAR_VALUE(u) + #define __Pyx_PyUnicode_KIND(u) ((int)PyUnicode_KIND(u)) + #define __Pyx_PyUnicode_DATA(u) PyUnicode_DATA(u) + #define __Pyx_PyUnicode_READ(k, d, i) PyUnicode_READ(k, d, i) + #define __Pyx_PyUnicode_WRITE(k, d, i, ch) PyUnicode_WRITE(k, d, i, (Py_UCS4) ch) + #if PY_VERSION_HEX >= 0x030C0000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != PyUnicode_GET_LENGTH(u)) + #else + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x03090000 + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : ((PyCompactUnicodeObject *)(u))->wstr_length)) + #else + #define __Pyx_PyUnicode_IS_TRUE(u) (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u))) + #endif + #endif +#endif +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyUnicode_Concat(a, b) PyNumber_Add(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) PyNumber_Add(a, b) +#else + #define __Pyx_PyUnicode_Concat(a, b) PyUnicode_Concat(a, b) + #define __Pyx_PyUnicode_ConcatSafe(a, b) ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\ + PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b)) +#endif +#if CYTHON_COMPILING_IN_PYPY + #if !defined(PyUnicode_DecodeUnicodeEscape) + #define PyUnicode_DecodeUnicodeEscape(s, size, errors) PyUnicode_Decode(s, size, "unicode_escape", errors) + #endif + #if !defined(PyUnicode_Contains) + #define PyUnicode_Contains(u, s) PySequence_Contains(u, s) + #endif + #if !defined(PyByteArray_Check) + #define PyByteArray_Check(obj) PyObject_TypeCheck(obj, &PyByteArray_Type) + #endif + #if !defined(PyObject_Format) + #define PyObject_Format(obj, fmt) PyObject_CallMethod(obj, "__format__", "O", fmt) + #endif +#endif +#define __Pyx_PyUnicode_FormatSafe(a, b) ((unlikely((a) == Py_None || (PyUnicode_Check(b) && !PyUnicode_CheckExact(b)))) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b)) +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && PyUnstable_Object_IsUniquelyReferenced(obj)) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#elif CYTHON_COMPILING_IN_CPYTHON + #define __Pyx_PySequence_ListKeepNew(obj)\ + (likely(PyList_CheckExact(obj) && Py_REFCNT(obj) == 1) ? __Pyx_NewRef(obj) : PySequence_List(obj)) +#else + #define __Pyx_PySequence_ListKeepNew(obj) PySequence_List(obj) +#endif +#ifndef PySet_CheckExact + #define PySet_CheckExact(obj) __Pyx_IS_TYPE(obj, &PySet_Type) +#endif +#if PY_VERSION_HEX >= 0x030900A4 + #define __Pyx_SET_REFCNT(obj, refcnt) Py_SET_REFCNT(obj, refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SET_SIZE(obj, size) +#else + #define __Pyx_SET_REFCNT(obj, refcnt) Py_REFCNT(obj) = (refcnt) + #define __Pyx_SET_SIZE(obj, size) Py_SIZE(obj) = (size) +#endif +enum __Pyx_ReferenceSharing { + __Pyx_ReferenceSharing_DefinitelyUnique, // We created it so we know it's unshared - no need to check + __Pyx_ReferenceSharing_OwnStrongReference, + __Pyx_ReferenceSharing_FunctionArgument, + __Pyx_ReferenceSharing_SharedReference, // Never trust it to be unshared because it's a global or similar +}; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && PY_VERSION_HEX >= 0x030E0000 +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing)\ + (sharing == __Pyx_ReferenceSharing_DefinitelyUnique ? 1 :\ + (sharing == __Pyx_ReferenceSharing_FunctionArgument ? PyUnstable_Object_IsUniqueReferencedTemporary(o) :\ + (sharing == __Pyx_ReferenceSharing_OwnStrongReference ? PyUnstable_Object_IsUniquelyReferenced(o) : 0))) +#elif (CYTHON_COMPILING_IN_CPYTHON && !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING) || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)sharing), Py_REFCNT(o) == 1) +#else +#define __Pyx_IS_UNIQUELY_REFERENCED(o, sharing) (((void)o), ((void)sharing), 0) +#endif +#if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRef(o, i) (likely((i) >= 0) ? PySequence_GetItem(o, i) : (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) + #else + #define __Pyx_PyList_GetItemRef(o, i) PySequence_ITEM(o, i) + #endif +#elif CYTHON_COMPILING_IN_LIMITED_API || !CYTHON_ASSUME_SAFE_MACROS + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyList_GetItemRef(o, i) PyList_GetItemRef(o, i) + #else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_XNewRef(PyList_GetItem(o, i)) + #endif +#else + #define __Pyx_PyList_GetItemRef(o, i) __Pyx_NewRef(PyList_GET_ITEM(o, i)) +#endif +#if CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS && !CYTHON_COMPILING_IN_LIMITED_API && CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyList_GetItemRefFast(o, i, unsafe_shared) (__Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared) ?\ + __Pyx_NewRef(PyList_GET_ITEM(o, i)) : __Pyx_PyList_GetItemRef(o, i)) +#else + #define __Pyx_PyList_GetItemRefFast(o, i, unsafe_shared) __Pyx_PyList_GetItemRef(o, i) +#endif +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyDict_GetItemRef(dict, key, result) PyDict_GetItemRef(dict, key, result) +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyObject_GetItem(dict, key); + if (*result == NULL) { + if (PyErr_ExceptionMatches(PyExc_KeyError)) { + PyErr_Clear(); + return 0; + } + return -1; + } + return 1; +} +#else +static CYTHON_INLINE int __Pyx_PyDict_GetItemRef(PyObject *dict, PyObject *key, PyObject **result) { + *result = PyDict_GetItemWithError(dict, key); + if (*result == NULL) { + return PyErr_Occurred() ? -1 : 0; + } + Py_INCREF(*result); + return 1; +} +#endif +#if defined(CYTHON_DEBUG_VISIT_CONST) && CYTHON_DEBUG_VISIT_CONST + #define __Pyx_VISIT_CONST(obj) Py_VISIT(obj) +#else + #define __Pyx_VISIT_CONST(obj) +#endif +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PySequence_ITEM(o, i) PySequence_ITEM(o, i) + #define __Pyx_PySequence_SIZE(seq) Py_SIZE(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) (PyTuple_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GET_ITEM(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) (PyList_SET_ITEM(o, i, v), (0)) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GET_ITEM(o, i) +#else + #define __Pyx_PySequence_ITEM(o, i) PySequence_GetItem(o, i) + #define __Pyx_PySequence_SIZE(seq) PySequence_Size(seq) + #define __Pyx_PyTuple_SET_ITEM(o, i, v) PyTuple_SetItem(o, i, v) + #define __Pyx_PyTuple_GET_ITEM(o, i) PyTuple_GetItem(o, i) + #define __Pyx_PyList_SET_ITEM(o, i, v) PyList_SetItem(o, i, v) + #define __Pyx_PyList_GET_ITEM(o, i) PyList_GetItem(o, i) +#endif +#if CYTHON_ASSUME_SAFE_SIZE + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_GET_SIZE(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_GET_SIZE(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_GET_SIZE(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_GET_SIZE(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_GET_SIZE(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GET_LENGTH(o) +#else + #define __Pyx_PyTuple_GET_SIZE(o) PyTuple_Size(o) + #define __Pyx_PyList_GET_SIZE(o) PyList_Size(o) + #define __Pyx_PySet_GET_SIZE(o) PySet_Size(o) + #define __Pyx_PyBytes_GET_SIZE(o) PyBytes_Size(o) + #define __Pyx_PyByteArray_GET_SIZE(o) PyByteArray_Size(o) + #define __Pyx_PyUnicode_GET_LENGTH(o) PyUnicode_GetLength(o) +#endif +#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_InternFromString) + #define PyUnicode_InternFromString(s) PyUnicode_FromString(s) +#endif +#define __Pyx_PyLong_FromHash_t PyLong_FromSsize_t +#define __Pyx_PyLong_AsHash_t __Pyx_PyIndex_AsSsize_t +#if __PYX_LIMITED_VERSION_HEX >= 0x030A0000 + #define __Pyx_PySendResult PySendResult +#else + typedef enum { + PYGEN_RETURN = 0, + PYGEN_ERROR = -1, + PYGEN_NEXT = 1, + } __Pyx_PySendResult; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX < 0x030A00A3 + typedef __Pyx_PySendResult (*__Pyx_pyiter_sendfunc)(PyObject *iter, PyObject *value, PyObject **result); +#else + #define __Pyx_pyiter_sendfunc sendfunc +#endif +#if !CYTHON_USE_AM_SEND +#define __PYX_HAS_PY_AM_SEND 0 +#elif __PYX_LIMITED_VERSION_HEX >= 0x030A0000 +#define __PYX_HAS_PY_AM_SEND 1 +#else +#define __PYX_HAS_PY_AM_SEND 2 // our own backported implementation +#endif +#if __PYX_HAS_PY_AM_SEND < 2 + #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods +#else + typedef struct { + unaryfunc am_await; + unaryfunc am_aiter; + unaryfunc am_anext; + __Pyx_pyiter_sendfunc am_send; + } __Pyx_PyAsyncMethodsStruct; + #define __Pyx_SlotTpAsAsync(s) ((PyAsyncMethods*)(s)) +#endif +#if CYTHON_USE_AM_SEND && PY_VERSION_HEX < 0x030A00F0 + #define __Pyx_TPFLAGS_HAVE_AM_SEND (1UL << 21) +#else + #define __Pyx_TPFLAGS_HAVE_AM_SEND (0) +#endif +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyInterpreterState_Get() PyInterpreterState_Get() +#else +#define __Pyx_PyInterpreterState_Get() PyThreadState_Get()->interp +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030A0000 +#ifdef __cplusplus +extern "C" +#endif +PyAPI_FUNC(void *) PyMem_Calloc(size_t nelem, size_t elsize); +#endif +#if CYTHON_COMPILING_IN_LIMITED_API +static int __Pyx_init_co_variable(PyObject *inspect, const char* name, int *write_to) { + int value; + PyObject *py_value = PyObject_GetAttrString(inspect, name); + if (!py_value) return 0; + value = (int) PyLong_AsLong(py_value); + Py_DECREF(py_value); + *write_to = value; + return value != -1 || !PyErr_Occurred(); +} +static int __Pyx_init_co_variables(void) { + PyObject *inspect; + int result; + inspect = PyImport_ImportModule("inspect"); + result = +#if !defined(CO_OPTIMIZED) + __Pyx_init_co_variable(inspect, "CO_OPTIMIZED", &CO_OPTIMIZED) && +#endif +#if !defined(CO_NEWLOCALS) + __Pyx_init_co_variable(inspect, "CO_NEWLOCALS", &CO_NEWLOCALS) && +#endif +#if !defined(CO_VARARGS) + __Pyx_init_co_variable(inspect, "CO_VARARGS", &CO_VARARGS) && +#endif +#if !defined(CO_VARKEYWORDS) + __Pyx_init_co_variable(inspect, "CO_VARKEYWORDS", &CO_VARKEYWORDS) && +#endif +#if !defined(CO_ASYNC_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_ASYNC_GENERATOR", &CO_ASYNC_GENERATOR) && +#endif +#if !defined(CO_GENERATOR) + __Pyx_init_co_variable(inspect, "CO_GENERATOR", &CO_GENERATOR) && +#endif +#if !defined(CO_COROUTINE) + __Pyx_init_co_variable(inspect, "CO_COROUTINE", &CO_COROUTINE) && +#endif + 1; + Py_DECREF(inspect); + return result ? 0 : -1; +} +#else +static int __Pyx_init_co_variables(void) { + return 0; // It's a limited API-only feature +} +#endif + +/* MathInitCode */ +#if defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS) + #ifndef _USE_MATH_DEFINES + #define _USE_MATH_DEFINES + #endif +#endif +#include +#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL) +#define __Pyx_truncl trunc +#else +#define __Pyx_truncl truncl +#endif + +#ifndef CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#define CYTHON_CLINE_IN_TRACEBACK_RUNTIME 0 +#endif +#ifndef CYTHON_CLINE_IN_TRACEBACK +#define CYTHON_CLINE_IN_TRACEBACK CYTHON_CLINE_IN_TRACEBACK_RUNTIME +#endif +#if CYTHON_CLINE_IN_TRACEBACK +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; __pyx_clineno = __LINE__; (void) __pyx_clineno; } +#else +#define __PYX_MARK_ERR_POS(f_index, lineno) { __pyx_filename = __pyx_f[f_index]; (void) __pyx_filename; __pyx_lineno = lineno; (void) __pyx_lineno; (void) __pyx_clineno; } +#endif +#define __PYX_ERR(f_index, lineno, Ln_error) \ + { __PYX_MARK_ERR_POS(f_index, lineno) goto Ln_error; } + +#ifdef CYTHON_EXTERN_C + #undef __PYX_EXTERN_C + #define __PYX_EXTERN_C CYTHON_EXTERN_C +#elif defined(__PYX_EXTERN_C) + #ifdef _MSC_VER + #pragma message ("Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead.") + #else + #warning Please do not define the '__PYX_EXTERN_C' macro externally. Use 'CYTHON_EXTERN_C' instead. + #endif +#else + #define __PYX_EXTERN_C extern "C++" +#endif + +#define __PYX_HAVE__cssm +#define __PYX_HAVE_API__cssm +/* Early includes */ +#include +#include +#include +#include +#include +#include + + /* Using NumPy API declarations from "numpy/__init__.cython-30.pxd" */ + +#include "numpy/arrayobject.h" +#include "numpy/ndarrayobject.h" +#include "numpy/ndarraytypes.h" +#include "numpy/arrayscalars.h" +#include "numpy/ufuncobject.h" +#include "pythread.h" +#ifdef _OPENMP +#include +#endif /* _OPENMP */ + +#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS) +#define CYTHON_WITHOUT_ASSERTIONS +#endif + +#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0 +#define __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 0 +#define __PYX_DEFAULT_STRING_ENCODING "" +#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString +#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize +#define __Pyx_uchar_cast(c) ((unsigned char)c) +#define __Pyx_long_cast(x) ((long)x) +#define __Pyx_fits_Py_ssize_t(v, type, is_signed) (\ + (sizeof(type) < sizeof(Py_ssize_t)) ||\ + (sizeof(type) > sizeof(Py_ssize_t) &&\ + likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX) &&\ + (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||\ + v == (type)PY_SSIZE_T_MIN))) ||\ + (sizeof(type) == sizeof(Py_ssize_t) &&\ + (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||\ + v == (type)PY_SSIZE_T_MAX))) ) +static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) { + return (size_t) i < (size_t) limit; +} +#if defined (__cplusplus) && __cplusplus >= 201103L + #include + #define __Pyx_sst_abs(value) std::abs(value) +#elif SIZEOF_INT >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) abs(value) +#elif SIZEOF_LONG >= SIZEOF_SIZE_T + #define __Pyx_sst_abs(value) labs(value) +#elif defined (_MSC_VER) + #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value)) +#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L + #define __Pyx_sst_abs(value) llabs(value) +#elif defined (__GNUC__) + #define __Pyx_sst_abs(value) __builtin_llabs(value) +#else + #define __Pyx_sst_abs(value) ((value<0) ? -value : value) +#endif +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s); +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*); +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length); +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*); +#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l) +#define __Pyx_PyBytes_FromString PyBytes_FromString +#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*); +#if CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AS_STRING(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AS_STRING(s) +#else + #define __Pyx_PyBytes_AsWritableString(s) ((char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableSString(s) ((signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsWritableUString(s) ((unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsString(s) ((const char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsSString(s) ((const signed char*) PyBytes_AsString(s)) + #define __Pyx_PyBytes_AsUString(s) ((const unsigned char*) PyBytes_AsString(s)) + #define __Pyx_PyByteArray_AsString(s) PyByteArray_AsString(s) +#endif +#define __Pyx_PyObject_AsWritableString(s) ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableSString(s) ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsWritableUString(s) ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsSString(s) ((const signed char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_AsUString(s) ((const unsigned char*) __Pyx_PyObject_AsString(s)) +#define __Pyx_PyObject_FromCString(s) __Pyx_PyObject_FromString((const char*)s) +#define __Pyx_PyBytes_FromCString(s) __Pyx_PyBytes_FromString((const char*)s) +#define __Pyx_PyByteArray_FromCString(s) __Pyx_PyByteArray_FromString((const char*)s) +#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s) +#define __Pyx_PyUnicode_FromOrdinal(o) PyUnicode_FromOrdinal((int)o) +#define __Pyx_PyUnicode_AsUnicode PyUnicode_AsUnicode +static CYTHON_INLINE PyObject *__Pyx_NewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_NewRef) + return Py_NewRef(obj); +#else + Py_INCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_XNewRef(PyObject *obj) { +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030a0000 || defined(Py_XNewRef) + return Py_XNewRef(obj); +#else + Py_XINCREF(obj); + return obj; +#endif +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b); +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b); +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*); +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*); +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x); +#define __Pyx_PySequence_Tuple(obj)\ + (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj)) +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*); +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t); +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*); +#if CYTHON_ASSUME_SAFE_MACROS +#define __Pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x)) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AS_DOUBLE(x) +#else +#define __Pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x) +#define __Pyx_PyFloat_AS_DOUBLE(x) PyFloat_AsDouble(x) +#endif +#define __Pyx_PyFloat_AsFloat(x) ((float) __Pyx_PyFloat_AsDouble(x)) +#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x)) +#if CYTHON_USE_PYLONG_INTERNALS + #if PY_VERSION_HEX >= 0x030C00A7 + #ifndef _PyLong_SIGN_MASK + #define _PyLong_SIGN_MASK 3 + #endif + #ifndef _PyLong_NON_SIZE_BITS + #define _PyLong_NON_SIZE_BITS 3 + #endif + #define __Pyx_PyLong_Sign(x) (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK) + #define __Pyx_PyLong_IsNeg(x) ((__Pyx_PyLong_Sign(x) & 2) != 0) + #define __Pyx_PyLong_IsNonNeg(x) (!__Pyx_PyLong_IsNeg(x)) + #define __Pyx_PyLong_IsZero(x) (__Pyx_PyLong_Sign(x) & 1) + #define __Pyx_PyLong_IsPos(x) (__Pyx_PyLong_Sign(x) == 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) (__Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_SignedDigitCount(x)\ + ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x)) + #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue) + #define __Pyx_PyLong_IsCompact(x) PyUnstable_Long_IsCompact((PyLongObject*) x) + #define __Pyx_PyLong_CompactValue(x) PyUnstable_Long_CompactValue((PyLongObject*) x) + #else + #define __Pyx_PyLong_IsCompact(x) (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS)) + #define __Pyx_PyLong_CompactValue(x) ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0]) + #endif + typedef Py_ssize_t __Pyx_compact_pylong; + typedef size_t __Pyx_compact_upylong; + #else + #define __Pyx_PyLong_IsNeg(x) (Py_SIZE(x) < 0) + #define __Pyx_PyLong_IsNonNeg(x) (Py_SIZE(x) >= 0) + #define __Pyx_PyLong_IsZero(x) (Py_SIZE(x) == 0) + #define __Pyx_PyLong_IsPos(x) (Py_SIZE(x) > 0) + #define __Pyx_PyLong_CompactValueUnsigned(x) ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0]) + #define __Pyx_PyLong_DigitCount(x) __Pyx_sst_abs(Py_SIZE(x)) + #define __Pyx_PyLong_SignedDigitCount(x) Py_SIZE(x) + #define __Pyx_PyLong_IsCompact(x) (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1) + #define __Pyx_PyLong_CompactValue(x)\ + ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0])) + typedef sdigit __Pyx_compact_pylong; + typedef digit __Pyx_compact_upylong; + #endif + #if PY_VERSION_HEX >= 0x030C00A5 + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->long_value.ob_digit) + #else + #define __Pyx_PyLong_Digits(x) (((PyLongObject*)x)->ob_digit) + #endif +#endif +#if __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL) +#elif __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeASCII(c_str, size, NULL) +#else + #define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL) +#endif + + +/* Test for GCC > 2.95 */ +#if defined(__GNUC__) && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95))) + #define likely(x) __builtin_expect(!!(x), 1) + #define unlikely(x) __builtin_expect(!!(x), 0) +#else /* !__GNUC__ or GCC < 2.95 */ + #define likely(x) (x) + #define unlikely(x) (x) +#endif /* __GNUC__ */ +/* PretendToInitialize */ +#ifdef __cplusplus +#if __cplusplus > 201103L +#include +#endif +template +static void __Pyx_pretend_to_initialize(T* ptr) { +#if __cplusplus > 201103L + if ((std::is_trivially_default_constructible::value)) +#endif + *ptr = T(); + (void)ptr; +} +#else +static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; } +#endif + + +#if !CYTHON_USE_MODULE_STATE +static PyObject *__pyx_m = NULL; +#endif +static int __pyx_lineno; +static int __pyx_clineno = 0; +static const char * const __pyx_cfilenm = __FILE__; +static const char *__pyx_filename; + +/* Header.proto */ +#if !defined(CYTHON_CCOMPLEX) + #if defined(__cplusplus) + #define CYTHON_CCOMPLEX 1 + #elif (defined(_Complex_I) && !defined(_MSC_VER)) || ((defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) && !defined(__STDC_NO_COMPLEX__) && !defined(_MSC_VER)) + #define CYTHON_CCOMPLEX 1 + #else + #define CYTHON_CCOMPLEX 0 + #endif +#endif +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #include + #else + #include + #endif +#endif +#if CYTHON_CCOMPLEX && !defined(__cplusplus) && defined(__sun__) && defined(__GNUC__) + #undef _Complex_I + #define _Complex_I 1.0fj +#endif + +/* #### Code section: filename_table ### */ + +static const char* const __pyx_f[] = { + "src/cssm.pyx", + "", + "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd", + "cpython/type.pxd", +}; +/* #### Code section: utility_code_proto_before_types ### */ +/* Atomics.proto */ +#include +#ifndef CYTHON_ATOMICS + #define CYTHON_ATOMICS 1 +#endif +#define __PYX_CYTHON_ATOMICS_ENABLED() CYTHON_ATOMICS +#define __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __pyx_atomic_int_type int +#define __pyx_nonatomic_int_type int +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__)) + #include +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ + (defined(_MSC_VER) && _MSC_VER >= 1700))) + #include +#endif +#if CYTHON_ATOMICS && (defined(__STDC_VERSION__) &&\ + (__STDC_VERSION__ >= 201112L) &&\ + !defined(__STDC_NO_ATOMICS__) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type atomic_int + #define __pyx_atomic_ptr_type atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) atomic_fetch_add_explicit(value, 1, memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) atomic_fetch_add_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) atomic_fetch_sub_explicit(value, 1, memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) atomic_load(value) + #define __pyx_atomic_store(value, new_value) atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) atomic_load_explicit(value, memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) atomic_load_explicit(value, memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) atomic_compare_exchange_strong(value, expected, desired) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C atomics" + #endif +#elif CYTHON_ATOMICS && (defined(__cplusplus) && (\ + (__cplusplus >= 201103L) ||\ +\ + (defined(_MSC_VER) && _MSC_VER >= 1700)) &&\ + ATOMIC_INT_LOCK_FREE == 2) + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type std::atomic_int + #define __pyx_atomic_ptr_type std::atomic_uintptr_t + #define __pyx_nonatomic_ptr_type uintptr_t + #define __pyx_atomic_incr_relaxed(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_relaxed) + #define __pyx_atomic_incr_acq_rel(value) std::atomic_fetch_add_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_decr_acq_rel(value) std::atomic_fetch_sub_explicit(value, 1, std::memory_order_acq_rel) + #define __pyx_atomic_sub(value, arg) std::atomic_fetch_sub(value, arg) + #define __pyx_atomic_int_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #define __pyx_atomic_load(value) std::atomic_load(value) + #define __pyx_atomic_store(value, new_value) std::atomic_store(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) std::atomic_load_explicit(value, std::memory_order_relaxed) + #define __pyx_atomic_pointer_load_acquire(value) std::atomic_load_explicit(value, std::memory_order_acquire) + #define __pyx_atomic_pointer_exchange(value, new_value) std::atomic_exchange(value, (__pyx_nonatomic_ptr_type)new_value) + #define __pyx_atomic_pointer_cmp_exchange(value, expected, desired) std::atomic_compare_exchange_strong(value, expected, desired) + #if defined(__PYX_DEBUG_ATOMICS) && defined(_MSC_VER) + #pragma message ("Using standard C++ atomics") + #elif defined(__PYX_DEBUG_ATOMICS) + #warning "Using standard C++ atomics" + #endif +#elif CYTHON_ATOMICS && (__GNUC__ >= 5 || (__GNUC__ == 4 &&\ + (__GNUC_MINOR__ > 1 ||\ + (__GNUC_MINOR__ == 1 && __GNUC_PATCHLEVEL__ >= 2)))) + #define __pyx_atomic_ptr_type void* + #define __pyx_nonatomic_ptr_type void* + #define __pyx_atomic_incr_relaxed(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_incr_acq_rel(value) __sync_fetch_and_add(value, 1) + #define __pyx_atomic_decr_acq_rel(value) __sync_fetch_and_sub(value, 1) + #define __pyx_atomic_sub(value, arg) __sync_fetch_and_sub(value, arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_store(value, new_value) __sync_lock_test_and_set(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_load_acquire(value) __sync_fetch_and_add(value, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) __sync_lock_test_and_set(value, (__pyx_atomic_ptr_type)new_value) + static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { + __pyx_nonatomic_ptr_type old = __sync_val_compare_and_swap(value, *expected, desired); + int result = old == *expected; + *expected = old; + return result; + } + #ifdef __PYX_DEBUG_ATOMICS + #warning "Using GNU atomics" + #endif +#elif CYTHON_ATOMICS && defined(_MSC_VER) + #include + #undef __pyx_atomic_int_type + #define __pyx_atomic_int_type long + #define __pyx_atomic_ptr_type void* + #undef __pyx_nonatomic_int_type + #define __pyx_nonatomic_int_type long + #define __pyx_nonatomic_ptr_type void* + #pragma intrinsic (_InterlockedExchangeAdd, _InterlockedExchange, _InterlockedCompareExchange, _InterlockedCompareExchangePointer, _InterlockedExchangePointer) + #define __pyx_atomic_incr_relaxed(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_incr_acq_rel(value) _InterlockedExchangeAdd(value, 1) + #define __pyx_atomic_decr_acq_rel(value) _InterlockedExchangeAdd(value, -1) + #define __pyx_atomic_sub(value, arg) _InterlockedExchangeAdd(value, -arg) + static CYTHON_INLINE int __pyx_atomic_int_cmp_exchange(__pyx_atomic_int_type* value, __pyx_nonatomic_int_type* expected, __pyx_nonatomic_int_type desired) { + __pyx_nonatomic_int_type old = _InterlockedCompareExchange(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #define __pyx_atomic_load(value) _InterlockedExchangeAdd(value, 0) + #define __pyx_atomic_store(value, new_value) _InterlockedExchange(value, new_value) + #define __pyx_atomic_pointer_load_relaxed(value) *(void * volatile *)value + #define __pyx_atomic_pointer_load_acquire(value) _InterlockedCompareExchangePointer(value, 0, 0) + #define __pyx_atomic_pointer_exchange(value, new_value) _InterlockedExchangePointer(value, (__pyx_atomic_ptr_type)new_value) + static CYTHON_INLINE int __pyx_atomic_pointer_cmp_exchange(__pyx_atomic_ptr_type* value, __pyx_nonatomic_ptr_type* expected, __pyx_nonatomic_ptr_type desired) { + __pyx_atomic_ptr_type old = _InterlockedCompareExchangePointer(value, desired, *expected); + int result = old == *expected; + *expected = old; + return result; + } + #ifdef __PYX_DEBUG_ATOMICS + #pragma message ("Using MSVC atomics") + #endif +#else + #undef CYTHON_ATOMICS + #define CYTHON_ATOMICS 0 + #ifdef __PYX_DEBUG_ATOMICS + #warning "Not using atomics" + #endif +#endif + +/* CriticalSectionsDefinition.proto */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection void* +#define __Pyx_PyCriticalSection2 void* +#define __Pyx_PyCriticalSection_End(cs) +#define __Pyx_PyCriticalSection2_End(cs) +#else +#define __Pyx_PyCriticalSection PyCriticalSection +#define __Pyx_PyCriticalSection2 PyCriticalSection2 +#define __Pyx_PyCriticalSection_End PyCriticalSection_End +#define __Pyx_PyCriticalSection2_End PyCriticalSection2_End +#endif + +/* CriticalSections.proto */ +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +#define __Pyx_PyCriticalSection_Begin(cs, arg) (void)(cs) +#define __Pyx_PyCriticalSection2_Begin(cs, arg1, arg2) (void)(cs) +#else +#define __Pyx_PyCriticalSection_Begin PyCriticalSection_Begin +#define __Pyx_PyCriticalSection2_Begin PyCriticalSection2_Begin +#endif +#if PY_VERSION_HEX < 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_BEGIN_CRITICAL_SECTION(o) { +#define __Pyx_END_CRITICAL_SECTION() } +#else +#define __Pyx_BEGIN_CRITICAL_SECTION Py_BEGIN_CRITICAL_SECTION +#define __Pyx_END_CRITICAL_SECTION Py_END_CRITICAL_SECTION +#endif + +/* ForceInitThreads.proto */ +#ifndef __PYX_FORCE_INIT_THREADS + #define __PYX_FORCE_INIT_THREADS 0 +#endif + +/* NoFastGil.proto */ +#define __Pyx_PyGILState_Ensure PyGILState_Ensure +#define __Pyx_PyGILState_Release PyGILState_Release +#define __Pyx_FastGIL_Remember() +#define __Pyx_FastGIL_Forget() +#define __Pyx_FastGilFuncInit() + +/* BufferFormatStructs.proto */ +struct __Pyx_StructField_; +#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0) +typedef struct { + const char* name; + const struct __Pyx_StructField_* fields; + size_t size; + size_t arraysize[8]; + int ndim; + char typegroup; + char is_unsigned; + int flags; +} __Pyx_TypeInfo; +typedef struct __Pyx_StructField_ { + const __Pyx_TypeInfo* type; + const char* name; + size_t offset; +} __Pyx_StructField; +typedef struct { + const __Pyx_StructField* field; + size_t parent_offset; +} __Pyx_BufFmt_StackElem; +typedef struct { + __Pyx_StructField root; + __Pyx_BufFmt_StackElem* head; + size_t fmt_offset; + size_t new_count, enc_count; + size_t struct_alignment; + int is_complex; + char enc_type; + char new_packmode; + char enc_packmode; + char is_valid_array; +} __Pyx_BufFmt_Context; + +/* IncludeStructmemberH.proto */ +#include + +/* MemviewSliceStruct.proto */ +struct __pyx_memoryview_obj; +typedef struct { + struct __pyx_memoryview_obj *memview; + char *data; + Py_ssize_t shape[8]; + Py_ssize_t strides[8]; + Py_ssize_t suboffsets[8]; +} __Pyx_memviewslice; +#define __Pyx_MemoryView_Len(m) (m.shape[0]) +#define __Pyx_MEMVIEW_DIRECT 1 +#define __Pyx_MEMVIEW_PTR 2 +#define __Pyx_MEMVIEW_FULL 4 +#define __Pyx_MEMVIEW_CONTIG 8 +#define __Pyx_MEMVIEW_STRIDED 16 +#define __Pyx_MEMVIEW_FOLLOW 32 +#define __Pyx_IS_C_CONTIG 1 +#define __Pyx_IS_F_CONTIG 2 +#if CYTHON_ATOMICS + #define __pyx_add_acquisition_count(memview)\ + __pyx_atomic_incr_relaxed(__pyx_get_slice_count_pointer(memview)) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_atomic_decr_acq_rel(__pyx_get_slice_count_pointer(memview)) +#else + #define __pyx_add_acquisition_count(memview)\ + __pyx_add_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) + #define __pyx_sub_acquisition_count(memview)\ + __pyx_sub_acquisition_count_locked(__pyx_get_slice_count_pointer(memview), memview->lock) +#endif + +/* #### Code section: numeric_typedefs ### */ + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":743 + * # in Cython to enable them only on the right systems. + * + * ctypedef npy_int8 int8_t # <<<<<<<<<<<<<< + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t +*/ +typedef npy_int8 __pyx_t_5numpy_int8_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":744 + * + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t # <<<<<<<<<<<<<< + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t +*/ +typedef npy_int16 __pyx_t_5numpy_int16_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":745 + * ctypedef npy_int8 int8_t + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t # <<<<<<<<<<<<<< + * ctypedef npy_int64 int64_t + * +*/ +typedef npy_int32 __pyx_t_5numpy_int32_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":746 + * ctypedef npy_int16 int16_t + * ctypedef npy_int32 int32_t + * ctypedef npy_int64 int64_t # <<<<<<<<<<<<<< + * + * ctypedef npy_uint8 uint8_t +*/ +typedef npy_int64 __pyx_t_5numpy_int64_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":748 + * ctypedef npy_int64 int64_t + * + * ctypedef npy_uint8 uint8_t # <<<<<<<<<<<<<< + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t +*/ +typedef npy_uint8 __pyx_t_5numpy_uint8_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":749 + * + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t # <<<<<<<<<<<<<< + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t +*/ +typedef npy_uint16 __pyx_t_5numpy_uint16_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":750 + * ctypedef npy_uint8 uint8_t + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t # <<<<<<<<<<<<<< + * ctypedef npy_uint64 uint64_t + * +*/ +typedef npy_uint32 __pyx_t_5numpy_uint32_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":751 + * ctypedef npy_uint16 uint16_t + * ctypedef npy_uint32 uint32_t + * ctypedef npy_uint64 uint64_t # <<<<<<<<<<<<<< + * + * ctypedef npy_float32 float32_t +*/ +typedef npy_uint64 __pyx_t_5numpy_uint64_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":753 + * ctypedef npy_uint64 uint64_t + * + * ctypedef npy_float32 float32_t # <<<<<<<<<<<<<< + * ctypedef npy_float64 float64_t + * #ctypedef npy_float80 float80_t +*/ +typedef npy_float32 __pyx_t_5numpy_float32_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":754 + * + * ctypedef npy_float32 float32_t + * ctypedef npy_float64 float64_t # <<<<<<<<<<<<<< + * #ctypedef npy_float80 float80_t + * #ctypedef npy_float128 float128_t +*/ +typedef npy_float64 __pyx_t_5numpy_float64_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":761 + * ctypedef double complex complex128_t + * + * ctypedef npy_longlong longlong_t # <<<<<<<<<<<<<< + * ctypedef npy_ulonglong ulonglong_t + * +*/ +typedef npy_longlong __pyx_t_5numpy_longlong_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":762 + * + * ctypedef npy_longlong longlong_t + * ctypedef npy_ulonglong ulonglong_t # <<<<<<<<<<<<<< + * + * ctypedef npy_intp intp_t +*/ +typedef npy_ulonglong __pyx_t_5numpy_ulonglong_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":764 + * ctypedef npy_ulonglong ulonglong_t + * + * ctypedef npy_intp intp_t # <<<<<<<<<<<<<< + * ctypedef npy_uintp uintp_t + * +*/ +typedef npy_intp __pyx_t_5numpy_intp_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":765 + * + * ctypedef npy_intp intp_t + * ctypedef npy_uintp uintp_t # <<<<<<<<<<<<<< + * + * ctypedef npy_double float_t +*/ +typedef npy_uintp __pyx_t_5numpy_uintp_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":767 + * ctypedef npy_uintp uintp_t + * + * ctypedef npy_double float_t # <<<<<<<<<<<<<< + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t +*/ +typedef npy_double __pyx_t_5numpy_float_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":768 + * + * ctypedef npy_double float_t + * ctypedef npy_double double_t # <<<<<<<<<<<<<< + * ctypedef npy_longdouble longdouble_t + * +*/ +typedef npy_double __pyx_t_5numpy_double_t; + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":769 + * ctypedef npy_double float_t + * ctypedef npy_double double_t + * ctypedef npy_longdouble longdouble_t # <<<<<<<<<<<<<< + * + * ctypedef float complex cfloat_t +*/ +typedef npy_longdouble __pyx_t_5numpy_longdouble_t; +/* #### Code section: complex_type_declarations ### */ +/* Declarations.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + typedef ::std::complex< double > __pyx_t_double_complex; + #else + typedef double _Complex __pyx_t_double_complex; + #endif +#else + typedef struct { double real, imag; } __pyx_t_double_complex; +#endif +static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double, double); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + typedef ::std::complex< float > __pyx_t_float_complex; + #else + typedef float _Complex __pyx_t_float_complex; + #endif +#else + typedef struct { float real, imag; } __pyx_t_float_complex; +#endif +static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float, float); + +/* Declarations.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + typedef ::std::complex< long double > __pyx_t_long_double_complex; + #else + typedef long double _Complex __pyx_t_long_double_complex; + #endif +#else + typedef struct { long double real, imag; } __pyx_t_long_double_complex; +#endif +static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double, long double); + +/* #### Code section: type_declarations ### */ + +/*--- Type declarations ---*/ +struct __pyx_defaults; +struct __pyx_defaults1; +struct __pyx_array_obj; +struct __pyx_MemviewEnum_obj; +struct __pyx_memoryview_obj; +struct __pyx_memoryviewslice_obj; + +/* "cssm.pyx":515 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ +struct __pyx_defaults { + PyObject_HEAD + PyObject *arg0; +}; + + +/* "cssm.pyx":682 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flex(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ +struct __pyx_defaults1 { + PyObject_HEAD + PyObject *arg0; + PyObject *arg1; +}; + + +/* "View.MemoryView":110 + * + * + * @cython.collection_type("sequence") # <<<<<<<<<<<<<< + * @cname("__pyx_array") + * cdef class array: +*/ +struct __pyx_array_obj { + PyObject_HEAD + struct __pyx_vtabstruct_array *__pyx_vtab; + char *data; + Py_ssize_t len; + char *format; + int ndim; + Py_ssize_t *_shape; + Py_ssize_t *_strides; + Py_ssize_t itemsize; + PyObject *mode; + PyObject *_format; + void (*callback_free_data)(void *); + int free_data; + int dtype_is_object; +}; + + +/* "View.MemoryView":299 + * + * + * @cname('__pyx_MemviewEnum') # <<<<<<<<<<<<<< + * cdef class Enum(object): + * cdef object name +*/ +struct __pyx_MemviewEnum_obj { + PyObject_HEAD + PyObject *name; +}; + + +/* "View.MemoryView":334 + * + * + * @cname('__pyx_memoryview') # <<<<<<<<<<<<<< + * cdef class memoryview: + * +*/ +struct __pyx_memoryview_obj { + PyObject_HEAD + struct __pyx_vtabstruct_memoryview *__pyx_vtab; + PyObject *obj; + PyObject *_size; + void *_unused; + PyThread_type_lock lock; + __pyx_atomic_int_type acquisition_count; + Py_buffer view; + int flags; + int dtype_is_object; + __Pyx_TypeInfo const *typeinfo; +}; + + +/* "View.MemoryView":951 + * + * + * @cython.collection_type("sequence") # <<<<<<<<<<<<<< + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): +*/ +struct __pyx_memoryviewslice_obj { + struct __pyx_memoryview_obj __pyx_base; + __Pyx_memviewslice from_slice; + PyObject *from_object; + PyObject *(*to_object_func)(char *); + int (*to_dtype_func)(char *, PyObject *); +}; + + + +/* "View.MemoryView":110 + * + * + * @cython.collection_type("sequence") # <<<<<<<<<<<<<< + * @cname("__pyx_array") + * cdef class array: +*/ + +struct __pyx_vtabstruct_array { + PyObject *(*get_memview)(struct __pyx_array_obj *); +}; +static struct __pyx_vtabstruct_array *__pyx_vtabptr_array; + + +/* "View.MemoryView":334 + * + * + * @cname('__pyx_memoryview') # <<<<<<<<<<<<<< + * cdef class memoryview: + * +*/ + +struct __pyx_vtabstruct_memoryview { + char *(*get_item_pointer)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*is_slice)(struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_slice_assignment)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*setitem_slice_assign_scalar)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *); + PyObject *(*setitem_indexed)(struct __pyx_memoryview_obj *, PyObject *, PyObject *); + PyObject *(*convert_item_to_object)(struct __pyx_memoryview_obj *, char *); + PyObject *(*assign_item_from_object)(struct __pyx_memoryview_obj *, char *, PyObject *); + PyObject *(*_get_base)(struct __pyx_memoryview_obj *); +}; +static struct __pyx_vtabstruct_memoryview *__pyx_vtabptr_memoryview; + + +/* "View.MemoryView":951 + * + * + * @cython.collection_type("sequence") # <<<<<<<<<<<<<< + * @cname('__pyx_memoryviewslice') + * cdef class _memoryviewslice(memoryview): +*/ + +struct __pyx_vtabstruct__memoryviewslice { + struct __pyx_vtabstruct_memoryview __pyx_base; +}; +static struct __pyx_vtabstruct__memoryviewslice *__pyx_vtabptr__memoryviewslice; +/* #### Code section: utility_code_proto ### */ + +/* --- Runtime support code (head) --- */ +/* Refnanny.proto */ +#ifndef CYTHON_REFNANNY + #define CYTHON_REFNANNY 0 +#endif +#if CYTHON_REFNANNY + typedef struct { + void (*INCREF)(void*, PyObject*, Py_ssize_t); + void (*DECREF)(void*, PyObject*, Py_ssize_t); + void (*GOTREF)(void*, PyObject*, Py_ssize_t); + void (*GIVEREF)(void*, PyObject*, Py_ssize_t); + void* (*SetupContext)(const char*, Py_ssize_t, const char*); + void (*FinishContext)(void**); + } __Pyx_RefNannyAPIStruct; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL; + static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname); + #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL; + #define __Pyx_RefNannySetupContext(name, acquire_gil)\ + if (acquire_gil) {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + PyGILState_Release(__pyx_gilstate_save);\ + } else {\ + __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), (__LINE__), (__FILE__));\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContextNogil() {\ + PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\ + __Pyx_RefNannyFinishContext();\ + PyGILState_Release(__pyx_gilstate_save);\ + } + #define __Pyx_RefNannyFinishContext()\ + __Pyx_RefNanny->FinishContext(&__pyx_refnanny) + #define __Pyx_INCREF(r) __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_DECREF(r) __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GOTREF(r) __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), (__LINE__)) + #define __Pyx_XINCREF(r) do { if((r) == NULL); else {__Pyx_INCREF(r); }} while(0) + #define __Pyx_XDECREF(r) do { if((r) == NULL); else {__Pyx_DECREF(r); }} while(0) + #define __Pyx_XGOTREF(r) do { if((r) == NULL); else {__Pyx_GOTREF(r); }} while(0) + #define __Pyx_XGIVEREF(r) do { if((r) == NULL); else {__Pyx_GIVEREF(r);}} while(0) +#else + #define __Pyx_RefNannyDeclarations + #define __Pyx_RefNannySetupContext(name, acquire_gil) + #define __Pyx_RefNannyFinishContextNogil() + #define __Pyx_RefNannyFinishContext() + #define __Pyx_INCREF(r) Py_INCREF(r) + #define __Pyx_DECREF(r) Py_DECREF(r) + #define __Pyx_GOTREF(r) + #define __Pyx_GIVEREF(r) + #define __Pyx_XINCREF(r) Py_XINCREF(r) + #define __Pyx_XDECREF(r) Py_XDECREF(r) + #define __Pyx_XGOTREF(r) + #define __Pyx_XGIVEREF(r) +#endif +#define __Pyx_Py_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; Py_XDECREF(tmp);\ + } while (0) +#define __Pyx_XDECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_XDECREF(tmp);\ + } while (0) +#define __Pyx_DECREF_SET(r, v) do {\ + PyObject *tmp = (PyObject *) r;\ + r = v; __Pyx_DECREF(tmp);\ + } while (0) +#define __Pyx_CLEAR(r) do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0) +#define __Pyx_XCLEAR(r) do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0) + +/* TupleAndListFromArray.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n); +#endif +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject* __Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n); +#endif + +/* IncludeStringH.proto */ +#include + +/* BytesEquals.proto */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals); + +/* UnicodeEquals.proto */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals); + +/* fastcall.proto */ +#if CYTHON_AVOID_BORROWED_REFS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_PySequence_ITEM(args, i) +#elif CYTHON_ASSUME_SAFE_MACROS + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_NewRef(__Pyx_PyTuple_GET_ITEM(args, i)) +#else + #define __Pyx_ArgRef_VARARGS(args, i) __Pyx_XNewRef(PyTuple_GetItem(args, i)) +#endif +#define __Pyx_NumKwargs_VARARGS(kwds) PyDict_Size(kwds) +#define __Pyx_KwValues_VARARGS(args, nargs) NULL +#define __Pyx_GetKwValue_VARARGS(kw, kwvalues, s) __Pyx_PyDict_GetItemStrWithError(kw, s) +#define __Pyx_KwargsAsDict_VARARGS(kw, kwvalues) PyDict_Copy(kw) +#if CYTHON_METH_FASTCALL + #define __Pyx_ArgRef_FASTCALL(args, i) __Pyx_NewRef(args[i]) + #define __Pyx_NumKwargs_FASTCALL(kwds) __Pyx_PyTuple_GET_SIZE(kwds) + #define __Pyx_KwValues_FASTCALL(args, nargs) ((args) + (nargs)) + static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API + CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues); + #else + #define __Pyx_KwargsAsDict_FASTCALL(kw, kwvalues) _PyStack_AsDict(kwvalues, kw) + #endif +#else + #define __Pyx_ArgRef_FASTCALL __Pyx_ArgRef_VARARGS + #define __Pyx_NumKwargs_FASTCALL __Pyx_NumKwargs_VARARGS + #define __Pyx_KwValues_FASTCALL __Pyx_KwValues_VARARGS + #define __Pyx_GetKwValue_FASTCALL __Pyx_GetKwValue_VARARGS + #define __Pyx_KwargsAsDict_FASTCALL __Pyx_KwargsAsDict_VARARGS +#endif +#define __Pyx_ArgsSlice_VARARGS(args, start, stop) PyTuple_GetSlice(args, start, stop) +#if CYTHON_METH_FASTCALL || (CYTHON_COMPILING_IN_CPYTHON && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) __Pyx_PyTuple_FromArray(args + start, stop - start) +#else +#define __Pyx_ArgsSlice_FASTCALL(args, start, stop) PyTuple_GetSlice(args, start, stop) +#endif + +/* py_dict_items.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d); + +/* CallCFunction.proto */ +#define __Pyx_CallCFunction(cfunc, self, args)\ + ((PyCFunction)(void(*)(void))(cfunc)->func)(self, args) +#define __Pyx_CallCFunctionWithKeywords(cfunc, self, args, kwargs)\ + ((PyCFunctionWithKeywords)(void(*)(void))(cfunc)->func)(self, args, kwargs) +#define __Pyx_CallCFunctionFast(cfunc, self, args, nargs)\ + ((__Pyx_PyCFunctionFast)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs) +#define __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, nargs, kwnames)\ + ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))(PyCFunction)(cfunc)->func)(self, args, nargs, kwnames) + +/* PyObjectCall.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw); +#else +#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw) +#endif + +/* PyObjectCallMethO.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg); +#endif + +/* PyObjectFastCall.proto */ +#define __Pyx_PyObject_FastCall(func, args, nargs) __Pyx_PyObject_FastCallDict(func, args, (size_t)(nargs), NULL) +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs); + +/* PyObjectCallOneArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg); + +/* PyObjectGetAttrStr.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name); +#else +#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n) +#endif + +/* UnpackUnboundCMethod.proto */ +typedef struct { + PyObject *type; + PyObject **method_name; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && CYTHON_ATOMICS + __pyx_atomic_int_type initialized; +#endif + PyCFunction func; + PyObject *method; + int flag; +} __Pyx_CachedCFunction; +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING +static CYTHON_INLINE int __Pyx_CachedCFunction_GetAndSetInitializing(__Pyx_CachedCFunction *cfunc) { +#if !CYTHON_ATOMICS + return 1; +#else + __pyx_nonatomic_int_type expected = 0; + if (__pyx_atomic_int_cmp_exchange(&cfunc->initialized, &expected, 1)) { + return 0; + } + return expected; +#endif +} +static CYTHON_INLINE void __Pyx_CachedCFunction_SetFinishedInitializing(__Pyx_CachedCFunction *cfunc) { +#if CYTHON_ATOMICS + __pyx_atomic_store(&cfunc->initialized, 2); +#endif +} +#else +#define __Pyx_CachedCFunction_GetAndSetInitializing(cfunc) 2 +#define __Pyx_CachedCFunction_SetFinishedInitializing(cfunc) +#endif + +/* CallUnboundCMethod0.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self); +#else +#define __Pyx_CallUnboundCMethod0(cfunc, self) __Pyx__CallUnboundCMethod0(cfunc, self) +#endif + +/* py_dict_values.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d); + +/* OwnedDictNext.proto */ +#if CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue); +#else +CYTHON_INLINE +static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue); +#endif + +/* RaiseDoubleKeywords.proto */ +static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name); + +/* ParseKeywordsImpl.export */ +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name +); +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* CallUnboundCMethod2.proto */ +CYTHON_UNUSED +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2); +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2); +#else +#define __Pyx_CallUnboundCMethod2(cfunc, self, arg1, arg2) __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2) +#endif + +/* ParseKeywords.proto */ +static CYTHON_INLINE int __Pyx_ParseKeywords( + PyObject *kwds, PyObject *const *kwvalues, PyObject ** const argnames[], + PyObject *kwds2, PyObject *values[], + Py_ssize_t num_pos_args, Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs +); + +/* RaiseArgTupleInvalid.proto */ +static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact, + Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found); + +/* ArgTypeTestFunc.export */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact); + +/* ArgTypeTest.proto */ +#define __Pyx_ArgTypeTest(obj, type, none_allowed, name, exact)\ + ((likely(__Pyx_IS_TYPE(obj, type) | (none_allowed && (obj == Py_None)))) ? 1 :\ + __Pyx__ArgTypeTest(obj, type, name, exact)) + +/* PyErrExceptionMatches.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState(__pyx_tstate, err) +static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err); +#else +#define __Pyx_PyErr_ExceptionMatches(err) PyErr_ExceptionMatches(err) +#endif + +/* PyThreadStateGet.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyThreadState_declare PyThreadState *__pyx_tstate; +#define __Pyx_PyThreadState_assign __pyx_tstate = __Pyx_PyThreadState_Current; +#if PY_VERSION_HEX >= 0x030C00A6 +#define __Pyx_PyErr_Occurred() (__pyx_tstate->current_exception != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->current_exception ? (PyObject*) Py_TYPE(__pyx_tstate->current_exception) : (PyObject*) NULL) +#else +#define __Pyx_PyErr_Occurred() (__pyx_tstate->curexc_type != NULL) +#define __Pyx_PyErr_CurrentExceptionType() (__pyx_tstate->curexc_type) +#endif +#else +#define __Pyx_PyThreadState_declare +#define __Pyx_PyThreadState_assign +#define __Pyx_PyErr_Occurred() (PyErr_Occurred() != NULL) +#define __Pyx_PyErr_CurrentExceptionType() PyErr_Occurred() +#endif + +/* PyErrFetchRestore.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL) +#define __Pyx_ErrRestoreWithState(type, value, tb) __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) __Pyx_ErrRestoreInState(__pyx_tstate, type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6 +#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL)) +#else +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#endif +#else +#define __Pyx_PyErr_Clear() PyErr_Clear() +#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc) +#define __Pyx_ErrRestoreWithState(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchWithState(type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestoreInState(tstate, type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetchInState(tstate, type, value, tb) PyErr_Fetch(type, value, tb) +#define __Pyx_ErrRestore(type, value, tb) PyErr_Restore(type, value, tb) +#define __Pyx_ErrFetch(type, value, tb) PyErr_Fetch(type, value, tb) +#endif + +/* PyObjectGetAttrStrNoError.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name); + +/* GetBuiltinName.proto */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name); + +/* PyValueError_Check.proto */ +#define __Pyx_PyExc_ValueError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ValueError) + +/* RaiseException.export */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); + +/* PyObjectFastCallMethod.proto */ +#if CYTHON_VECTORCALL && PY_VERSION_HEX >= 0x03090000 +#define __Pyx_PyObject_FastCallMethod(name, args, nargsf) PyObject_VectorcallMethod(name, args, nargsf, NULL) +#else +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf); +#endif + +/* RaiseUnexpectedTypeError.proto */ +static int __Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj); + +/* PyMemoryError_Check.proto */ +#define __Pyx_PyExc_MemoryError_Check(obj) __Pyx_TypeCheck(obj, PyExc_MemoryError) + +/* BuildPyUnicode.proto */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char); + +/* COrdinalToPyUnicode.proto */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value); +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t width, char padding_char); + +/* GCCDiagnostics.proto */ +#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) +#define __Pyx_HAS_GCC_DIAGNOSTIC +#endif + +/* IncludeStdlibH.proto */ +#include + +/* CIntToPyUnicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char); + +/* CIntToPyUnicode.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char); + +/* JoinPyUnicode.export */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char); + +/* PyObjectFormatSimple.proto */ +#if CYTHON_COMPILING_IN_PYPY + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#elif CYTHON_USE_TYPE_SLOTS + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + likely(PyLong_CheckExact(s)) ? PyLong_Type.tp_repr(s) :\ + likely(PyFloat_CheckExact(s)) ? PyFloat_Type.tp_repr(s) :\ + PyObject_Format(s, f)) +#else + #define __Pyx_PyObject_FormatSimple(s, f) (\ + likely(PyUnicode_CheckExact(s)) ? (Py_INCREF(s), s) :\ + PyObject_Format(s, f)) +#endif + +CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *); /*proto*/ +/* GetAttr.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *, PyObject *); + +/* GetItemInt.proto */ +#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck, unsafe_shared) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\ + __Pyx_GetItemInt_Generic(o, to_py_func(i)))) +#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ + (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared); +#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck, unsafe_shared) :\ + (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL)) +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared); +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j); +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, + int is_list, int wraparound, int boundscheck, int unsafe_shared); + +/* ObjectGetItem.proto */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key); +#else +#define __Pyx_PyObject_GetItem(obj, key) PyObject_GetItem(obj, key) +#endif + +/* RejectKeywords.export */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds); + +/* PyTypeError_Check.proto */ +#define __Pyx_PyExc_TypeError_Check(obj) __Pyx_TypeCheck(obj, PyExc_TypeError) + +/* DivInt[Py_ssize_t].proto */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t, Py_ssize_t, int b_is_constant); + +/* UnaryNegOverflows.proto */ +#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)\ + (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x))) + +/* GetAttr3.proto */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *, PyObject *, PyObject *); + +/* PyDictVersioning.proto */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +#define __PYX_DICT_VERSION_INIT ((PY_UINT64_T) -1) +#define __PYX_GET_DICT_VERSION(dict) (((PyDictObject*)(dict))->ma_version_tag) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var)\ + (version_var) = __PYX_GET_DICT_VERSION(dict);\ + (cache_var) = (value); +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + if (likely(__PYX_GET_DICT_VERSION(DICT) == __pyx_dict_version)) {\ + (VAR) = __Pyx_XNewRef(__pyx_dict_cached_value);\ + } else {\ + (VAR) = __pyx_dict_cached_value = (LOOKUP);\ + __pyx_dict_version = __PYX_GET_DICT_VERSION(DICT);\ + }\ +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj); +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj); +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version); +#else +#define __PYX_GET_DICT_VERSION(dict) (0) +#define __PYX_UPDATE_DICT_CACHE(dict, value, cache_var, version_var) +#define __PYX_PY_DICT_LOOKUP_IF_MODIFIED(VAR, DICT, LOOKUP) (VAR) = (LOOKUP); +#endif + +/* GetModuleGlobalName.proto */ +#if CYTHON_USE_DICT_VERSIONS +#define __Pyx_GetModuleGlobalName(var, name) do {\ + static PY_UINT64_T __pyx_dict_version = 0;\ + static PyObject *__pyx_dict_cached_value = NULL;\ + (var) = (likely(__pyx_dict_version == __PYX_GET_DICT_VERSION(__pyx_mstate_global->__pyx_d))) ?\ + (likely(__pyx_dict_cached_value) ? __Pyx_NewRef(__pyx_dict_cached_value) : __Pyx_GetBuiltinName(name)) :\ + __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +#define __Pyx_GetModuleGlobalNameUncached(var, name) do {\ + PY_UINT64_T __pyx_dict_version;\ + PyObject *__pyx_dict_cached_value;\ + (var) = __Pyx__GetModuleGlobalName(name, &__pyx_dict_version, &__pyx_dict_cached_value);\ +} while(0) +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value); +#else +#define __Pyx_GetModuleGlobalName(var, name) (var) = __Pyx__GetModuleGlobalName(name) +#define __Pyx_GetModuleGlobalNameUncached(var, name) (var) = __Pyx__GetModuleGlobalName(name) +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name); +#endif + +/* AssertionsEnabled.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000 + static int __pyx_assertions_enabled_flag; + #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag) + static int __Pyx_init_assertions_enabled(void) { + PyObject *builtins, *debug, *debug_str; + int flag; + builtins = PyEval_GetBuiltins(); + if (!builtins) goto bad; + debug_str = PyUnicode_FromStringAndSize("__debug__", 9); + if (!debug_str) goto bad; + debug = PyObject_GetItem(builtins, debug_str); + Py_DECREF(debug_str); + if (!debug) goto bad; + flag = PyObject_IsTrue(debug); + Py_DECREF(debug); + if (flag == -1) goto bad; + __pyx_assertions_enabled_flag = flag; + return 0; + bad: + __pyx_assertions_enabled_flag = 1; + return -1; + } +#else + #define __Pyx_init_assertions_enabled() (0) + #define __pyx_assertions_enabled() (!Py_OptimizeFlag) +#endif + +/* PyAssertionError_Check.proto */ +#define __Pyx_PyExc_AssertionError_Check(obj) __Pyx_TypeCheck(obj, PyExc_AssertionError) + +/* RaiseTooManyValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected); + +/* RaiseNeedMoreValuesToUnpack.proto */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index); + +/* RaiseNoneIterError.proto */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void); + +/* ExtTypeTest.proto */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type); + +/* GetTopmostException.proto */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate); +#endif + +/* SaveResetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSave(type, value, tb) __Pyx__ExceptionSave(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#define __Pyx_ExceptionReset(type, value, tb) __Pyx__ExceptionReset(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); +#else +#define __Pyx_ExceptionSave(type, value, tb) PyErr_GetExcInfo(type, value, tb) +#define __Pyx_ExceptionReset(type, value, tb) PyErr_SetExcInfo(type, value, tb) +#endif + +/* GetException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_GetException(type, value, tb) __Pyx__GetException(__pyx_tstate, type, value, tb) +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* SwapException.proto */ +#if CYTHON_FAST_THREAD_STATE +#define __Pyx_ExceptionSwap(type, value, tb) __Pyx__ExceptionSwap(__pyx_tstate, type, value, tb) +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); +#endif + +/* HasAttr.proto */ +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_HasAttr(o, n) PyObject_HasAttrWithError(o, n) +#else +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *, PyObject *); +#endif + +/* Import.export */ +static PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level); + +/* FastTypeChecks.proto */ +#if CYTHON_COMPILING_IN_CPYTHON +#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) __Pyx_IsAnySubtype2(Py_TYPE(obj), (PyTypeObject *)type1, (PyTypeObject *)type2) +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type); +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2); +#else +#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type) +#define __Pyx_TypeCheck2(obj, type1, type2) (PyObject_TypeCheck(obj, (PyTypeObject *)type1) || PyObject_TypeCheck(obj, (PyTypeObject *)type2)) +#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type) +static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2) { + return PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2); +} +#endif +#define __Pyx_PyErr_ExceptionMatches2(err1, err2) __Pyx_PyErr_GivenExceptionMatches2(__Pyx_PyErr_CurrentExceptionType(), err1, err2) +#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception) +#ifdef PyExceptionInstance_Check + #define __Pyx_PyBaseException_Check(obj) PyExceptionInstance_Check(obj) +#else + #define __Pyx_PyBaseException_Check(obj) __Pyx_TypeCheck(obj, PyExc_BaseException) +#endif + +CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +/* ListCompAppend.proto */ +#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS +static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) { + PyListObject* L = (PyListObject*) list; + Py_ssize_t len = Py_SIZE(list); + if (likely(L->allocated > len)) { + Py_INCREF(x); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 + L->ob_item[len] = x; + #else + PyList_SET_ITEM(list, len, x); + #endif + __Pyx_SET_SIZE(list, len + 1); + return 0; + } + return PyList_Append(list, x); +} +#else +#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x) +#endif + +/* PySequenceMultiply.proto */ +#define __Pyx_PySequence_Multiply_Left(mul, seq) __Pyx_PySequence_Multiply(seq, mul) +static CYTHON_INLINE PyObject* __Pyx_PySequence_Multiply(PyObject *seq, Py_ssize_t mul); + +/* PyObjectFormatAndDecref.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f); +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f); + +/* PyObjectFormat.proto */ +#if CYTHON_USE_UNICODE_WRITER +static PyObject* __Pyx_PyObject_Format(PyObject* s, PyObject* f); +#else +#define __Pyx_PyObject_Format(s, f) PyObject_Format(s, f) +#endif + +/* SetItemInt.proto */ +#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck, has_gil, unsafe_shared)\ + (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\ + __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck, unsafe_shared) :\ + (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\ + __Pyx_SetItemInt_Generic(o, to_py_func(i), v))) +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v); +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, + int is_list, int wraparound, int boundscheck, int unsafe_shared); + +/* RaiseUnboundLocalError.proto */ +static void __Pyx_RaiseUnboundLocalError(const char *varname); + +/* PyIndexError_Check.proto */ +#define __Pyx_PyExc_IndexError_Check(obj) __Pyx_TypeCheck(obj, PyExc_IndexError) + +/* DivInt[long].proto */ +static CYTHON_INLINE long __Pyx_div_long(long, long, int b_is_constant); + +/* PyImportError_Check.proto */ +#define __Pyx_PyExc_ImportError_Check(obj) __Pyx_TypeCheck(obj, PyExc_ImportError) + +/* PyObjectVectorCallKwBuilder.proto */ +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#if CYTHON_VECTORCALL +#if PY_VERSION_HEX >= 0x03090000 +#define __Pyx_Object_Vectorcall_CallFromBuilder PyObject_Vectorcall +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder _PyObject_Vectorcall +#endif +#define __Pyx_MakeVectorcallBuilderKwds(n) PyTuple_New(n) +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n); +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n); +#else +#define __Pyx_Object_Vectorcall_CallFromBuilder __Pyx_PyObject_FastCallDict +#define __Pyx_MakeVectorcallBuilderKwds(n) __Pyx_PyDict_NewPresized(n) +#define __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n) PyDict_SetItem(builder, key, value) +#define __Pyx_VectorcallBuilder_AddArgStr(key, value, builder, args, n) PyDict_SetItemString(builder, key, value) +#endif + +/* IsLittleEndian.proto */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void); + +/* BufferFormatCheck.proto */ +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts); +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + const __Pyx_TypeInfo* type); + +/* BufferGetAndValidate.proto */ +#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)\ + ((obj == Py_None || obj == NULL) ?\ + (__Pyx_ZeroBuffer(buf), 0) :\ + __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack)) +static int __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj, + const __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack); +static void __Pyx_ZeroBuffer(Py_buffer* buf); +static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info); +static Py_ssize_t __Pyx_minusones[] = { -1, -1, -1, -1, -1, -1, -1, -1 }; +static Py_ssize_t __Pyx_zeros[] = { 0, 0, 0, 0, 0, 0, 0, 0 }; + +/* PyLongBinop.proto */ +#if !CYTHON_COMPILING_IN_PYPY +static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); +#else +#define __Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check)\ + (inplace ? PyNumber_InPlaceAdd(op1, op2) : PyNumber_Add(op1, op2)) +#endif + +/* IterFinish.proto */ +static CYTHON_INLINE int __Pyx_IterFinish(void); + +/* PyObjectCallNoArg.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func); + +/* PyObjectGetMethod.proto */ +#if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) +static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method); +#endif + +/* PyObjectCallMethod0.proto */ +static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name); + +/* UnpackItemEndCheck.proto */ +static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected); + +/* UnpackTupleError.proto */ +static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index); + +/* UnpackTuple2.proto */ +static CYTHON_INLINE int __Pyx_unpack_tuple2( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple); +static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple); +static int __Pyx_unpack_tuple2_generic( + PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple); + +/* dict_iter.proto */ +static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_is_dict); +static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict); + +/* MergeKeywords.proto */ +static int __Pyx_MergeKeywords(PyObject *kwdict, PyObject *source_mapping); + +/* SliceObject.proto */ +#define __Pyx_PyObject_DelSlice(obj, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound)\ + __Pyx_PyObject_SetSlice(obj, (PyObject*)NULL, cstart, cstop, py_start, py_stop, py_slice, has_cstart, has_cstop, wraparound) +static CYTHON_INLINE int __Pyx_PyObject_SetSlice( + PyObject* obj, PyObject* value, Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** py_start, PyObject** py_stop, PyObject** py_slice, + int has_cstart, int has_cstop, int wraparound); + +/* RaiseMappingExpected.proto */ +static void __Pyx_RaiseMappingExpectedError(PyObject* arg); + +#define __Pyx_BufPtrStrided2d(type, buf, i0, s0, i1, s1) (type)((char*)buf + i0 * s0 + i1 * s1) +/* PyRange_Check.proto */ +#if CYTHON_COMPILING_IN_PYPY && !defined(PyRange_Check) + #define PyRange_Check(obj) __Pyx_TypeCheck((obj), &PyRange_Type) +#endif + +/* PyObject_Unicode.proto */ +#define __Pyx_PyObject_Unicode(obj)\ + (likely(PyUnicode_CheckExact(obj)) ? __Pyx_NewRef(obj) : PyObject_Str(obj)) + +/* BufferFallbackError.proto */ +static void __Pyx_RaiseBufferFallbackError(void); + +/* PyLongCompare.proto */ +static CYTHON_INLINE int __Pyx_PyLong_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace); + +#define __Pyx_BufPtrStrided1d(type, buf, i0, s0) (type)((char*)buf + i0 * s0) +/* AllocateExtensionType.proto */ +static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final); + +/* CallTypeTraverse.proto */ +#if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) +#define __Pyx_call_type_traverse(o, always_call, visit, arg) 0 +#else +static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg); +#endif + +/* DefaultPlacementNew.proto */ +#include +template +void __Pyx_default_placement_construct(T* x) { + new (static_cast(x)) T(); +} + +/* LimitedApiGetTypeDict.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp); +#endif + +/* SetItemOnTypeDict.proto */ +static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v); +#define __Pyx_SetItemOnTypeDict(tp, k, v) __Pyx__SetItemOnTypeDict((PyTypeObject*)tp, k, v) + +/* FixUpExtensionType.proto */ +static CYTHON_INLINE int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type); + +/* ValidateBasesTuple.proto */ +#if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS +static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases); +#endif + +/* PyType_Ready.proto */ +CYTHON_UNUSED static int __Pyx_PyType_Ready(PyTypeObject *t); + +/* SetVTable.proto */ +static int __Pyx_SetVtable(PyTypeObject* typeptr , void* vtable); + +/* GetVTable.proto */ +static void* __Pyx_GetVtable(PyTypeObject *type); + +/* MergeVTables.proto */ +static int __Pyx_MergeVtables(PyTypeObject *type); + +/* DelItemOnTypeDict.proto */ +static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k); +#define __Pyx_DelItemOnTypeDict(tp, k) __Pyx__DelItemOnTypeDict((PyTypeObject*)tp, k) + +/* SetupReduce.proto */ +static int __Pyx_setup_reduce(PyObject* type_obj); + +/* TypeImport.proto */ +#ifndef __PYX_HAVE_RT_ImportType_proto_3_2_0 +#define __PYX_HAVE_RT_ImportType_proto_3_2_0 +#if defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L +#include +#endif +#if (defined (__STDC_VERSION__) && __STDC_VERSION__ >= 201112L) || __cplusplus >= 201103L +#define __PYX_GET_STRUCT_ALIGNMENT_3_2_0(s) alignof(s) +#else +#define __PYX_GET_STRUCT_ALIGNMENT_3_2_0(s) sizeof(void*) +#endif +enum __Pyx_ImportType_CheckSize_3_2_0 { + __Pyx_ImportType_CheckSize_Error_3_2_0 = 0, + __Pyx_ImportType_CheckSize_Warn_3_2_0 = 1, + __Pyx_ImportType_CheckSize_Ignore_3_2_0 = 2 +}; +static PyTypeObject *__Pyx_ImportType_3_2_0(PyObject* module, const char *module_name, const char *class_name, size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_0 check_size); +#endif + +/* dict_setdefault.proto */ +static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value); + +/* AddModuleRef.proto */ +#if ((CYTHON_COMPILING_IN_CPYTHON_FREETHREADING ) ||\ + __PYX_LIMITED_VERSION_HEX < 0x030d0000) + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name); +#else + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) +#endif + +/* FetchSharedCythonModule.proto */ +static PyObject *__Pyx_FetchSharedCythonABIModule(void); + +/* FetchCommonType.proto */ +static PyTypeObject* __Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases); + +/* CommonTypesMetaclass.proto */ +static int __pyx_CommonTypesMetaclass_init(PyObject *module); +#define __Pyx_CommonTypesMetaclass_USED + +/* PyMethodNew.proto */ +static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ); + +/* PyVectorcallFastCallDict.proto */ +#if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL +static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw); +#endif + +/* CythonFunctionShared.proto */ +#define __Pyx_CyFunction_USED +#define __Pyx_CYFUNCTION_STATICMETHOD 0x01 +#define __Pyx_CYFUNCTION_CLASSMETHOD 0x02 +#define __Pyx_CYFUNCTION_CCLASS 0x04 +#define __Pyx_CYFUNCTION_COROUTINE 0x08 +#define __Pyx_CyFunction_GetClosure(f)\ + (((__pyx_CyFunctionObject *) (f))->func_closure) +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_GetClassObj(f)\ + (((__pyx_CyFunctionObject *) (f))->func_classobj) +#else + #define __Pyx_CyFunction_GetClassObj(f)\ + ((PyObject*) ((PyCMethodObject *) (f))->mm_class) +#endif +#define __Pyx_CyFunction_SetClassObj(f, classobj)\ + __Pyx__CyFunction_SetClassObj((__pyx_CyFunctionObject *) (f), (classobj)) +#define __Pyx_CyFunction_Defaults(type, f)\ + ((type *)(((__pyx_CyFunctionObject *) (f))->defaults)) +#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\ + ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g) +typedef struct { +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject_HEAD + PyObject *func; +#elif PY_VERSION_HEX < 0x030900B1 + PyCFunctionObject func; +#else + PyCMethodObject func; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API && CYTHON_METH_FASTCALL + __pyx_vectorcallfunc func_vectorcall; +#endif +#if CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_weakreflist; +#endif +#if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_dict; +#endif + PyObject *func_name; + PyObject *func_qualname; + PyObject *func_doc; + PyObject *func_globals; + PyObject *func_code; + PyObject *func_closure; +#if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + PyObject *func_classobj; +#endif + PyObject *defaults; + int flags; + PyObject *defaults_tuple; + PyObject *defaults_kwdict; + PyObject *(*defaults_getter)(PyObject *); + PyObject *func_annotations; + PyObject *func_is_coroutine; +} __pyx_CyFunctionObject; +#undef __Pyx_CyOrPyCFunction_Check +#define __Pyx_CyFunction_Check(obj) __Pyx_TypeCheck(obj, __pyx_mstate_global->__pyx_CyFunctionType) +#define __Pyx_CyOrPyCFunction_Check(obj) __Pyx_TypeCheck2(obj, __pyx_mstate_global->__pyx_CyFunctionType, &PyCFunction_Type) +#define __Pyx_CyFunction_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_mstate_global->__pyx_CyFunctionType) +static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)); +#undef __Pyx_IsSameCFunction +#define __Pyx_IsSameCFunction(func, cfunc) __Pyx__IsSameCyOrCFunction(func, cfunc) +static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject* op, PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); +static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj); +static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, + PyTypeObject *defaults_type); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m, + PyObject *tuple); +static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m, + PyObject *dict); +static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m, + PyObject *dict); +static int __pyx_CyFunction_init(PyObject *module); +#if CYTHON_METH_FASTCALL +static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames); +#if CYTHON_COMPILING_IN_LIMITED_API +#define __Pyx_CyFunction_func_vectorcall(f) (((__pyx_CyFunctionObject*)f)->func_vectorcall) +#else +#define __Pyx_CyFunction_func_vectorcall(f) (((PyCFunctionObject*)f)->vectorcall) +#endif +#endif + +/* CythonFunction.proto */ +static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, + int flags, PyObject* qualname, + PyObject *closure, + PyObject *module, PyObject *globals, + PyObject* code); + +/* CLineInTraceback.proto */ +#if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME +static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line); +#else +#define __Pyx_CLineForTraceback(tstate, c_line) (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0) +#endif + +/* CodeObjectCache.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject __Pyx_CachedCodeObjectType; +#else +typedef PyCodeObject __Pyx_CachedCodeObjectType; +#endif +typedef struct { + __Pyx_CachedCodeObjectType* code_object; + int code_line; +} __Pyx_CodeObjectCacheEntry; +struct __Pyx_CodeObjectCache { + int count; + int max_count; + __Pyx_CodeObjectCacheEntry* entries; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_int_type accessor_count; + #endif +}; +static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line); +static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line); +static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object); + +/* AddTraceback.proto */ +static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename); + +/* BufferStructDeclare.proto */ +typedef struct { + Py_ssize_t shape, strides, suboffsets; +} __Pyx_Buf_DimInfo; +typedef struct { + size_t refcount; + Py_buffer pybuffer; +} __Pyx_Buffer; +typedef struct { + __Pyx_Buffer *rcbuffer; + char *data; + __Pyx_Buf_DimInfo diminfo[8]; +} __Pyx_LocalBuf_ND; + +/* MemviewRefcount.proto */ +static CYTHON_INLINE int __pyx_add_acquisition_count_locked( + __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); +static CYTHON_INLINE int __pyx_sub_acquisition_count_locked( + __pyx_atomic_int_type *acquisition_count, PyThread_type_lock lock); +#define __pyx_get_slice_count_pointer(memview) (&memview->acquisition_count) +#define __PYX_INC_MEMVIEW(slice, have_gil) __Pyx_INC_MEMVIEW(slice, have_gil, __LINE__) +#define __PYX_XCLEAR_MEMVIEW(slice, have_gil) __Pyx_XCLEAR_MEMVIEW(slice, have_gil, __LINE__) +static CYTHON_INLINE void __Pyx_INC_MEMVIEW(__Pyx_memviewslice *, int, int); +static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *, int, int); + +/* MemviewSliceIsContig.proto */ +static int __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim); + +/* OverlappingSlices.proto */ +static int __pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize); + +/* MemviewSliceInit.proto */ +static int __Pyx_init_memviewslice( + struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference); + +/* TypeInfoCompare.proto */ +static int __pyx_typeinfo_cmp(const __Pyx_TypeInfo *a, const __Pyx_TypeInfo *b); + +/* MemviewSliceValidateAndInit.export */ +static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + const __Pyx_TypeInfo *dtype, + __Pyx_BufFmt_StackElem stack[], + __Pyx_memviewslice *memviewslice, + PyObject *original_obj); + +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_ds_float(PyObject *, int writable_flag); + +/* RealImag.proto */ +#if CYTHON_CCOMPLEX + #ifdef __cplusplus + #define __Pyx_CREAL(z) ((z).real()) + #define __Pyx_CIMAG(z) ((z).imag()) + #else + #define __Pyx_CREAL(z) (__real__(z)) + #define __Pyx_CIMAG(z) (__imag__(z)) + #endif +#else + #define __Pyx_CREAL(z) ((z).real) + #define __Pyx_CIMAG(z) ((z).imag) +#endif +#if defined(__cplusplus) && CYTHON_CCOMPLEX\ + && (defined(_WIN32) || defined(__clang__) || (defined(__GNUC__) && (__GNUC__ >= 5 || __GNUC__ == 4 && __GNUC_MINOR__ >= 4 )) || __cplusplus >= 201103) + #define __Pyx_SET_CREAL(z,x) ((z).real(x)) + #define __Pyx_SET_CIMAG(z,y) ((z).imag(y)) +#else + #define __Pyx_SET_CREAL(z,x) __Pyx_CREAL(z) = (x) + #define __Pyx_SET_CIMAG(z,y) __Pyx_CIMAG(z) = (y) +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #define __Pyx_c_eq_double(a, b) ((a)==(b)) + #define __Pyx_c_sum_double(a, b) ((a)+(b)) + #define __Pyx_c_diff_double(a, b) ((a)-(b)) + #define __Pyx_c_prod_double(a, b) ((a)*(b)) + #define __Pyx_c_quot_double(a, b) ((a)/(b)) + #define __Pyx_c_neg_double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_double(z) ((z)==(double)0) + #define __Pyx_c_conj_double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (::std::abs(z)) + #define __Pyx_c_pow_double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_double(z) ((z)==0) + #define __Pyx_c_conj_double(z) (conj(z)) + #if 1 + #define __Pyx_c_abs_double(z) (cabs(z)) + #define __Pyx_c_pow_double(a, b) (cpow(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex, __pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex); + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex); + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex, __pyx_t_double_complex); + #endif +#endif + +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_float(PyObject *, int writable_flag); + +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(PyObject *, int writable_flag); + +/* ObjectToMemviewSlice.proto */ +static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(PyObject *, int writable_flag); + +/* MemviewDtypeToObject.proto */ +static CYTHON_INLINE PyObject *__pyx_memview_get_float(const char *itemp); +static CYTHON_INLINE int __pyx_memview_set_float(char *itemp, PyObject *obj); + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #define __Pyx_c_eq_float(a, b) ((a)==(b)) + #define __Pyx_c_sum_float(a, b) ((a)+(b)) + #define __Pyx_c_diff_float(a, b) ((a)-(b)) + #define __Pyx_c_prod_float(a, b) ((a)*(b)) + #define __Pyx_c_quot_float(a, b) ((a)/(b)) + #define __Pyx_c_neg_float(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_float(z) ((z)==(float)0) + #define __Pyx_c_conj_float(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_float(z) (::std::abs(z)) + #define __Pyx_c_pow_float(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_float(z) ((z)==0) + #define __Pyx_c_conj_float(z) (conjf(z)) + #if 1 + #define __Pyx_c_abs_float(z) (cabsf(z)) + #define __Pyx_c_pow_float(a, b) (cpowf(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex, __pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex); + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex); + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex, __pyx_t_float_complex); + #endif +#endif + +/* Arithmetic.proto */ +#if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #define __Pyx_c_eq_long__double(a, b) ((a)==(b)) + #define __Pyx_c_sum_long__double(a, b) ((a)+(b)) + #define __Pyx_c_diff_long__double(a, b) ((a)-(b)) + #define __Pyx_c_prod_long__double(a, b) ((a)*(b)) + #define __Pyx_c_quot_long__double(a, b) ((a)/(b)) + #define __Pyx_c_neg_long__double(a) (-(a)) + #ifdef __cplusplus + #define __Pyx_c_is_zero_long__double(z) ((z)==(long double)0) + #define __Pyx_c_conj_long__double(z) (::std::conj(z)) + #if 1 + #define __Pyx_c_abs_long__double(z) (::std::abs(z)) + #define __Pyx_c_pow_long__double(a, b) (::std::pow(a, b)) + #endif + #else + #define __Pyx_c_is_zero_long__double(z) ((z)==0) + #define __Pyx_c_conj_long__double(z) (conjl(z)) + #if 1 + #define __Pyx_c_abs_long__double(z) (cabsl(z)) + #define __Pyx_c_pow_long__double(a, b) (cpowl(a, b)) + #endif + #endif +#else + static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex); + static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex); + #if 1 + static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex); + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex, __pyx_t_long_double_complex); + #endif +#endif + +/* MemviewSliceCopyTemplate.proto */ +static __Pyx_memviewslice +__pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object); + +/* CIntFromPy.proto */ +static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value); + +/* CIntFromPy.proto */ +static CYTHON_INLINE npy_intp __Pyx_PyLong_As_npy_intp(PyObject *); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From_npy_intp(npy_intp value); + +/* CIntToPy.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyLong_From___pyx_anon_enum(int value); + +/* PyObjectCall2Args.proto */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2); + +/* PyObjectCallMethod1.proto */ +static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg); + +/* UpdateUnpickledDict.proto */ +static int __Pyx_UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index); + +/* CheckUnpickleChecksum.proto */ +static CYTHON_INLINE int __Pyx_CheckUnpickleChecksum(long checksum, long checksum1, long checksum2, long checksum3, const char *members); + +/* CIntFromPy.proto */ +static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *); + +/* CIntFromPy.proto */ +static CYTHON_INLINE char __Pyx_PyLong_As_char(PyObject *); + +/* FormatTypeName.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API +typedef PyObject *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%U" +#define __Pyx_DECREF_TypeName(obj) Py_XDECREF(obj) +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 +#define __Pyx_PyType_GetFullyQualifiedName PyType_GetFullyQualifiedName +#else +static __Pyx_TypeName __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp); +#endif +#else // !LIMITED_API +typedef const char *__Pyx_TypeName; +#define __Pyx_FMT_TYPENAME "%.200s" +#define __Pyx_PyType_GetFullyQualifiedName(tp) ((tp)->tp_name) +#define __Pyx_DECREF_TypeName(obj) +#endif + +/* GetRuntimeVersion.proto */ +#if __PYX_LIMITED_VERSION_HEX < 0x030b0000 +static unsigned long __Pyx_cached_runtime_version = 0; +static void __Pyx_init_runtime_version(void); +#else +#define __Pyx_init_runtime_version() +#endif +static unsigned long __Pyx_get_runtime_version(void); + +/* CheckBinaryVersion.proto */ +static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer); + +/* DecompressString.proto */ +static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo); + +/* MultiPhaseInitModuleState.proto */ +#if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE +static PyObject *__Pyx_State_FindModule(void*); +static int __Pyx_State_AddModule(PyObject* module, void*); +static int __Pyx_State_RemoveModule(void*); +#elif CYTHON_USE_MODULE_STATE +#define __Pyx_State_FindModule PyState_FindModule +#define __Pyx_State_AddModule PyState_AddModule +#define __Pyx_State_RemoveModule PyState_RemoveModule +#endif + +/* #### Code section: module_declarations ### */ +/* CythonABIVersion.proto */ +#if CYTHON_COMPILING_IN_LIMITED_API + #if CYTHON_METH_FASTCALL + #define __PYX_FASTCALL_ABI_SUFFIX "_fastcall" + #else + #define __PYX_FASTCALL_ABI_SUFFIX + #endif + #define __PYX_LIMITED_ABI_SUFFIX "limited" __PYX_FASTCALL_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#else + #define __PYX_LIMITED_ABI_SUFFIX +#endif +#if __PYX_HAS_PY_AM_SEND == 1 + #define __PYX_AM_SEND_ABI_SUFFIX +#elif __PYX_HAS_PY_AM_SEND == 2 + #define __PYX_AM_SEND_ABI_SUFFIX "amsendbackport" +#else + #define __PYX_AM_SEND_ABI_SUFFIX "noamsend" +#endif +#ifndef __PYX_MONITORING_ABI_SUFFIX + #define __PYX_MONITORING_ABI_SUFFIX +#endif +#if CYTHON_USE_TP_FINALIZE + #define __PYX_TP_FINALIZE_ABI_SUFFIX +#else + #define __PYX_TP_FINALIZE_ABI_SUFFIX "nofinalize" +#endif +#if CYTHON_USE_FREELISTS || !defined(__Pyx_AsyncGen_USED) + #define __PYX_FREELISTS_ABI_SUFFIX +#else + #define __PYX_FREELISTS_ABI_SUFFIX "nofreelists" +#endif +#define CYTHON_ABI __PYX_ABI_VERSION __PYX_LIMITED_ABI_SUFFIX __PYX_MONITORING_ABI_SUFFIX __PYX_TP_FINALIZE_ABI_SUFFIX __PYX_FREELISTS_ABI_SUFFIX __PYX_AM_SEND_ABI_SUFFIX +#define __PYX_ABI_MODULE_NAME "_cython_" CYTHON_ABI +#define __PYX_TYPE_MODULE_PREFIX __PYX_ABI_MODULE_NAME "." + +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self); /* proto*/ +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto*/ +static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj); /* proto*/ +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src); /* proto*/ +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ +static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self); /* proto*/ +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp); /* proto*/ +static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value); /* proto*/ +static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self); /* proto*/ +static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self); /* proto*/ + +/* Module declarations from "cython.view" */ + +/* Module declarations from "cython.dataclasses" */ + +/* Module declarations from "cython" */ + +/* Module declarations from "libc.string" */ + +/* Module declarations from "libc.stdlib" */ + +/* Module declarations from "libc.math" */ + +/* Module declarations from "libc.stddef" */ + +/* Module declarations from "libc.time" */ + +/* Module declarations from "libc.stdio" */ + +/* Module declarations from "__builtin__" */ + +/* Module declarations from "cpython.type" */ + +/* Module declarations from "cpython" */ + +/* Module declarations from "cpython.object" */ + +/* Module declarations from "cpython.ref" */ + +/* Module declarations from "numpy" */ + +/* Module declarations from "numpy" */ + +/* Module declarations from "cssm" */ +static PyObject *__pyx_collections_abc_Sequence = 0; +static PyObject *generic = 0; +static PyObject *strided = 0; +static PyObject *indirect = 0; +static PyObject *contiguous = 0; +static PyObject *indirect_contiguous = 0; +static int __pyx_memoryview_thread_locks_used; +static PyThread_type_lock __pyx_memoryview_thread_locks[8]; +static PyObject *__pyx_f_4cssm_set_seed(PyObject *); /*proto*/ +static float __pyx_f_4cssm_random_uniform(void); /*proto*/ +static float __pyx_f_4cssm_random_exponential(void); /*proto*/ +static float __pyx_f_4cssm_random_stable(float); /*proto*/ +static __Pyx_memviewslice __pyx_f_4cssm_draw_random_stable(int, float); /*proto*/ +static float __pyx_f_4cssm_random_gaussian(void); /*proto*/ +static int __pyx_f_4cssm_sign(float); /*proto*/ +static float __pyx_f_4cssm_csum(__Pyx_memviewslice); /*proto*/ +static void __pyx_f_4cssm_assign_random_gaussian_pair(__Pyx_memviewslice, int); /*proto*/ +static __Pyx_memviewslice __pyx_f_4cssm_draw_gaussian(int); /*proto*/ +static int __pyx_f_4cssm_check_finished(__Pyx_memviewslice, float, int); /*proto*/ +static int __pyx_array_allocate_buffer(struct __pyx_array_obj *); /*proto*/ +static struct __pyx_array_obj *__pyx_array_new(PyObject *, Py_ssize_t, char *, char const *, char *); /*proto*/ +static PyObject *__pyx_memoryview_new(PyObject *, int, int, __Pyx_TypeInfo const *); /*proto*/ +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *); /*proto*/ +static PyObject *_unellipsify(PyObject *, int); /*proto*/ +static int assert_direct_dimensions(Py_ssize_t *, int); /*proto*/ +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *, PyObject *); /*proto*/ +static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int *, Py_ssize_t, Py_ssize_t, Py_ssize_t, int, int, int, int); /*proto*/ +static char *__pyx_pybuffer_index(Py_buffer *, char *, Py_ssize_t, Py_ssize_t); /*proto*/ +static int __pyx_memslice_transpose(__Pyx_memviewslice *); /*proto*/ +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice, int, PyObject *(*)(char *), int (*)(char *, PyObject *), int); /*proto*/ +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ +static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *); /*proto*/ +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *, __Pyx_memviewslice *); /*proto*/ +static Py_ssize_t abs_py_ssize_t(Py_ssize_t); /*proto*/ +static char __pyx_get_best_slice_order(__Pyx_memviewslice *, int); /*proto*/ +static void _copy_strided_to_strided(char *, Py_ssize_t *, char *, Py_ssize_t *, Py_ssize_t *, Py_ssize_t *, int, size_t); /*proto*/ +static void copy_strided_to_strided(__Pyx_memviewslice *, __Pyx_memviewslice *, int, size_t); /*proto*/ +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *, int); /*proto*/ +static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *, Py_ssize_t *, Py_ssize_t, int, char); /*proto*/ +static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *, __Pyx_memviewslice *, char, int); /*proto*/ +static int __pyx_memoryview_err_extents(int, Py_ssize_t, Py_ssize_t); /*proto*/ +static int __pyx_memoryview_err_dim(PyObject *, PyObject *, int); /*proto*/ +static int __pyx_memoryview_err(PyObject *, PyObject *); /*proto*/ +static int __pyx_memoryview_err_no_memory(void); /*proto*/ +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice, __Pyx_memviewslice, int, int, int); /*proto*/ +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *, int, int); /*proto*/ +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *, int, int, int); /*proto*/ +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ +static void __pyx_memoryview_refcount_objects_in_slice(char *, Py_ssize_t *, Py_ssize_t *, int, int); /*proto*/ +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *, int, size_t, void *, int); /*proto*/ +static void __pyx_memoryview__slice_assign_scalar(char *, Py_ssize_t *, Py_ssize_t *, int, size_t, void *); /*proto*/ +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *, PyObject *); /*proto*/ +/* #### Code section: typeinfo ### */ +static const __Pyx_TypeInfo __Pyx_TypeInfo_float = { "float", NULL, sizeof(float), { 0 }, 0, 'R', 0, 0 }; +static const __Pyx_TypeInfo __Pyx_TypeInfo_double = { "double", NULL, sizeof(double), { 0 }, 0, 'R', 0, 0 }; +static const __Pyx_TypeInfo __Pyx_TypeInfo_int = { "int", NULL, sizeof(int), { 0 }, 0, __PYX_IS_UNSIGNED(int) ? 'U' : 'I', __PYX_IS_UNSIGNED(int), 0 }; +/* #### Code section: before_global_var ### */ +#define __Pyx_MODULE_NAME "cssm" +extern int __pyx_module_is_main_cssm; +int __pyx_module_is_main_cssm = 0; + +/* Implementation of "cssm" */ +/* #### Code section: global_var ### */ +static PyObject *__pyx_builtin___import__; +static PyObject *__pyx_builtin_enumerate; +static PyObject *__pyx_builtin_Ellipsis; +static PyObject *__pyx_builtin_id; +/* #### Code section: string_decls ### */ +/* #### Code section: decls ### */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr); /* proto */ +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item); /* proto */ +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /* proto */ +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name); /* proto */ +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object); /* proto */ +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /* proto */ +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self); /* proto */ +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state); /* proto */ +static PyObject *__pyx_pf_4cssm_full_ddm_hddm_base(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_sz, PyArrayObject *__pyx_v_sv, PyArrayObject *__pyx_v_st, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_random_state, PyObject *__pyx_v_smooth_unif, PyObject *__pyx_v_return_option, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_2ddm(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, PyObject *__pyx_v_max_t, float __pyx_v_delta_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_48__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_4ddm_flexbound(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_max_t, float __pyx_v_delta_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_50__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_6ddm_flex(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_drift_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_drift_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_52__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_8levy_flexbound(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_alpha, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_54__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_10full_ddm_rv(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyObject *__pyx_v_z_dist, PyObject *__pyx_v_v_dist, PyObject *__pyx_v_t_dist, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_56__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_12full_ddm(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_sz, PyArrayObject *__pyx_v_sv, PyArrayObject *__pyx_v_st, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_58__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_14ddm_sdv(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_sv, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_60__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_16ornstein_uhlenbeck(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_62__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_18race_model(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_s, PyArrayObject *__pyx_v_deadline, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_64__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_20lca(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_b, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_s, PyArrayObject *__pyx_v_deadline, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_66__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_22ddm_flexbound_seq2(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_68__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_24ddm_flexbound_par2(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_70__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_26ddm_flexbound_mic2_ornstein(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s_pre_high_level_choice, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_72__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_28ddm_flexbound_mic2_multinoise(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_74__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_30ddm_flexbound_mic2_ornstein_multinoise(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_32lba_vanilla(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_sd, PyArrayObject *__pyx_v_t, int __pyx_v_nact, int __pyx_v_n_samples, int __pyx_v_n_trials, float __pyx_v_max_t, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_34lba_angle(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_theta, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_sd, PyArrayObject *__pyx_v_t, int __pyx_v_nact, int __pyx_v_n_samples, int __pyx_v_n_trials, float __pyx_v_max_t, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_36rlwm_lba_pw_v1(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v_RL, PyArrayObject *__pyx_v_v_WM, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t_WM, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_sd, PyArrayObject *__pyx_v_t, int __pyx_v_nact, int __pyx_v_n_samples, int __pyx_v_n_trials, float __pyx_v_max_t, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_38rlwm_lba_race(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v_RL, PyArrayObject *__pyx_v_v_WM, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_sd, PyArrayObject *__pyx_v_t, int __pyx_v_nact, int __pyx_v_n_samples, int __pyx_v_n_trials, float __pyx_v_max_t, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_76__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_40ddm_flexbound_mic2_unnormalized_ornstein_multinoise(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_78__defaults__(CYTHON_UNUSED PyObject *__pyx_self); /* proto */ +static PyObject *__pyx_pf_4cssm_42ddm_flexbound_tradeoff(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_44exgauss(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_mu, PyArrayObject *__pyx_v_sigma, PyArrayObject *__pyx_v_tau, PyArrayObject *__pyx_v_p, float __pyx_v_delta_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, float __pyx_v_max_t, PyObject *__pyx_v_race, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_pf_4cssm_46shifted_wald(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_p, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, PyObject *__pyx_v_race, CYTHON_UNUSED PyObject *__pyx_v_kwargs); /* proto */ +static PyObject *__pyx_tp_new_4cssm___pyx_defaults(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_4cssm___pyx_defaults1(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k); /*proto*/ +/* #### Code section: late_includes ### */ +/* #### Code section: module_state ### */ +/* SmallCodeConfig */ +#ifndef CYTHON_SMALL_CODE +#if defined(__clang__) + #define CYTHON_SMALL_CODE +#elif defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3)) + #define CYTHON_SMALL_CODE __attribute__((cold)) +#else + #define CYTHON_SMALL_CODE +#endif +#endif + +typedef struct { + PyObject *__pyx_d; + PyObject *__pyx_b; + PyObject *__pyx_cython_runtime; + PyObject *__pyx_empty_tuple; + PyObject *__pyx_empty_bytes; + PyObject *__pyx_empty_unicode; + PyTypeObject *__pyx_ptype_7cpython_4type_type; + PyTypeObject *__pyx_ptype_5numpy_dtype; + PyTypeObject *__pyx_ptype_5numpy_flatiter; + PyTypeObject *__pyx_ptype_5numpy_broadcast; + PyTypeObject *__pyx_ptype_5numpy_ndarray; + PyTypeObject *__pyx_ptype_5numpy_generic; + PyTypeObject *__pyx_ptype_5numpy_number; + PyTypeObject *__pyx_ptype_5numpy_integer; + PyTypeObject *__pyx_ptype_5numpy_signedinteger; + PyTypeObject *__pyx_ptype_5numpy_unsignedinteger; + PyTypeObject *__pyx_ptype_5numpy_inexact; + PyTypeObject *__pyx_ptype_5numpy_floating; + PyTypeObject *__pyx_ptype_5numpy_complexfloating; + PyTypeObject *__pyx_ptype_5numpy_flexible; + PyTypeObject *__pyx_ptype_5numpy_character; + PyTypeObject *__pyx_ptype_5numpy_ufunc; + PyObject *__pyx_type_4cssm___pyx_defaults; + PyObject *__pyx_type_4cssm___pyx_defaults1; + PyObject *__pyx_type___pyx_array; + PyObject *__pyx_type___pyx_MemviewEnum; + PyObject *__pyx_type___pyx_memoryview; + PyObject *__pyx_type___pyx_memoryviewslice; + PyTypeObject *__pyx_ptype_4cssm___pyx_defaults; + PyTypeObject *__pyx_ptype_4cssm___pyx_defaults1; + PyTypeObject *__pyx_array_type; + PyTypeObject *__pyx_MemviewEnum_type; + PyTypeObject *__pyx_memoryview_type; + PyTypeObject *__pyx_memoryviewslice_type; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_items; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_pop; + __Pyx_CachedCFunction __pyx_umethod_PyDict_Type_values; + PyObject *__pyx_slice[1]; + PyObject *__pyx_tuple[3]; + PyObject *__pyx_codeobj_tab[24]; + PyObject *__pyx_string_tab[385]; + PyObject *__pyx_number_tab[9]; +/* #### Code section: module_state_contents ### */ +/* CommonTypesMetaclass.module_state_decls */ +PyTypeObject *__pyx_CommonTypesMetaclassType; + +/* CachedMethodType.module_state_decls */ +#if CYTHON_COMPILING_IN_LIMITED_API +PyObject *__Pyx_CachedMethodType; +#endif + +/* CythonFunctionShared.module_state_decls */ +PyTypeObject *__pyx_CyFunctionType; + +/* CodeObjectCache.module_state_decls */ +struct __Pyx_CodeObjectCache __pyx_code_cache; + +/* #### Code section: module_state_end ### */ +} __pyx_mstatetype; + +#if CYTHON_USE_MODULE_STATE +#ifdef __cplusplus +namespace { +extern struct PyModuleDef __pyx_moduledef; +} /* anonymous namespace */ +#else +static struct PyModuleDef __pyx_moduledef; +#endif + +#define __pyx_mstate_global (__Pyx_PyModule_GetState(__Pyx_State_FindModule(&__pyx_moduledef))) + +#define __pyx_m (__Pyx_State_FindModule(&__pyx_moduledef)) +#else +static __pyx_mstatetype __pyx_mstate_global_static = +#ifdef __cplusplus + {}; +#else + {0}; +#endif +static __pyx_mstatetype * const __pyx_mstate_global = &__pyx_mstate_global_static; +#endif +/* #### Code section: constant_name_defines ### */ +#define __pyx_kp_u_ __pyx_string_tab[0] +#define __pyx_kp_u_All_dimensions_preceding_dimensi __pyx_string_tab[1] +#define __pyx_kp_u_Buffer_view_does_not_expose_stri __pyx_string_tab[2] +#define __pyx_kp_u_Can_only_create_a_buffer_that_is __pyx_string_tab[3] +#define __pyx_kp_u_Cannot_assign_to_read_only_memor __pyx_string_tab[4] +#define __pyx_kp_u_Cannot_create_writable_memory_vi __pyx_string_tab[5] +#define __pyx_kp_u_Cannot_index_with_type __pyx_string_tab[6] +#define __pyx_kp_u_Cannot_transpose_memoryview_with __pyx_string_tab[7] +#define __pyx_kp_u_Dimension_d_is_not_direct __pyx_string_tab[8] +#define __pyx_kp_u_Empty_shape_tuple_for_cython_arr __pyx_string_tab[9] +#define __pyx_kp_u_Index_out_of_bounds_axis_d __pyx_string_tab[10] +#define __pyx_kp_u_Indirect_dimensions_not_supporte __pyx_string_tab[11] +#define __pyx_kp_u_Invalid_mode_expected_c_or_fortr __pyx_string_tab[12] +#define __pyx_kp_u_Invalid_shape_in_axis __pyx_string_tab[13] +#define __pyx_kp_u_MemoryView_of __pyx_string_tab[14] +#define __pyx_kp_u_Note_that_Cython_is_deliberately __pyx_string_tab[15] +#define __pyx_kp_u_Out_of_bounds_on_buffer_access_a __pyx_string_tab[16] +#define __pyx_kp_u_Step_may_not_be_zero_axis_d __pyx_string_tab[17] +#define __pyx_kp_u_This_simulator_does_not_yet_allo __pyx_string_tab[18] +#define __pyx_kp_u_Unable_to_convert_item_to_object __pyx_string_tab[19] +#define __pyx_kp_u__2 __pyx_string_tab[20] +#define __pyx_kp_u__3 __pyx_string_tab[21] +#define __pyx_kp_u__4 __pyx_string_tab[22] +#define __pyx_kp_u__5 __pyx_string_tab[23] +#define __pyx_kp_u__6 __pyx_string_tab[24] +#define __pyx_kp_u_add_note __pyx_string_tab[25] +#define __pyx_kp_u_and __pyx_string_tab[26] +#define __pyx_kp_u_at_0x __pyx_string_tab[27] +#define __pyx_kp_u_collections_abc __pyx_string_tab[28] +#define __pyx_kp_u_contiguous_and_direct __pyx_string_tab[29] +#define __pyx_kp_u_contiguous_and_indirect __pyx_string_tab[30] +#define __pyx_kp_u_disable __pyx_string_tab[31] +#define __pyx_kp_u_enable __pyx_string_tab[32] +#define __pyx_kp_u_gc __pyx_string_tab[33] +#define __pyx_kp_u_got __pyx_string_tab[34] +#define __pyx_kp_u_got_differing_extents_in_dimensi __pyx_string_tab[35] +#define __pyx_kp_u_isenabled __pyx_string_tab[36] +#define __pyx_kp_u_itemsize_0_for_cython_array __pyx_string_tab[37] +#define __pyx_kp_u_no_default___reduce___due_to_non __pyx_string_tab[38] +#define __pyx_kp_u_numpy__core_multiarray_failed_to __pyx_string_tab[39] +#define __pyx_kp_u_numpy__core_umath_failed_to_impo __pyx_string_tab[40] +#define __pyx_kp_u_object __pyx_string_tab[41] +#define __pyx_kp_u_return_option_must_be_either_ful __pyx_string_tab[42] +#define __pyx_kp_u_return_option_must_be_full_or_mi __pyx_string_tab[43] +#define __pyx_kp_u_self_name_is_not_None __pyx_string_tab[44] +#define __pyx_kp_u_src_cssm_pyx __pyx_string_tab[45] +#define __pyx_kp_u_strided_and_direct __pyx_string_tab[46] +#define __pyx_kp_u_strided_and_direct_or_indirect __pyx_string_tab[47] +#define __pyx_kp_u_strided_and_indirect __pyx_string_tab[48] +#define __pyx_kp_u_unable_to_allocate_array_data __pyx_string_tab[49] +#define __pyx_kp_u_unable_to_allocate_shape_and_str __pyx_string_tab[50] +#define __pyx_n_u_ASCII __pyx_string_tab[51] +#define __pyx_n_u_DTYPE __pyx_string_tab[52] +#define __pyx_n_u_Ellipsis __pyx_string_tab[53] +#define __pyx_n_u_Integral __pyx_string_tab[54] +#define __pyx_n_u_Pyx_PyDict_NextRef __pyx_string_tab[55] +#define __pyx_n_u_Sequence __pyx_string_tab[56] +#define __pyx_n_u_T __pyx_string_tab[57] +#define __pyx_n_u_View_MemoryView __pyx_string_tab[58] +#define __pyx_n_u_a __pyx_string_tab[59] +#define __pyx_n_u_a_view __pyx_string_tab[60] +#define __pyx_n_u_abc __pyx_string_tab[61] +#define __pyx_n_u_abs __pyx_string_tab[62] +#define __pyx_n_u_add __pyx_string_tab[63] +#define __pyx_n_u_allocate_buffer __pyx_string_tab[64] +#define __pyx_n_u_alpha __pyx_string_tab[65] +#define __pyx_n_u_alpha_stable_values __pyx_string_tab[66] +#define __pyx_n_u_alpha_view __pyx_string_tab[67] +#define __pyx_n_u_arange __pyx_string_tab[68] +#define __pyx_n_u_argmax __pyx_string_tab[69] +#define __pyx_n_u_argmin __pyx_string_tab[70] +#define __pyx_n_u_asarray __pyx_string_tab[71] +#define __pyx_n_u_astype __pyx_string_tab[72] +#define __pyx_n_u_asyncio_coroutines __pyx_string_tab[73] +#define __pyx_n_u_b __pyx_string_tab[74] +#define __pyx_n_u_b_view __pyx_string_tab[75] +#define __pyx_n_u_base __pyx_string_tab[76] +#define __pyx_n_u_bias_trace __pyx_string_tab[77] +#define __pyx_n_u_bias_trace_l1 __pyx_string_tab[78] +#define __pyx_n_u_bias_trace_l1_view __pyx_string_tab[79] +#define __pyx_n_u_bias_trace_l2 __pyx_string_tab[80] +#define __pyx_n_u_bias_trace_l2_view __pyx_string_tab[81] +#define __pyx_n_u_bias_trace_view __pyx_string_tab[82] +#define __pyx_n_u_boundary __pyx_string_tab[83] +#define __pyx_n_u_boundary_fun __pyx_string_tab[84] +#define __pyx_n_u_boundary_fun_type __pyx_string_tab[85] +#define __pyx_n_u_boundary_multiplicative __pyx_string_tab[86] +#define __pyx_n_u_boundary_params __pyx_string_tab[87] +#define __pyx_n_u_boundary_params_tmp __pyx_string_tab[88] +#define __pyx_n_u_boundary_view __pyx_string_tab[89] +#define __pyx_n_u_c __pyx_string_tab[90] +#define __pyx_n_u_choice_idx __pyx_string_tab[91] +#define __pyx_n_u_choices __pyx_string_tab[92] +#define __pyx_n_u_choices_idx __pyx_string_tab[93] +#define __pyx_n_u_choices_view __pyx_string_tab[94] +#define __pyx_n_u_class __pyx_string_tab[95] +#define __pyx_n_u_class_getitem __pyx_string_tab[96] +#define __pyx_n_u_cline_in_traceback __pyx_string_tab[97] +#define __pyx_n_u_constant __pyx_string_tab[98] +#define __pyx_n_u_count __pyx_string_tab[99] +#define __pyx_n_u_cssm __pyx_string_tab[100] +#define __pyx_n_u_d __pyx_string_tab[101] +#define __pyx_n_u_d_view __pyx_string_tab[102] +#define __pyx_n_u_ddm __pyx_string_tab[103] +#define __pyx_n_u_ddm_flex __pyx_string_tab[104] +#define __pyx_n_u_ddm_flexbound __pyx_string_tab[105] +#define __pyx_n_u_ddm_flexbound_mic2_adj __pyx_string_tab[106] +#define __pyx_n_u_ddm_flexbound_mic2_multinoise __pyx_string_tab[107] +#define __pyx_n_u_ddm_flexbound_mic2_ornstein __pyx_string_tab[108] +#define __pyx_n_u_ddm_flexbound_mic2_ornstein_mult __pyx_string_tab[109] +#define __pyx_n_u_ddm_flexbound_mic2_unnormalized __pyx_string_tab[110] +#define __pyx_n_u_ddm_flexbound_par2 __pyx_string_tab[111] +#define __pyx_n_u_ddm_flexbound_seq2 __pyx_string_tab[112] +#define __pyx_n_u_ddm_flexbound_tradeoff __pyx_string_tab[113] +#define __pyx_n_u_ddm_sdv __pyx_string_tab[114] +#define __pyx_n_u_deadline __pyx_string_tab[115] +#define __pyx_n_u_deadline_tmp __pyx_string_tab[116] +#define __pyx_n_u_deadline_view __pyx_string_tab[117] +#define __pyx_n_u_decision_taken __pyx_string_tab[118] +#define __pyx_n_u_default_rng __pyx_string_tab[119] +#define __pyx_n_u_delta_t __pyx_string_tab[120] +#define __pyx_n_u_delta_t_alpha __pyx_string_tab[121] +#define __pyx_n_u_delta_t_sqrt __pyx_string_tab[122] +#define __pyx_n_u_dict __pyx_string_tab[123] +#define __pyx_n_u_drift __pyx_string_tab[124] +#define __pyx_n_u_drift_fun __pyx_string_tab[125] +#define __pyx_n_u_drift_fun_type __pyx_string_tab[126] +#define __pyx_n_u_drift_increment __pyx_string_tab[127] +#define __pyx_n_u_drift_params __pyx_string_tab[128] +#define __pyx_n_u_drift_params_tmp __pyx_string_tab[129] +#define __pyx_n_u_drift_view __pyx_string_tab[130] +#define __pyx_n_u_dtype __pyx_string_tab[131] +#define __pyx_n_u_dtype_is_object __pyx_string_tab[132] +#define __pyx_n_u_empty __pyx_string_tab[133] +#define __pyx_n_u_encode __pyx_string_tab[134] +#define __pyx_n_u_enumerate __pyx_string_tab[135] +#define __pyx_n_u_error __pyx_string_tab[136] +#define __pyx_n_u_exgauss __pyx_string_tab[137] +#define __pyx_n_u_exgauss_race __pyx_string_tab[138] +#define __pyx_n_u_exp_sample __pyx_string_tab[139] +#define __pyx_n_u_exponential __pyx_string_tab[140] +#define __pyx_n_u_flags __pyx_string_tab[141] +#define __pyx_n_u_float32 __pyx_string_tab[142] +#define __pyx_n_u_format __pyx_string_tab[143] +#define __pyx_n_u_fortran __pyx_string_tab[144] +#define __pyx_n_u_full __pyx_string_tab[145] +#define __pyx_n_u_full_ddm __pyx_string_tab[146] +#define __pyx_n_u_full_ddm_hddm_base __pyx_string_tab[147] +#define __pyx_n_u_full_ddm_rv __pyx_string_tab[148] +#define __pyx_n_u_func __pyx_string_tab[149] +#define __pyx_n_u_g __pyx_string_tab[150] +#define __pyx_n_u_g_view __pyx_string_tab[151] +#define __pyx_n_u_gaussian_values __pyx_string_tab[152] +#define __pyx_n_u_getstate __pyx_string_tab[153] +#define __pyx_n_u_i __pyx_string_tab[154] +#define __pyx_n_u_id __pyx_string_tab[155] +#define __pyx_n_u_import __pyx_string_tab[156] +#define __pyx_n_u_index __pyx_string_tab[157] +#define __pyx_n_u_intc __pyx_string_tab[158] +#define __pyx_n_u_is_coroutine __pyx_string_tab[159] +#define __pyx_n_u_items __pyx_string_tab[160] +#define __pyx_n_u_itemsize __pyx_string_tab[161] +#define __pyx_n_u_ix __pyx_string_tab[162] +#define __pyx_n_u_ix1 __pyx_string_tab[163] +#define __pyx_n_u_ix1_tmp __pyx_string_tab[164] +#define __pyx_n_u_ix2 __pyx_string_tab[165] +#define __pyx_n_u_ix2_tmp __pyx_string_tab[166] +#define __pyx_n_u_ix_l __pyx_string_tab[167] +#define __pyx_n_u_ix_tmp __pyx_string_tab[168] +#define __pyx_n_u_j __pyx_string_tab[169] +#define __pyx_n_u_k __pyx_string_tab[170] +#define __pyx_n_u_key __pyx_string_tab[171] +#define __pyx_n_u_keys __pyx_string_tab[172] +#define __pyx_n_u_kwargs __pyx_string_tab[173] +#define __pyx_n_u_lba_angle __pyx_string_tab[174] +#define __pyx_n_u_lba_vanilla __pyx_string_tab[175] +#define __pyx_n_u_lca __pyx_string_tab[176] +#define __pyx_n_u_levy_flexbound __pyx_string_tab[177] +#define __pyx_n_u_m __pyx_string_tab[178] +#define __pyx_n_u_main __pyx_string_tab[179] +#define __pyx_n_u_max_t __pyx_string_tab[180] +#define __pyx_n_u_memview __pyx_string_tab[181] +#define __pyx_n_u_metadata __pyx_string_tab[182] +#define __pyx_n_u_min __pyx_string_tab[183] +#define __pyx_n_u_minimal __pyx_string_tab[184] +#define __pyx_n_u_mode __pyx_string_tab[185] +#define __pyx_n_u_module __pyx_string_tab[186] +#define __pyx_n_u_mu __pyx_string_tab[187] +#define __pyx_n_u_mu_val __pyx_string_tab[188] +#define __pyx_n_u_multiply __pyx_string_tab[189] +#define __pyx_n_u_n __pyx_string_tab[190] +#define __pyx_n_u_n_choices __pyx_string_tab[191] +#define __pyx_n_u_n_particles __pyx_string_tab[192] +#define __pyx_n_u_n_samples __pyx_string_tab[193] +#define __pyx_n_u_n_trials __pyx_string_tab[194] +#define __pyx_n_u_nact __pyx_string_tab[195] +#define __pyx_n_u_name __pyx_string_tab[196] +#define __pyx_n_u_name_2 __pyx_string_tab[197] +#define __pyx_n_u_ndim __pyx_string_tab[198] +#define __pyx_n_u_new __pyx_string_tab[199] +#define __pyx_n_u_norm_sample __pyx_string_tab[200] +#define __pyx_n_u_normal __pyx_string_tab[201] +#define __pyx_n_u_np __pyx_string_tab[202] +#define __pyx_n_u_num_draws __pyx_string_tab[203] +#define __pyx_n_u_num_steps __pyx_string_tab[204] +#define __pyx_n_u_numbers __pyx_string_tab[205] +#define __pyx_n_u_numpy __pyx_string_tab[206] +#define __pyx_n_u_obj __pyx_string_tab[207] +#define __pyx_n_u_ornstein_uhlenbeck __pyx_string_tab[208] +#define __pyx_n_u_p __pyx_string_tab[209] +#define __pyx_n_u_p_view __pyx_string_tab[210] +#define __pyx_n_u_pack __pyx_string_tab[211] +#define __pyx_n_u_particles __pyx_string_tab[212] +#define __pyx_n_u_particles_reduced_sum __pyx_string_tab[213] +#define __pyx_n_u_particles_reduced_sum_view __pyx_string_tab[214] +#define __pyx_n_u_particles_sum __pyx_string_tab[215] +#define __pyx_n_u_particles_view __pyx_string_tab[216] +#define __pyx_n_u_pop __pyx_string_tab[217] +#define __pyx_n_u_possible_choices __pyx_string_tab[218] +#define __pyx_n_u_print_info __pyx_string_tab[219] +#define __pyx_n_u_pyx_checksum __pyx_string_tab[220] +#define __pyx_n_u_pyx_state __pyx_string_tab[221] +#define __pyx_n_u_pyx_type __pyx_string_tab[222] +#define __pyx_n_u_pyx_unpickle_Enum __pyx_string_tab[223] +#define __pyx_n_u_pyx_vtable __pyx_string_tab[224] +#define __pyx_n_u_qualname __pyx_string_tab[225] +#define __pyx_n_u_race __pyx_string_tab[226] +#define __pyx_n_u_race_model __pyx_string_tab[227] +#define __pyx_n_u_random __pyx_string_tab[228] +#define __pyx_n_u_random_state __pyx_string_tab[229] +#define __pyx_n_u_random_val __pyx_string_tab[230] +#define __pyx_n_u_reduce __pyx_string_tab[231] +#define __pyx_n_u_reduce_cython __pyx_string_tab[232] +#define __pyx_n_u_reduce_ex __pyx_string_tab[233] +#define __pyx_n_u_register __pyx_string_tab[234] +#define __pyx_n_u_repeat __pyx_string_tab[235] +#define __pyx_n_u_return_option __pyx_string_tab[236] +#define __pyx_n_u_rlwm_lba_pw_v1 __pyx_string_tab[237] +#define __pyx_n_u_rlwm_lba_race __pyx_string_tab[238] +#define __pyx_n_u_rng __pyx_string_tab[239] +#define __pyx_n_u_rt_candidates __pyx_string_tab[240] +#define __pyx_n_u_rt_val __pyx_string_tab[241] +#define __pyx_n_u_rts __pyx_string_tab[242] +#define __pyx_n_u_rts_high __pyx_string_tab[243] +#define __pyx_n_u_rts_high_view __pyx_string_tab[244] +#define __pyx_n_u_rts_low __pyx_string_tab[245] +#define __pyx_n_u_rts_low_view __pyx_string_tab[246] +#define __pyx_n_u_rts_view __pyx_string_tab[247] +#define __pyx_n_u_s __pyx_string_tab[248] +#define __pyx_n_u_s_pre_high_level_choice __pyx_string_tab[249] +#define __pyx_n_u_s_pre_high_level_choice_view __pyx_string_tab[250] +#define __pyx_n_u_s_view __pyx_string_tab[251] +#define __pyx_n_u_sd __pyx_string_tab[252] +#define __pyx_n_u_sd_view __pyx_string_tab[253] +#define __pyx_n_u_set_name __pyx_string_tab[254] +#define __pyx_n_u_setdefault __pyx_string_tab[255] +#define __pyx_n_u_setstate __pyx_string_tab[256] +#define __pyx_n_u_setstate_cython __pyx_string_tab[257] +#define __pyx_n_u_shape __pyx_string_tab[258] +#define __pyx_n_u_shifted_wald __pyx_string_tab[259] +#define __pyx_n_u_shifted_wald_race __pyx_string_tab[260] +#define __pyx_n_u_sigma __pyx_string_tab[261] +#define __pyx_n_u_sigma_val __pyx_string_tab[262] +#define __pyx_n_u_sign __pyx_string_tab[263] +#define __pyx_n_u_simulator __pyx_string_tab[264] +#define __pyx_n_u_size __pyx_string_tab[265] +#define __pyx_n_u_smooth_u __pyx_string_tab[266] +#define __pyx_n_u_smooth_unif __pyx_string_tab[267] +#define __pyx_n_u_sqrt __pyx_string_tab[268] +#define __pyx_n_u_sqrt_st __pyx_string_tab[269] +#define __pyx_n_u_sqrt_st_view __pyx_string_tab[270] +#define __pyx_n_u_st __pyx_string_tab[271] +#define __pyx_n_u_st_samplewise __pyx_string_tab[272] +#define __pyx_n_u_st_samplewise_view __pyx_string_tab[273] +#define __pyx_n_u_st_view __pyx_string_tab[274] +#define __pyx_n_u_start __pyx_string_tab[275] +#define __pyx_n_u_step __pyx_string_tab[276] +#define __pyx_n_u_stop __pyx_string_tab[277] +#define __pyx_n_u_struct __pyx_string_tab[278] +#define __pyx_n_u_sv __pyx_string_tab[279] +#define __pyx_n_u_sv_samplewise __pyx_string_tab[280] +#define __pyx_n_u_sv_samplewise_view __pyx_string_tab[281] +#define __pyx_n_u_sv_view __pyx_string_tab[282] +#define __pyx_n_u_sz __pyx_string_tab[283] +#define __pyx_n_u_sz_samplewise __pyx_string_tab[284] +#define __pyx_n_u_sz_samplewise_view __pyx_string_tab[285] +#define __pyx_n_u_sz_view __pyx_string_tab[286] +#define __pyx_n_u_t __pyx_string_tab[287] +#define __pyx_n_u_t_WM __pyx_string_tab[288] +#define __pyx_n_u_t_WM_view __pyx_string_tab[289] +#define __pyx_n_u_t_dist __pyx_string_tab[290] +#define __pyx_n_u_t_h __pyx_string_tab[291] +#define __pyx_n_u_t_l __pyx_string_tab[292] +#define __pyx_n_u_t_l1 __pyx_string_tab[293] +#define __pyx_n_u_t_l2 __pyx_string_tab[294] +#define __pyx_n_u_t_par __pyx_string_tab[295] +#define __pyx_n_u_t_particle __pyx_string_tab[296] +#define __pyx_n_u_t_particle1 __pyx_string_tab[297] +#define __pyx_n_u_t_particle2 __pyx_string_tab[298] +#define __pyx_n_u_t_s __pyx_string_tab[299] +#define __pyx_n_u_t_tmp __pyx_string_tab[300] +#define __pyx_n_u_t_view __pyx_string_tab[301] +#define __pyx_n_u_tan __pyx_string_tab[302] +#define __pyx_n_u_tau __pyx_string_tab[303] +#define __pyx_n_u_tau_val __pyx_string_tab[304] +#define __pyx_n_u_test __pyx_string_tab[305] +#define __pyx_n_u_theta __pyx_string_tab[306] +#define __pyx_n_u_theta_view __pyx_string_tab[307] +#define __pyx_n_u_tmp_pos_dep __pyx_string_tab[308] +#define __pyx_n_u_traj __pyx_string_tab[309] +#define __pyx_n_u_traj_view __pyx_string_tab[310] +#define __pyx_n_u_trajectory __pyx_string_tab[311] +#define __pyx_n_u_uniform __pyx_string_tab[312] +#define __pyx_n_u_unpack __pyx_string_tab[313] +#define __pyx_n_u_update __pyx_string_tab[314] +#define __pyx_n_u_v __pyx_string_tab[315] +#define __pyx_n_u_v_2 __pyx_string_tab[316] +#define __pyx_n_u_v_RL __pyx_string_tab[317] +#define __pyx_n_u_v_RL_2 __pyx_string_tab[318] +#define __pyx_n_u_v_RL_view __pyx_string_tab[319] +#define __pyx_n_u_v_WM __pyx_string_tab[320] +#define __pyx_n_u_v_WM_2 __pyx_string_tab[321] +#define __pyx_n_u_v_WM_view __pyx_string_tab[322] +#define __pyx_n_u_v_dict __pyx_string_tab[323] +#define __pyx_n_u_v_dist __pyx_string_tab[324] +#define __pyx_n_u_v_l __pyx_string_tab[325] +#define __pyx_n_u_v_l1 __pyx_string_tab[326] +#define __pyx_n_u_v_l2 __pyx_string_tab[327] +#define __pyx_n_u_v_view __pyx_string_tab[328] +#define __pyx_n_u_values __pyx_string_tab[329] +#define __pyx_n_u_vh __pyx_string_tab[330] +#define __pyx_n_u_vh_view __pyx_string_tab[331] +#define __pyx_n_u_vl1 __pyx_string_tab[332] +#define __pyx_n_u_vl1_view __pyx_string_tab[333] +#define __pyx_n_u_vl2 __pyx_string_tab[334] +#define __pyx_n_u_vl2_view __pyx_string_tab[335] +#define __pyx_n_u_vs __pyx_string_tab[336] +#define __pyx_n_u_vs_RL __pyx_string_tab[337] +#define __pyx_n_u_vs_WM __pyx_string_tab[338] +#define __pyx_n_u_x __pyx_string_tab[339] +#define __pyx_n_u_x_t __pyx_string_tab[340] +#define __pyx_n_u_x_t_RL __pyx_string_tab[341] +#define __pyx_n_u_x_t_WM __pyx_string_tab[342] +#define __pyx_n_u_y __pyx_string_tab[343] +#define __pyx_n_u_y_h __pyx_string_tab[344] +#define __pyx_n_u_y_l __pyx_string_tab[345] +#define __pyx_n_u_y_l1 __pyx_string_tab[346] +#define __pyx_n_u_y_l2 __pyx_string_tab[347] +#define __pyx_n_u_z __pyx_string_tab[348] +#define __pyx_n_u_z_dict __pyx_string_tab[349] +#define __pyx_n_u_z_dist __pyx_string_tab[350] +#define __pyx_n_u_z_view __pyx_string_tab[351] +#define __pyx_n_u_zeros __pyx_string_tab[352] +#define __pyx_n_u_zh __pyx_string_tab[353] +#define __pyx_n_u_zh_view __pyx_string_tab[354] +#define __pyx_n_u_zl1 __pyx_string_tab[355] +#define __pyx_n_u_zl1_view __pyx_string_tab[356] +#define __pyx_n_u_zl2 __pyx_string_tab[357] +#define __pyx_n_u_zl2_view __pyx_string_tab[358] +#define __pyx_n_u_zs __pyx_string_tab[359] +#define __pyx_kp_b_iso88591_23_l_AQ_A_Q_Q_1_A_Q_Q_1_1_1_1_1 __pyx_string_tab[360] +#define __pyx_kp_b_iso88591_45_AQ_A_Q_Q_1_A_Q_Q_1_1_1_F_Kz __pyx_string_tab[361] +#define __pyx_kp_b_iso88591_9_898989898989JK898989_AQ_A_Q_Q __pyx_string_tab[362] +#define __pyx_kp_b_iso88591_AQ_1_1_1_1_1_2V2S_r_Ct81_F_Kz_X __pyx_string_tab[363] +#define __pyx_kp_b_iso88591_AQ_A_1_1_1_1_2V2S_r_Ct81_F_Kz_X __pyx_string_tab[364] +#define __pyx_kp_b_iso88591_AQ_A_1_1_1_A_A_A_1_2V2S_r_Ct81 __pyx_string_tab[365] +#define __pyx_kp_b_iso88591_AQ_A_Q_Q_1_A_Q_Q_1_1_1_1_F_Kz_X __pyx_string_tab[366] +#define __pyx_kp_b_iso88591_AQ_A_Q_Q_1_A_Q_Q_1_1_1_F_Kz_XQ __pyx_string_tab[367] +#define __pyx_kp_b_iso88591_AQ_a_a_a_1_1_2V2S_r_Ct6_F_Kz_XQ __pyx_string_tab[368] +#define __pyx_kp_b_iso88591_AQ_a_a_a_a_a_d_1_m2Q_A_1F_1_F_K __pyx_string_tab[369] +#define __pyx_kp_b_iso88591_B_AQ_2V2S_r_Ct81_A_1_1_1_1_1_F __pyx_string_tab[370] +#define __pyx_kp_b_iso88591_B_AQ_2V2S_r_Ct81_A_1_1_1_A_1_F __pyx_string_tab[371] +#define __pyx_kp_b_iso88591_B_AQ_A_1_1_q_1_1_2V2S_r_Ct81_F __pyx_string_tab[372] +#define __pyx_kp_b_iso88591_D_AQ_1_1_1_1_1_2V2S_r_Ct81_F_Kz __pyx_string_tab[373] +#define __pyx_kp_b_iso88591_F_AQ_1_1_1_1_1_BfBj_HA_BfBj_HA __pyx_string_tab[374] +#define __pyx_kp_b_iso88591_F_AQ_A_1_1_1_A_A_A_1_2V2S_r_Ct8 __pyx_string_tab[375] +#define __pyx_kp_b_iso88591_G_q_81D_a_BhawfA_HAU_3fA_r_s_Rw __pyx_string_tab[376] +#define __pyx_kp_b_iso88591_R_a_a_1_q_F_Kz_XQ_1_b_b_T_1_Q_U __pyx_string_tab[377] +#define __pyx_kp_b_iso88591_R_a_a_a_1_q_F_Kz_XQ_1_b_b_T_1_Q __pyx_string_tab[378] +#define __pyx_kp_b_iso88591_R_a_a_a_1_q_F_Kz_XQ_1_b_b_T_1_Q_2 __pyx_string_tab[379] +#define __pyx_kp_b_iso88591_a_a_1_q_F_Kz_XQ_1_b_b_T_1_Q_U_1 __pyx_string_tab[380] +#define __pyx_kp_b_iso88591_f_AQ_a_a_a_a_a_a_a_1F_1_2V2S_r __pyx_string_tab[381] +#define __pyx_kp_b_iso88591_j_AQ_A_Q_Q_1_A_Q_Q_1_1_2V2S_r_C __pyx_string_tab[382] +#define __pyx_kp_b_iso88591_j_AQ_A_Q_Q_1_A_Q_Q_1_1_F_Kz_XQ __pyx_string_tab[383] +#define __pyx_n_b_O __pyx_string_tab[384] +#define __pyx_float_0_0 __pyx_number_tab[0] +#define __pyx_int_0 __pyx_number_tab[1] +#define __pyx_int_neg_1 __pyx_number_tab[2] +#define __pyx_int_1 __pyx_number_tab[3] +#define __pyx_int_2 __pyx_number_tab[4] +#define __pyx_int_3 __pyx_number_tab[5] +#define __pyx_int_20 __pyx_number_tab[6] +#define __pyx_int_neg_999 __pyx_number_tab[7] +#define __pyx_int_136983863 __pyx_number_tab[8] +/* #### Code section: module_state_clear ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_clear(PyObject *m) { + __pyx_mstatetype *clear_module_state = __Pyx_PyModule_GetState(m); + if (!clear_module_state) return 0; + Py_CLEAR(clear_module_state->__pyx_d); + Py_CLEAR(clear_module_state->__pyx_b); + Py_CLEAR(clear_module_state->__pyx_cython_runtime); + Py_CLEAR(clear_module_state->__pyx_empty_tuple); + Py_CLEAR(clear_module_state->__pyx_empty_bytes); + Py_CLEAR(clear_module_state->__pyx_empty_unicode); + #if CYTHON_PEP489_MULTI_PHASE_INIT + __Pyx_State_RemoveModule(NULL); + #endif + Py_CLEAR(clear_module_state->__pyx_ptype_7cpython_4type_type); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_dtype); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flatiter); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_broadcast); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ndarray); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_generic); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_number); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_integer); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_signedinteger); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_unsignedinteger); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_inexact); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_floating); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_complexfloating); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_flexible); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_character); + Py_CLEAR(clear_module_state->__pyx_ptype_5numpy_ufunc); + Py_CLEAR(clear_module_state->__pyx_ptype_4cssm___pyx_defaults); + Py_CLEAR(clear_module_state->__pyx_type_4cssm___pyx_defaults); + Py_CLEAR(clear_module_state->__pyx_ptype_4cssm___pyx_defaults1); + Py_CLEAR(clear_module_state->__pyx_type_4cssm___pyx_defaults1); + Py_CLEAR(clear_module_state->__pyx_array_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_array); + Py_CLEAR(clear_module_state->__pyx_MemviewEnum_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_MemviewEnum); + Py_CLEAR(clear_module_state->__pyx_memoryview_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryview); + Py_CLEAR(clear_module_state->__pyx_memoryviewslice_type); + Py_CLEAR(clear_module_state->__pyx_type___pyx_memoryviewslice); + for (int i=0; i<1; ++i) { Py_CLEAR(clear_module_state->__pyx_slice[i]); } + for (int i=0; i<3; ++i) { Py_CLEAR(clear_module_state->__pyx_tuple[i]); } + for (int i=0; i<24; ++i) { Py_CLEAR(clear_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<385; ++i) { Py_CLEAR(clear_module_state->__pyx_string_tab[i]); } + for (int i=0; i<9; ++i) { Py_CLEAR(clear_module_state->__pyx_number_tab[i]); } +/* #### Code section: module_state_clear_contents ### */ +/* CommonTypesMetaclass.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CommonTypesMetaclassType); + +/* CythonFunctionShared.module_state_clear */ +Py_CLEAR(clear_module_state->__pyx_CyFunctionType); + +/* #### Code section: module_state_clear_end ### */ +return 0; +} +#endif +/* #### Code section: module_state_traverse ### */ +#if CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __pyx_m_traverse(PyObject *m, visitproc visit, void *arg) { + __pyx_mstatetype *traverse_module_state = __Pyx_PyModule_GetState(m); + if (!traverse_module_state) return 0; + Py_VISIT(traverse_module_state->__pyx_d); + Py_VISIT(traverse_module_state->__pyx_b); + Py_VISIT(traverse_module_state->__pyx_cython_runtime); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_tuple); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_bytes); + __Pyx_VISIT_CONST(traverse_module_state->__pyx_empty_unicode); + Py_VISIT(traverse_module_state->__pyx_ptype_7cpython_4type_type); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_dtype); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flatiter); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_broadcast); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ndarray); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_generic); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_number); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_integer); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_signedinteger); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_unsignedinteger); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_inexact); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_floating); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_complexfloating); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_flexible); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_character); + Py_VISIT(traverse_module_state->__pyx_ptype_5numpy_ufunc); + Py_VISIT(traverse_module_state->__pyx_ptype_4cssm___pyx_defaults); + Py_VISIT(traverse_module_state->__pyx_type_4cssm___pyx_defaults); + Py_VISIT(traverse_module_state->__pyx_ptype_4cssm___pyx_defaults1); + Py_VISIT(traverse_module_state->__pyx_type_4cssm___pyx_defaults1); + Py_VISIT(traverse_module_state->__pyx_array_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_array); + Py_VISIT(traverse_module_state->__pyx_MemviewEnum_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_MemviewEnum); + Py_VISIT(traverse_module_state->__pyx_memoryview_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryview); + Py_VISIT(traverse_module_state->__pyx_memoryviewslice_type); + Py_VISIT(traverse_module_state->__pyx_type___pyx_memoryviewslice); + for (int i=0; i<1; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_slice[i]); } + for (int i=0; i<3; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_tuple[i]); } + for (int i=0; i<24; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_codeobj_tab[i]); } + for (int i=0; i<385; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_string_tab[i]); } + for (int i=0; i<9; ++i) { __Pyx_VISIT_CONST(traverse_module_state->__pyx_number_tab[i]); } +/* #### Code section: module_state_traverse_contents ### */ +/* CommonTypesMetaclass.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CommonTypesMetaclassType); + +/* CythonFunctionShared.module_state_traverse */ +Py_VISIT(traverse_module_state->__pyx_CyFunctionType); + +/* #### Code section: module_state_traverse_end ### */ +return 0; +} +#endif +/* #### Code section: module_code ### */ + +/* "View.MemoryView":129 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * +*/ + +/* Python wrapper */ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_array___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_shape = 0; + Py_ssize_t __pyx_v_itemsize; + PyObject *__pyx_v_format = 0; + PyObject *__pyx_v_mode = 0; + int __pyx_v_allocate_buffer; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[5] = {0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_shape,&__pyx_mstate_global->__pyx_n_u_itemsize,&__pyx_mstate_global->__pyx_n_u_format,&__pyx_mstate_global->__pyx_n_u_mode,&__pyx_mstate_global->__pyx_n_u_allocate_buffer,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 129, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(1, 129, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(1, 129, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 129, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 129, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 129, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < (0)) __PYX_ERR(1, 129, __pyx_L3_error) + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_n_u_c)); + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, i); __PYX_ERR(1, 129, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 5: + values[4] = __Pyx_ArgRef_VARARGS(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(1, 129, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_VARARGS(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(1, 129, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 129, __pyx_L3_error) + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 129, __pyx_L3_error) + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 129, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[3]) values[3] = __Pyx_NewRef(((PyObject *)__pyx_mstate_global->__pyx_n_u_c)); + } + __pyx_v_shape = ((PyObject*)values[0]); + __pyx_v_itemsize = __Pyx_PyIndex_AsSsize_t(values[1]); if (unlikely((__pyx_v_itemsize == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 129, __pyx_L3_error) + __pyx_v_format = values[2]; + __pyx_v_mode = values[3]; + if (values[4]) { + __pyx_v_allocate_buffer = __Pyx_PyObject_IsTrue(values[4]); if (unlikely((__pyx_v_allocate_buffer == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 130, __pyx_L3_error) + } else { + + /* "View.MemoryView":130 + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, + * mode="c", bint allocate_buffer=True): # <<<<<<<<<<<<<< + * + * cdef int idx +*/ + __pyx_v_allocate_buffer = ((int)1); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 3, 5, __pyx_nargs); __PYX_ERR(1, 129, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_shape), (&PyTuple_Type), 1, "shape", 1))) __PYX_ERR(1, 129, __pyx_L1_error) + if (unlikely(((PyObject *)__pyx_v_format) == Py_None)) { + PyErr_Format(PyExc_TypeError, "Argument '%.200s' must not be None", "format"); __PYX_ERR(1, 129, __pyx_L1_error) + } + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v_shape, __pyx_v_itemsize, __pyx_v_format, __pyx_v_mode, __pyx_v_allocate_buffer); + + /* "View.MemoryView":129 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = -1; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array___cinit__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, PyObject *__pyx_v_format, PyObject *__pyx_v_mode, int __pyx_v_allocate_buffer) { + int __pyx_v_idx; + Py_ssize_t __pyx_v_dim; + char __pyx_v_order; + int __pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + char *__pyx_t_7; + int __pyx_t_8; + Py_ssize_t __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11[5]; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + __Pyx_INCREF(__pyx_v_format); + + /* "View.MemoryView":135 + * cdef Py_ssize_t dim + * + * self.ndim = len(shape) # <<<<<<<<<<<<<< + * self.itemsize = itemsize + * +*/ + if (unlikely(__pyx_v_shape == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 135, __pyx_L1_error) + } + __pyx_t_1 = __Pyx_PyTuple_GET_SIZE(__pyx_v_shape); if (unlikely(__pyx_t_1 == ((Py_ssize_t)-1))) __PYX_ERR(1, 135, __pyx_L1_error) + __pyx_v_self->ndim = ((int)__pyx_t_1); + + /* "View.MemoryView":136 + * + * self.ndim = len(shape) + * self.itemsize = itemsize # <<<<<<<<<<<<<< + * + * if not self.ndim: +*/ + __pyx_v_self->itemsize = __pyx_v_itemsize; + + /* "View.MemoryView":138 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError, "Empty shape tuple for cython.array" + * +*/ + __pyx_t_2 = (!(__pyx_v_self->ndim != 0)); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":139 + * + * if not self.ndim: + * raise ValueError, "Empty shape tuple for cython.array" # <<<<<<<<<<<<<< + * + * if itemsize <= 0: +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Empty_shape_tuple_for_cython_arr, 0, 0); + __PYX_ERR(1, 139, __pyx_L1_error) + + /* "View.MemoryView":138 + * self.itemsize = itemsize + * + * if not self.ndim: # <<<<<<<<<<<<<< + * raise ValueError, "Empty shape tuple for cython.array" + * +*/ + } + + /* "View.MemoryView":141 + * raise ValueError, "Empty shape tuple for cython.array" + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError, "itemsize <= 0 for cython.array" + * +*/ + __pyx_t_2 = (__pyx_v_itemsize <= 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":142 + * + * if itemsize <= 0: + * raise ValueError, "itemsize <= 0 for cython.array" # <<<<<<<<<<<<<< + * + * if not isinstance(format, bytes): +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_itemsize_0_for_cython_array, 0, 0); + __PYX_ERR(1, 142, __pyx_L1_error) + + /* "View.MemoryView":141 + * raise ValueError, "Empty shape tuple for cython.array" + * + * if itemsize <= 0: # <<<<<<<<<<<<<< + * raise ValueError, "itemsize <= 0 for cython.array" + * +*/ + } + + /* "View.MemoryView":144 + * raise ValueError, "itemsize <= 0 for cython.array" + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string +*/ + __pyx_t_2 = PyBytes_Check(__pyx_v_format); + __pyx_t_3 = (!__pyx_t_2); + if (__pyx_t_3) { + + /* "View.MemoryView":145 + * + * if not isinstance(format, bytes): + * format = format.encode('ASCII') # <<<<<<<<<<<<<< + * self._format = format # keep a reference to the byte string + * self.format = self._format +*/ + __pyx_t_5 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_n_u_ASCII}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_encode, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF_SET(__pyx_v_format, __pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":144 + * raise ValueError, "itemsize <= 0 for cython.array" + * + * if not isinstance(format, bytes): # <<<<<<<<<<<<<< + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string +*/ + } + + /* "View.MemoryView":146 + * if not isinstance(format, bytes): + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string # <<<<<<<<<<<<<< + * self.format = self._format + * +*/ + __pyx_t_4 = __pyx_v_format; + __Pyx_INCREF(__pyx_t_4); + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_4))) __PYX_ERR(1, 146, __pyx_L1_error) + __Pyx_GIVEREF(__pyx_t_4); + __Pyx_GOTREF(__pyx_v_self->_format); + __Pyx_DECREF(__pyx_v_self->_format); + __pyx_v_self->_format = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":147 + * format = format.encode('ASCII') + * self._format = format # keep a reference to the byte string + * self.format = self._format # <<<<<<<<<<<<<< + * + * +*/ + if (unlikely(__pyx_v_self->_format == Py_None)) { + PyErr_SetString(PyExc_TypeError, "expected bytes, NoneType found"); + __PYX_ERR(1, 147, __pyx_L1_error) + } + __pyx_t_7 = __Pyx_PyBytes_AsWritableString(__pyx_v_self->_format); if (unlikely((!__pyx_t_7) && PyErr_Occurred())) __PYX_ERR(1, 147, __pyx_L1_error) + __pyx_v_self->format = __pyx_t_7; + + /* "View.MemoryView":150 + * + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) # <<<<<<<<<<<<<< + * self._strides = self._shape + self.ndim + * +*/ + __pyx_v_self->_shape = ((Py_ssize_t *)PyObject_Malloc((((sizeof(Py_ssize_t)) * __pyx_v_self->ndim) * 2))); + + /* "View.MemoryView":151 + * + * self._shape = PyObject_Malloc(sizeof(Py_ssize_t)*self.ndim*2) + * self._strides = self._shape + self.ndim # <<<<<<<<<<<<<< + * + * if not self._shape: +*/ + __pyx_v_self->_strides = (__pyx_v_self->_shape + __pyx_v_self->ndim); + + /* "View.MemoryView":153 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate shape and strides." + * +*/ + __pyx_t_3 = (!(__pyx_v_self->_shape != 0)); + if (unlikely(__pyx_t_3)) { + + /* "View.MemoryView":154 + * + * if not self._shape: + * raise MemoryError, "unable to allocate shape and strides." # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_MemoryError))), __pyx_mstate_global->__pyx_kp_u_unable_to_allocate_shape_and_str, 0, 0); + __PYX_ERR(1, 154, __pyx_L1_error) + + /* "View.MemoryView":153 + * self._strides = self._shape + self.ndim + * + * if not self._shape: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate shape and strides." + * +*/ + } + + /* "View.MemoryView":157 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." +*/ + __pyx_t_8 = 0; + __pyx_t_4 = __pyx_v_shape; __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_4); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 157, __pyx_L1_error) + #endif + if (__pyx_t_1 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_4, __pyx_t_1)); + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_4, __pyx_t_1); + #endif + ++__pyx_t_1; + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_5); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 157, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_9; + __pyx_v_idx = __pyx_t_8; + __pyx_t_8 = (__pyx_t_8 + 1); + + /* "View.MemoryView":158 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + * self._shape[idx] = dim +*/ + __pyx_t_3 = (__pyx_v_dim <= 0); + if (unlikely(__pyx_t_3)) { + + /* "View.MemoryView":159 + * for idx, dim in enumerate(shape): + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." # <<<<<<<<<<<<<< + * self._shape[idx] = dim + * +*/ + __pyx_t_5 = __Pyx_PyUnicode_From_int(__pyx_v_idx, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_10 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11[0] = __pyx_mstate_global->__pyx_kp_u_Invalid_shape_in_axis; + __pyx_t_11[1] = __pyx_t_5; + __pyx_t_11[2] = __pyx_mstate_global->__pyx_kp_u_; + __pyx_t_11[3] = __pyx_t_10; + __pyx_t_11[4] = __pyx_mstate_global->__pyx_kp_u__2; + __pyx_t_12 = __Pyx_PyUnicode_Join(__pyx_t_11, 5, 22 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 2 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_10) + 1, 127); + if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 159, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_t_12, 0, 0); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __PYX_ERR(1, 159, __pyx_L1_error) + + /* "View.MemoryView":158 + * + * for idx, dim in enumerate(shape): + * if dim <= 0: # <<<<<<<<<<<<<< + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + * self._shape[idx] = dim +*/ + } + + /* "View.MemoryView":160 + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." + * self._shape[idx] = dim # <<<<<<<<<<<<<< + * + * cdef char order +*/ + (__pyx_v_self->_shape[__pyx_v_idx]) = __pyx_v_dim; + + /* "View.MemoryView":157 + * + * + * for idx, dim in enumerate(shape): # <<<<<<<<<<<<<< + * if dim <= 0: + * raise ValueError, f"Invalid shape in axis {idx}: {dim}." +*/ + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":163 + * + * cdef char order + * if mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' +*/ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_mode, __pyx_mstate_global->__pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 163, __pyx_L1_error) + if (__pyx_t_3) { + + /* "View.MemoryView":164 + * cdef char order + * if mode == 'c': + * order = b'C' # <<<<<<<<<<<<<< + * self.mode = u'c' + * elif mode == 'fortran': +*/ + __pyx_v_order = 'C'; + + /* "View.MemoryView":165 + * if mode == 'c': + * order = b'C' + * self.mode = u'c' # <<<<<<<<<<<<<< + * elif mode == 'fortran': + * order = b'F' +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_c); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_c); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_mstate_global->__pyx_n_u_c; + + /* "View.MemoryView":163 + * + * cdef char order + * if mode == 'c': # <<<<<<<<<<<<<< + * order = b'C' + * self.mode = u'c' +*/ + goto __pyx_L11; + } + + /* "View.MemoryView":166 + * order = b'C' + * self.mode = u'c' + * elif mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' +*/ + __pyx_t_3 = (__Pyx_PyUnicode_Equals(__pyx_v_mode, __pyx_mstate_global->__pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 166, __pyx_L1_error) + if (likely(__pyx_t_3)) { + + /* "View.MemoryView":167 + * self.mode = u'c' + * elif mode == 'fortran': + * order = b'F' # <<<<<<<<<<<<<< + * self.mode = u'fortran' + * else: +*/ + __pyx_v_order = 'F'; + + /* "View.MemoryView":168 + * elif mode == 'fortran': + * order = b'F' + * self.mode = u'fortran' # <<<<<<<<<<<<<< + * else: + * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_fortran); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_n_u_fortran); + __Pyx_GOTREF(__pyx_v_self->mode); + __Pyx_DECREF(__pyx_v_self->mode); + __pyx_v_self->mode = __pyx_mstate_global->__pyx_n_u_fortran; + + /* "View.MemoryView":166 + * order = b'C' + * self.mode = u'c' + * elif mode == 'fortran': # <<<<<<<<<<<<<< + * order = b'F' + * self.mode = u'fortran' +*/ + goto __pyx_L11; + } + + /* "View.MemoryView":170 + * self.mode = u'fortran' + * else: + * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" # <<<<<<<<<<<<<< + * + * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) +*/ + /*else*/ { + __pyx_t_4 = __Pyx_PyObject_FormatSimple(__pyx_v_mode, __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_kp_u_Invalid_mode_expected_c_or_fortr, __pyx_t_4); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_t_12, 0, 0); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __PYX_ERR(1, 170, __pyx_L1_error) + } + __pyx_L11:; + + /* "View.MemoryView":172 + * raise ValueError, f"Invalid mode, expected 'c' or 'fortran', got {mode}" + * + * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) # <<<<<<<<<<<<<< + * + * self.free_data = allocate_buffer +*/ + __pyx_v_self->len = __pyx_fill_contig_strides_array(__pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_itemsize, __pyx_v_self->ndim, __pyx_v_order); + + /* "View.MemoryView":174 + * self.len = fill_contig_strides_array(self._shape, self._strides, itemsize, self.ndim, order) + * + * self.free_data = allocate_buffer # <<<<<<<<<<<<<< + * self.dtype_is_object = format == b'O' + * +*/ + __pyx_v_self->free_data = __pyx_v_allocate_buffer; + + /* "View.MemoryView":175 + * + * self.free_data = allocate_buffer + * self.dtype_is_object = format == b'O' # <<<<<<<<<<<<<< + * + * if allocate_buffer: +*/ + __pyx_t_12 = PyObject_RichCompare(__pyx_v_format, __pyx_mstate_global->__pyx_n_b_O, Py_EQ); __Pyx_XGOTREF(__pyx_t_12); if (unlikely(!__pyx_t_12)) __PYX_ERR(1, 175, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_t_12); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 175, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_v_self->dtype_is_object = __pyx_t_3; + + /* "View.MemoryView":177 + * self.dtype_is_object = format == b'O' + * + * if allocate_buffer: # <<<<<<<<<<<<<< + * _allocate_buffer(self) + * +*/ + if (__pyx_v_allocate_buffer) { + + /* "View.MemoryView":178 + * + * if allocate_buffer: + * _allocate_buffer(self) # <<<<<<<<<<<<<< + * + * @cname('getbuffer') +*/ + __pyx_t_8 = __pyx_array_allocate_buffer(__pyx_v_self); if (unlikely(__pyx_t_8 == ((int)-1))) __PYX_ERR(1, 178, __pyx_L1_error) + + /* "View.MemoryView":177 + * self.dtype_is_object = format == b'O' + * + * if allocate_buffer: # <<<<<<<<<<<<<< + * _allocate_buffer(self) + * +*/ + } + + /* "View.MemoryView":129 + * cdef bint dtype_is_object + * + * def __cinit__(array self, tuple shape, Py_ssize_t itemsize, format not None, # <<<<<<<<<<<<<< + * mode="c", bint allocate_buffer=True): + * +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_AddTraceback("View.MemoryView.array.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_format); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":180 + * _allocate_buffer(self) + * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 +*/ + +/* Python wrapper */ +CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +CYTHON_UNUSED static int __pyx_array_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(((struct __pyx_array_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_2__getbuffer__(struct __pyx_array_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_v_bufmode; + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + char *__pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + Py_ssize_t *__pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (unlikely(__pyx_v_info == NULL)) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":182 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 # <<<<<<<<<<<<<< + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": +*/ + __pyx_v_bufmode = -1; + + /* "View.MemoryView":183 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS +*/ + __pyx_t_1 = ((__pyx_v_flags & ((PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS) | PyBUF_ANY_CONTIGUOUS)) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":184 + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": +*/ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_mstate_global->__pyx_n_u_c, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 184, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":185 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS +*/ + __pyx_v_bufmode = (PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":184 + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): + * if self.mode == u"c": # <<<<<<<<<<<<<< + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": +*/ + goto __pyx_L4; + } + + /* "View.MemoryView":186 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): +*/ + __pyx_t_1 = (__Pyx_PyUnicode_Equals(__pyx_v_self->mode, __pyx_mstate_global->__pyx_n_u_fortran, Py_EQ)); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 186, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":187 + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS # <<<<<<<<<<<<<< + * if not (flags & bufmode): + * raise ValueError, "Can only create a buffer that is contiguous in memory." +*/ + __pyx_v_bufmode = (PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS); + + /* "View.MemoryView":186 + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * elif self.mode == u"fortran": # <<<<<<<<<<<<<< + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): +*/ + } + __pyx_L4:; + + /* "View.MemoryView":188 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data +*/ + __pyx_t_1 = (!((__pyx_v_flags & __pyx_v_bufmode) != 0)); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":189 + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): + * raise ValueError, "Can only create a buffer that is contiguous in memory." # <<<<<<<<<<<<<< + * info.buf = self.data + * info.len = self.len +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Can_only_create_a_buffer_that_is, 0, 0); + __PYX_ERR(1, 189, __pyx_L1_error) + + /* "View.MemoryView":188 + * elif self.mode == u"fortran": + * bufmode = PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS + * if not (flags & bufmode): # <<<<<<<<<<<<<< + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data +*/ + } + + /* "View.MemoryView":183 + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 + * if flags & (PyBUF_C_CONTIGUOUS | PyBUF_F_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS): # <<<<<<<<<<<<<< + * if self.mode == u"c": + * bufmode = PyBUF_C_CONTIGUOUS | PyBUF_ANY_CONTIGUOUS +*/ + } + + /* "View.MemoryView":190 + * if not (flags & bufmode): + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data # <<<<<<<<<<<<<< + * info.len = self.len + * +*/ + __pyx_t_2 = __pyx_v_self->data; + __pyx_v_info->buf = __pyx_t_2; + + /* "View.MemoryView":191 + * raise ValueError, "Can only create a buffer that is contiguous in memory." + * info.buf = self.data + * info.len = self.len # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: +*/ + __pyx_t_3 = __pyx_v_self->len; + __pyx_v_info->len = __pyx_t_3; + + /* "View.MemoryView":193 + * info.len = self.len + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":194 + * + * if flags & PyBUF_STRIDES: + * info.ndim = self.ndim # <<<<<<<<<<<<<< + * info.shape = self._shape + * info.strides = self._strides +*/ + __pyx_t_4 = __pyx_v_self->ndim; + __pyx_v_info->ndim = __pyx_t_4; + + /* "View.MemoryView":195 + * if flags & PyBUF_STRIDES: + * info.ndim = self.ndim + * info.shape = self._shape # <<<<<<<<<<<<<< + * info.strides = self._strides + * else: +*/ + __pyx_t_5 = __pyx_v_self->_shape; + __pyx_v_info->shape = __pyx_t_5; + + /* "View.MemoryView":196 + * info.ndim = self.ndim + * info.shape = self._shape + * info.strides = self._strides # <<<<<<<<<<<<<< + * else: + * info.ndim = 1 +*/ + __pyx_t_5 = __pyx_v_self->_strides; + __pyx_v_info->strides = __pyx_t_5; + + /* "View.MemoryView":193 + * info.len = self.len + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.ndim = self.ndim + * info.shape = self._shape +*/ + goto __pyx_L6; + } + + /* "View.MemoryView":198 + * info.strides = self._strides + * else: + * info.ndim = 1 # <<<<<<<<<<<<<< + * info.shape = &self.len if flags & PyBUF_ND else NULL + * info.strides = NULL +*/ + /*else*/ { + __pyx_v_info->ndim = 1; + + /* "View.MemoryView":199 + * else: + * info.ndim = 1 + * info.shape = &self.len if flags & PyBUF_ND else NULL # <<<<<<<<<<<<<< + * info.strides = NULL + * +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + if (__pyx_t_1) { + __pyx_t_5 = (&__pyx_v_self->len); + } else { + __pyx_t_5 = NULL; + } + __pyx_v_info->shape = __pyx_t_5; + + /* "View.MemoryView":200 + * info.ndim = 1 + * info.shape = &self.len if flags & PyBUF_ND else NULL + * info.strides = NULL # <<<<<<<<<<<<<< + * + * info.suboffsets = NULL +*/ + __pyx_v_info->strides = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":202 + * info.strides = NULL + * + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * info.itemsize = self.itemsize + * info.readonly = 0 +*/ + __pyx_v_info->suboffsets = NULL; + + /* "View.MemoryView":203 + * + * info.suboffsets = NULL + * info.itemsize = self.itemsize # <<<<<<<<<<<<<< + * info.readonly = 0 + * info.format = self.format if flags & PyBUF_FORMAT else NULL +*/ + __pyx_t_3 = __pyx_v_self->itemsize; + __pyx_v_info->itemsize = __pyx_t_3; + + /* "View.MemoryView":204 + * info.suboffsets = NULL + * info.itemsize = self.itemsize + * info.readonly = 0 # <<<<<<<<<<<<<< + * info.format = self.format if flags & PyBUF_FORMAT else NULL + * info.obj = self +*/ + __pyx_v_info->readonly = 0; + + /* "View.MemoryView":205 + * info.itemsize = self.itemsize + * info.readonly = 0 + * info.format = self.format if flags & PyBUF_FORMAT else NULL # <<<<<<<<<<<<<< + * info.obj = self + * +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + __pyx_t_2 = __pyx_v_self->format; + } else { + __pyx_t_2 = NULL; + } + __pyx_v_info->format = __pyx_t_2; + + /* "View.MemoryView":206 + * info.readonly = 0 + * info.format = self.format if flags & PyBUF_FORMAT else NULL + * info.obj = self # <<<<<<<<<<<<<< + * + * def __dealloc__(array self): +*/ + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":180 + * _allocate_buffer(self) + * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * cdef int bufmode = -1 +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.array.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":208 + * info.obj = self + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) +*/ + +/* Python wrapper */ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_array___dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_array___pyx_pf_15View_dot_MemoryView_5array_4__dealloc__(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_t_1; + int __pyx_t_2; + + /* "View.MemoryView":209 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: +*/ + __pyx_t_1 = (__pyx_v_self->callback_free_data != NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":210 + * def __dealloc__(array self): + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) # <<<<<<<<<<<<<< + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: +*/ + __pyx_v_self->callback_free_data(__pyx_v_self->data); + + /* "View.MemoryView":209 + * + * def __dealloc__(array self): + * if self.callback_free_data != NULL: # <<<<<<<<<<<<<< + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":211 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) +*/ + if (__pyx_v_self->free_data) { + } else { + __pyx_t_1 = __pyx_v_self->free_data; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_self->data != NULL); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":212 + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) +*/ + if (__pyx_v_self->dtype_is_object) { + + /* "View.MemoryView":213 + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) # <<<<<<<<<<<<<< + * free(self.data) + * PyObject_Free(self._shape) +*/ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_self->data, __pyx_v_self->_shape, __pyx_v_self->_strides, __pyx_v_self->ndim, 0); + + /* "View.MemoryView":212 + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) +*/ + } + + /* "View.MemoryView":214 + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) # <<<<<<<<<<<<<< + * PyObject_Free(self._shape) + * +*/ + free(__pyx_v_self->data); + + /* "View.MemoryView":211 + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) + * elif self.free_data and self.data is not NULL: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) +*/ + } + __pyx_L3:; + + /* "View.MemoryView":215 + * refcount_objects_in_slice(self.data, self._shape, self._strides, self.ndim, inc=False) + * free(self.data) + * PyObject_Free(self._shape) # <<<<<<<<<<<<<< + * + * @property +*/ + PyObject_Free(__pyx_v_self->_shape); + + /* "View.MemoryView":208 + * info.obj = self + * + * def __dealloc__(array self): # <<<<<<<<<<<<<< + * if self.callback_free_data != NULL: + * self.callback_free_data(self.data) +*/ + + /* function exit code */ +} + +/* "View.MemoryView":217 + * PyObject_Free(self._shape) + * + * @property # <<<<<<<<<<<<<< + * def memview(self): + * return self.get_memview() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_5array_7memview___get__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_5array_7memview___get__(struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":219 + * @property + * def memview(self): + * return self.get_memview() # <<<<<<<<<<<<<< + * + * @cname('get_memview') +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_array *)__pyx_v_self->__pyx_vtab)->get_memview(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":217 + * PyObject_Free(self._shape) + * + * @property # <<<<<<<<<<<<<< + * def memview(self): + * return self.get_memview() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.memview.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":221 + * return self.get_memview() + * + * @cname('get_memview') # <<<<<<<<<<<<<< + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE +*/ + +static PyObject *__pyx_array_get_memview(struct __pyx_array_obj *__pyx_v_self) { + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_memview", 0); + + /* "View.MemoryView":223 + * @cname('get_memview') + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE # <<<<<<<<<<<<<< + * return memoryview(self, flags, self.dtype_is_object) + * +*/ + __pyx_v_flags = ((PyBUF_ANY_CONTIGUOUS | PyBUF_FORMAT) | PyBUF_WRITABLE); + + /* "View.MemoryView":224 + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE + * return memoryview(self, flags, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * def __len__(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = NULL; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[4] = {__pyx_t_2, ((PyObject *)__pyx_v_self), __pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_memoryview_type, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 224, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_r = ((PyObject *)__pyx_t_1); + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":221 + * return self.get_memview() + * + * @cname('get_memview') # <<<<<<<<<<<<<< + * cdef get_memview(self): + * flags = PyBUF_ANY_CONTIGUOUS|PyBUF_FORMAT|PyBUF_WRITABLE +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.array.get_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":226 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * +*/ + +/* Python wrapper */ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_array___len__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_array___pyx_pf_15View_dot_MemoryView_5array_6__len__(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + + /* "View.MemoryView":227 + * + * def __len__(self): + * return self._shape[0] # <<<<<<<<<<<<<< + * + * def __getattr__(self, attr): +*/ + __pyx_r = (__pyx_v_self->_shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":226 + * return memoryview(self, flags, self.dtype_is_object) + * + * def __len__(self): # <<<<<<<<<<<<<< + * return self._shape[0] + * +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":229 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr); /*proto*/ +static PyObject *__pyx_array___getattr__(PyObject *__pyx_v_self, PyObject *__pyx_v_attr) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getattr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_attr)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_8__getattr__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_attr) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getattr__", 0); + + /* "View.MemoryView":230 + * + * def __getattr__(self, attr): + * return getattr(self.memview, attr) # <<<<<<<<<<<<<< + * + * def __getitem__(self, item): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_GetAttr(__pyx_t_1, __pyx_v_attr); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":229 + * return self._shape[0] + * + * def __getattr__(self, attr): # <<<<<<<<<<<<<< + * return getattr(self.memview, attr) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getattr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":232 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item); /*proto*/ +static PyObject *__pyx_array___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_array___pyx_pf_15View_dot_MemoryView_5array_10__getitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":233 + * + * def __getitem__(self, item): + * return self.memview[item] # <<<<<<<<<<<<<< + * + * def __setitem__(self, item, value): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetItem(__pyx_t_1, __pyx_v_item); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":232 + * return getattr(self.memview, attr) + * + * def __getitem__(self, item): # <<<<<<<<<<<<<< + * return self.memview[item] + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.array.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":235 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * +*/ + +/* Python wrapper */ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_array___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(((struct __pyx_array_obj *)__pyx_v_self), ((PyObject *)__pyx_v_item), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_array___pyx_pf_15View_dot_MemoryView_5array_12__setitem__(struct __pyx_array_obj *__pyx_v_self, PyObject *__pyx_v_item, PyObject *__pyx_v_value) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + + /* "View.MemoryView":236 + * + * def __setitem__(self, item, value): + * self.memview[item] = value # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_memview); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 236, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (unlikely((PyObject_SetItem(__pyx_t_1, __pyx_v_item, __pyx_v_value) < 0))) __PYX_ERR(1, 236, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":235 + * return self.memview[item] + * + * def __setitem__(self, item, value): # <<<<<<<<<<<<<< + * self.memview[item] = value + * +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.array.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_array_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf___pyx_array___reduce_cython__(((struct __pyx_array_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array___reduce_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.array.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_array_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_array_2__setstate_cython__(((struct __pyx_array_obj *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_array_2__setstate_cython__(CYTHON_UNUSED struct __pyx_array_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.array.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":245 + * pass + * + * @cname("__pyx_array_allocate_buffer") # <<<<<<<<<<<<<< + * cdef int _allocate_buffer(array self) except -1: + * +*/ + +static int __pyx_array_allocate_buffer(struct __pyx_array_obj *__pyx_v_self) { + Py_ssize_t __pyx_v_i; + PyObject **__pyx_v_p; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":252 + * cdef PyObject **p + * + * self.free_data = True # <<<<<<<<<<<<<< + * self.data = malloc(self.len) + * if not self.data: +*/ + __pyx_v_self->free_data = 1; + + /* "View.MemoryView":253 + * + * self.free_data = True + * self.data = malloc(self.len) # <<<<<<<<<<<<<< + * if not self.data: + * raise MemoryError, "unable to allocate array data." +*/ + __pyx_v_self->data = ((char *)malloc(__pyx_v_self->len)); + + /* "View.MemoryView":254 + * self.free_data = True + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate array data." + * +*/ + __pyx_t_1 = (!(__pyx_v_self->data != 0)); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":255 + * self.data = malloc(self.len) + * if not self.data: + * raise MemoryError, "unable to allocate array data." # <<<<<<<<<<<<<< + * + * if self.dtype_is_object: +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_MemoryError))), __pyx_mstate_global->__pyx_kp_u_unable_to_allocate_array_data, 0, 0); + __PYX_ERR(1, 255, __pyx_L1_error) + + /* "View.MemoryView":254 + * self.free_data = True + * self.data = malloc(self.len) + * if not self.data: # <<<<<<<<<<<<<< + * raise MemoryError, "unable to allocate array data." + * +*/ + } + + /* "View.MemoryView":257 + * raise MemoryError, "unable to allocate array data." + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len // self.itemsize): +*/ + if (__pyx_v_self->dtype_is_object) { + + /* "View.MemoryView":258 + * + * if self.dtype_is_object: + * p = self.data # <<<<<<<<<<<<<< + * for i in range(self.len // self.itemsize): + * p[i] = Py_None +*/ + __pyx_v_p = ((PyObject **)__pyx_v_self->data); + + /* "View.MemoryView":259 + * if self.dtype_is_object: + * p = self.data + * for i in range(self.len // self.itemsize): # <<<<<<<<<<<<<< + * p[i] = Py_None + * Py_INCREF(Py_None) +*/ + if (unlikely(__pyx_v_self->itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 259, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_self->itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_self->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 259, __pyx_L1_error) + } + __pyx_t_2 = __Pyx_div_Py_ssize_t(__pyx_v_self->len, __pyx_v_self->itemsize, 0); + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":260 + * p = self.data + * for i in range(self.len // self.itemsize): + * p[i] = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * return 0 +*/ + (__pyx_v_p[__pyx_v_i]) = Py_None; + + /* "View.MemoryView":261 + * for i in range(self.len // self.itemsize): + * p[i] = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * return 0 + * +*/ + Py_INCREF(Py_None); + } + + /* "View.MemoryView":257 + * raise MemoryError, "unable to allocate array data." + * + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * p = self.data + * for i in range(self.len // self.itemsize): +*/ + } + + /* "View.MemoryView":262 + * p[i] = Py_None + * Py_INCREF(Py_None) + * return 0 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":245 + * pass + * + * @cname("__pyx_array_allocate_buffer") # <<<<<<<<<<<<<< + * cdef int _allocate_buffer(array self) except -1: + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._allocate_buffer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":265 + * + * + * @cname("__pyx_array_new") # <<<<<<<<<<<<<< + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, const char *c_mode, char *buf): + * cdef array result +*/ + +static struct __pyx_array_obj *__pyx_array_new(PyObject *__pyx_v_shape, Py_ssize_t __pyx_v_itemsize, char *__pyx_v_format, char const *__pyx_v_c_mode, char *__pyx_v_buf) { + struct __pyx_array_obj *__pyx_v_result = 0; + PyObject *__pyx_v_mode = 0; + struct __pyx_array_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("array_cwrapper", 0); + + /* "View.MemoryView":268 + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, const char *c_mode, char *buf): + * cdef array result + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. # <<<<<<<<<<<<<< + * + * if buf is NULL: +*/ + __pyx_t_2 = ((__pyx_v_c_mode[0]) == 'f'); + if (__pyx_t_2) { + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_fortran); + __pyx_t_1 = __pyx_mstate_global->__pyx_n_u_fortran; + } else { + __Pyx_INCREF(__pyx_mstate_global->__pyx_n_u_c); + __pyx_t_1 = __pyx_mstate_global->__pyx_n_u_c; + } + __pyx_v_mode = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":270 + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. + * + * if buf is NULL: # <<<<<<<<<<<<<< + * result = array.__new__(array, shape, itemsize, format, mode) + * else: +*/ + __pyx_t_2 = (__pyx_v_buf == NULL); + if (__pyx_t_2) { + + /* "View.MemoryView":271 + * + * if buf is NULL: + * result = array.__new__(array, shape, itemsize, format, mode) # <<<<<<<<<<<<<< + * else: + * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) +*/ + __pyx_t_1 = PyLong_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = PyTuple_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 271, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_v_shape) != (0)) __PYX_ERR(1, 271, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 271, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_t_3) != (0)) __PYX_ERR(1, 271, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_mode); + __Pyx_GIVEREF(__pyx_v_mode); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 3, __pyx_v_mode) != (0)) __PYX_ERR(1, 271, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_3 = 0; + __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_mstate_global->__pyx_array_type), __pyx_t_4, NULL)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 271, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":270 + * cdef str mode = "fortran" if c_mode[0] == b'f' else "c" # this often comes from a constant C string. + * + * if buf is NULL: # <<<<<<<<<<<<<< + * result = array.__new__(array, shape, itemsize, format, mode) + * else: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":273 + * result = array.__new__(array, shape, itemsize, format, mode) + * else: + * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) # <<<<<<<<<<<<<< + * result.data = buf + * +*/ + /*else*/ { + __pyx_t_3 = PyLong_FromSsize_t(__pyx_v_itemsize); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_shape); + __Pyx_GIVEREF(__pyx_v_shape); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_shape) != (0)) __PYX_ERR(1, 273, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_3) != (0)) __PYX_ERR(1, 273, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_t_4) != (0)) __PYX_ERR(1, 273, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_mode); + __Pyx_GIVEREF(__pyx_v_mode); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 3, __pyx_v_mode) != (0)) __PYX_ERR(1, 273, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 273, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_allocate_buffer, Py_False) < (0)) __PYX_ERR(1, 273, __pyx_L1_error) + __pyx_t_3 = ((PyObject *)__pyx_tp_new_array(((PyTypeObject *)__pyx_mstate_global->__pyx_array_type), __pyx_t_1, __pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 273, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_result = ((struct __pyx_array_obj *)__pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":274 + * else: + * result = array.__new__(array, shape, itemsize, format, mode, allocate_buffer=False) + * result.data = buf # <<<<<<<<<<<<<< + * + * return result +*/ + __pyx_v_result->data = __pyx_v_buf; + } + __pyx_L3:; + + /* "View.MemoryView":276 + * result.data = buf + * + * return result # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF((PyObject *)__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":265 + * + * + * @cname("__pyx_array_new") # <<<<<<<<<<<<<< + * cdef array array_cwrapper(tuple shape, Py_ssize_t itemsize, char *format, const char *c_mode, char *buf): + * cdef array result +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.array_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_mode); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":302 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): +*/ + +/* Python wrapper */ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_MemviewEnum___init__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_name = 0; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_name,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 302, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 302, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__init__", 0) < (0)) __PYX_ERR(1, 302, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, i); __PYX_ERR(1, 302, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 302, __pyx_L3_error) + } + __pyx_v_name = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__init__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 302, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.Enum.__init__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v_name); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum___init__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v_name) { + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__init__", 0); + + /* "View.MemoryView":303 + * cdef object name + * def __init__(self, name): + * self.name = name # <<<<<<<<<<<<<< + * def __repr__(self): + * return self.name +*/ + __Pyx_INCREF(__pyx_v_name); + __Pyx_GIVEREF(__pyx_v_name); + __Pyx_GOTREF(__pyx_v_self->name); + __Pyx_DECREF(__pyx_v_self->name); + __pyx_v_self->name = __pyx_v_name; + + /* "View.MemoryView":302 + * cdef class Enum(object): + * cdef object name + * def __init__(self, name): # <<<<<<<<<<<<<< + * self.name = name + * def __repr__(self): +*/ + + /* function exit code */ + __pyx_r = 0; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":304 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_MemviewEnum___repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_MemviewEnum___pyx_pf_15View_dot_MemoryView_4Enum_2__repr__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":305 + * self.name = name + * def __repr__(self): + * return self.name # <<<<<<<<<<<<<< + * + * cdef generic = Enum("") +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->name); + __pyx_r = __pyx_v_self->name; + goto __pyx_L0; + + /* "View.MemoryView":304 + * def __init__(self, name): + * self.name = name + * def __repr__(self): # <<<<<<<<<<<<<< + * return self.name + * +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf___pyx_MemviewEnum___reduce_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum___reduce_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self) { + PyObject *__pyx_v_state = 0; + PyObject *__pyx_v__dict = 0; + int __pyx_v_use_setstate; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":5 + * cdef object _dict + * cdef bint use_setstate + * state = (self.name,) # <<<<<<<<<<<<<< + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: +*/ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 5, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v_self->name); + __Pyx_GIVEREF(__pyx_v_self->name); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v_self->name) != (0)) __PYX_ERR(1, 5, __pyx_L1_error); + __pyx_v_state = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "(tree fragment)":6 + * cdef bint use_setstate + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) # <<<<<<<<<<<<<< + * if _dict is not None and _dict: + * state += (_dict,) +*/ + __pyx_t_1 = __Pyx_GetAttr3(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_dict, Py_None); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 6, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v__dict = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + __pyx_t_3 = (__pyx_v__dict != Py_None); + if (__pyx_t_3) { + } else { + __pyx_t_2 = __pyx_t_3; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_3 = __Pyx_PyObject_IsTrue(__pyx_v__dict); if (unlikely((__pyx_t_3 < 0))) __PYX_ERR(1, 7, __pyx_L1_error) + __pyx_t_2 = __pyx_t_3; + __pyx_L4_bool_binop_done:; + if (__pyx_t_2) { + + /* "(tree fragment)":8 + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: + * state += (_dict,) # <<<<<<<<<<<<<< + * use_setstate = True + * else: +*/ + __pyx_t_1 = PyTuple_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(__pyx_v__dict); + __Pyx_GIVEREF(__pyx_v__dict); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_v__dict) != (0)) __PYX_ERR(1, 8, __pyx_L1_error); + __pyx_t_4 = PyNumber_InPlaceAdd(__pyx_v_state, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 8, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF_SET(__pyx_v_state, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "(tree fragment)":9 + * if _dict is not None and _dict: + * state += (_dict,) + * use_setstate = True # <<<<<<<<<<<<<< + * else: + * use_setstate = ('self.name is not None',) +*/ + __pyx_v_use_setstate = 1; + + /* "(tree fragment)":7 + * state = (self.name,) + * _dict = getattr(self, '__dict__', None) + * if _dict is not None and _dict: # <<<<<<<<<<<<<< + * state += (_dict,) + * use_setstate = True +*/ + goto __pyx_L3; + } + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = ('self.name is not None',) # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state +*/ + /*else*/ { + __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_mstate_global->__pyx_tuple[0]); if (unlikely((__pyx_t_2 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 11, __pyx_L1_error) + __pyx_v_use_setstate = __pyx_t_2; + } + __pyx_L3:; + + /* "(tree fragment)":12 + * else: + * use_setstate = ('self.name is not None',) + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state + * else: +*/ + if (__pyx_v_use_setstate) { + + /* "(tree fragment)":13 + * use_setstate = ('self.name is not None',) + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state # <<<<<<<<<<<<<< + * else: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Enum); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_136983863); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_136983863); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_136983863) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, Py_None) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 13, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 13, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "(tree fragment)":12 + * else: + * use_setstate = ('self.name is not None',) + * if use_setstate: # <<<<<<<<<<<<<< + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state + * else: +*/ + } + + /* "(tree fragment)":15 + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state + * else: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Enum); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_INCREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + __Pyx_GIVEREF(((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, ((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self)))) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_136983863); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_136983863); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_mstate_global->__pyx_int_136983863) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_state); + __Pyx_GIVEREF(__pyx_v_state); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_v_state) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 15, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_1) != (0)) __PYX_ERR(1, 15, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_1 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + } + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * cdef tuple state + * cdef object _dict +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.Enum.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_state); + __Pyx_XDECREF(__pyx_v__dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_MemviewEnum_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 16, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 16, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 16, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 16, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 16, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_MemviewEnum_2__setstate_cython__(((struct __pyx_MemviewEnum_obj *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_MemviewEnum_2__setstate_cython__(struct __pyx_MemviewEnum_obj *__pyx_v_self, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":17 + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) + * def __setstate_cython__(self, __pyx_state): + * __pyx_unpickle_Enum__set_state(self, __pyx_state) # <<<<<<<<<<<<<< +*/ + __pyx_t_1 = __pyx_v___pyx_state; + __Pyx_INCREF(__pyx_t_1); + if (!(likely(PyTuple_CheckExact(__pyx_t_1))||((__pyx_t_1) == Py_None) || __Pyx_RaiseUnexpectedTypeError("tuple", __pyx_t_1))) __PYX_ERR(1, 17, __pyx_L1_error) + if (unlikely(__pyx_t_1 == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 17, __pyx_L1_error) + } + __pyx_t_2 = __pyx_unpickle_Enum__set_state(__pyx_v_self, ((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":16 + * else: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, state) + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state(self, __pyx_state) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.Enum.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":348 + * cdef const __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags +*/ + +/* Python wrapper */ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/ +static int __pyx_memoryview___cinit__(PyObject *__pyx_v_self, PyObject *__pyx_args, PyObject *__pyx_kwds) { + PyObject *__pyx_v_obj = 0; + int __pyx_v_flags; + int __pyx_v_dtype_is_object; + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__cinit__ (wrapper)", 0); + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return -1; + #endif + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_obj,&__pyx_mstate_global->__pyx_n_u_flags,&__pyx_mstate_global->__pyx_n_u_dtype_is_object,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_VARARGS(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 348, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 348, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 348, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 348, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__cinit__", 0) < (0)) __PYX_ERR(1, 348, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 2; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, i); __PYX_ERR(1, 348, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_VARARGS(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 348, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_VARARGS(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 348, __pyx_L3_error) + values[0] = __Pyx_ArgRef_VARARGS(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 348, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_obj = values[0]; + __pyx_v_flags = __Pyx_PyLong_As_int(values[1]); if (unlikely((__pyx_v_flags == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 348, __pyx_L3_error) + if (values[2]) { + __pyx_v_dtype_is_object = __Pyx_PyObject_IsTrue(values[2]); if (unlikely((__pyx_v_dtype_is_object == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 348, __pyx_L3_error) + } else { + __pyx_v_dtype_is_object = ((int)0); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__cinit__", 0, 2, 3, __pyx_nargs); __PYX_ERR(1, 348, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return -1; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_obj, __pyx_v_flags, __pyx_v_dtype_is_object); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview___cinit__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj, int __pyx_v_flags, int __pyx_v_dtype_is_object) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + Py_intptr_t __pyx_t_4; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__cinit__", 0); + + /* "View.MemoryView":349 + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj # <<<<<<<<<<<<<< + * self.flags = flags + * if type(self) is memoryview or obj is not None: +*/ + __Pyx_INCREF(__pyx_v_obj); + __Pyx_GIVEREF(__pyx_v_obj); + __Pyx_GOTREF(__pyx_v_self->obj); + __Pyx_DECREF(__pyx_v_self->obj); + __pyx_v_self->obj = __pyx_v_obj; + + /* "View.MemoryView":350 + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): + * self.obj = obj + * self.flags = flags # <<<<<<<<<<<<<< + * if type(self) is memoryview or obj is not None: + * PyObject_GetBuffer(obj, &self.view, flags) +*/ + __pyx_v_self->flags = __pyx_v_flags; + + /* "View.MemoryView":351 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * PyObject_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: +*/ + __pyx_t_2 = (((PyObject *)Py_TYPE(((PyObject *)__pyx_v_self))) == ((PyObject *)__pyx_mstate_global->__pyx_memoryview_type)); + if (!__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_obj != Py_None); + __pyx_t_1 = __pyx_t_2; + __pyx_L4_bool_binop_done:; + if (__pyx_t_1) { + + /* "View.MemoryView":352 + * self.flags = flags + * if type(self) is memoryview or obj is not None: + * PyObject_GetBuffer(obj, &self.view, flags) # <<<<<<<<<<<<<< + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None +*/ + __pyx_t_3 = PyObject_GetBuffer(__pyx_v_obj, (&__pyx_v_self->view), __pyx_v_flags); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 352, __pyx_L1_error) + + /* "View.MemoryView":353 + * if type(self) is memoryview or obj is not None: + * PyObject_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) +*/ + __pyx_t_1 = (((PyObject *)__pyx_v_self->view.obj) == NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":354 + * PyObject_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * +*/ + ((Py_buffer *)(&__pyx_v_self->view))->obj = Py_None; + + /* "View.MemoryView":355 + * if self.view.obj == NULL: + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): +*/ + Py_INCREF(Py_None); + + /* "View.MemoryView":353 + * if type(self) is memoryview or obj is not None: + * PyObject_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &self.view).obj = Py_None + * Py_INCREF(Py_None) +*/ + } + + /* "View.MemoryView":351 + * self.obj = obj + * self.flags = flags + * if type(self) is memoryview or obj is not None: # <<<<<<<<<<<<<< + * PyObject_GetBuffer(obj, &self.view, flags) + * if self.view.obj == NULL: +*/ + } + + /* "View.MemoryView":357 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and +*/ + __pyx_t_1 = (!__PYX_CYTHON_ATOMICS_ENABLED()); + if (__pyx_t_1) { + + /* "View.MemoryView":359 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and # <<<<<<<<<<<<<< + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): +*/ + __pyx_t_2 = (__pyx_memoryview_thread_locks_used < 8); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L9_bool_binop_done; + } + + /* "View.MemoryView":361 + * if (__pyx_memoryview_thread_locks_used < 8 and + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): # <<<<<<<<<<<<<< + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 +*/ + __pyx_t_2 = (!__PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()); + __pyx_t_1 = __pyx_t_2; + __pyx_L9_bool_binop_done:; + + /* "View.MemoryView":359 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and # <<<<<<<<<<<<<< + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): +*/ + if (__pyx_t_1) { + + /* "View.MemoryView":362 + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: +*/ + __pyx_v_self->lock = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + + /* "View.MemoryView":363 + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 # <<<<<<<<<<<<<< + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() +*/ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used + 1); + + /* "View.MemoryView":359 + * if not __PYX_CYTHON_ATOMICS_ENABLED(): + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and # <<<<<<<<<<<<<< + * + * not __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING()): +*/ + } + + /* "View.MemoryView":364 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: +*/ + __pyx_t_1 = (__pyx_v_self->lock == NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":365 + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() # <<<<<<<<<<<<<< + * if self.lock is NULL: + * raise MemoryError +*/ + __pyx_v_self->lock = PyThread_allocate_lock(); + + /* "View.MemoryView":366 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * +*/ + __pyx_t_1 = (__pyx_v_self->lock == NULL); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":367 + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: +*/ + PyErr_NoMemory(); __PYX_ERR(1, 367, __pyx_L1_error) + + /* "View.MemoryView":366 + * if self.lock is NULL: + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * +*/ + } + + /* "View.MemoryView":364 + * self.lock = __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] + * __pyx_memoryview_thread_locks_used += 1 + * if self.lock is NULL: # <<<<<<<<<<<<<< + * self.lock = PyThread_allocate_lock() + * if self.lock is NULL: +*/ + } + + /* "View.MemoryView":357 + * Py_INCREF(Py_None) + * + * if not __PYX_CYTHON_ATOMICS_ENABLED(): # <<<<<<<<<<<<<< + * global __pyx_memoryview_thread_locks_used + * if (__pyx_memoryview_thread_locks_used < 8 and +*/ + } + + /* "View.MemoryView":369 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":370 + * + * if flags & PyBUF_FORMAT: + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') # <<<<<<<<<<<<<< + * else: + * self.dtype_is_object = dtype_is_object +*/ + __pyx_t_2 = ((__pyx_v_self->view.format[0]) == 'O'); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_2 = ((__pyx_v_self->view.format[1]) == '\x00'); + __pyx_t_1 = __pyx_t_2; + __pyx_L14_bool_binop_done:; + __pyx_v_self->dtype_is_object = __pyx_t_1; + + /* "View.MemoryView":369 + * raise MemoryError + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: +*/ + goto __pyx_L13; + } + + /* "View.MemoryView":372 + * self.dtype_is_object = (self.view.format[0] == b'O' and self.view.format[1] == b'\0') + * else: + * self.dtype_is_object = dtype_is_object # <<<<<<<<<<<<<< + * + * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 +*/ + /*else*/ { + __pyx_v_self->dtype_is_object = __pyx_v_dtype_is_object; + } + __pyx_L13:; + + /* "View.MemoryView":374 + * self.dtype_is_object = dtype_is_object + * + * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 # <<<<<<<<<<<<<< + * self.typeinfo = NULL + * +*/ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_4 = ((Py_intptr_t)((void *)(&__pyx_v_self->acquisition_count))); + __pyx_t_5 = (sizeof(__pyx_atomic_int_type)); + if (unlikely(__pyx_t_5 == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 374, __pyx_L1_error) + } + __pyx_t_1 = ((__pyx_t_4 % __pyx_t_5) == 0); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); + __PYX_ERR(1, 374, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 374, __pyx_L1_error) + #endif + + /* "View.MemoryView":375 + * + * assert (&self.acquisition_count) % sizeof(__pyx_atomic_int_type) == 0 + * self.typeinfo = NULL # <<<<<<<<<<<<<< + * + * def __dealloc__(memoryview self): +*/ + __pyx_v_self->typeinfo = NULL; + + /* "View.MemoryView":348 + * cdef const __Pyx_TypeInfo *typeinfo + * + * def __cinit__(memoryview self, object obj, int flags, bint dtype_is_object=False): # <<<<<<<<<<<<<< + * self.obj = obj + * self.flags = flags +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__cinit__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":377 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * PyBuffer_Release(&self.view) +*/ + +/* Python wrapper */ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryview___dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_2__dealloc__(struct __pyx_memoryview_obj *__pyx_v_self) { + int __pyx_v_i; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + PyThread_type_lock __pyx_t_5; + PyThread_type_lock __pyx_t_6; + + /* "View.MemoryView":378 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * PyBuffer_Release(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: +*/ + __pyx_t_1 = (__pyx_v_self->obj != Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":379 + * def __dealloc__(memoryview self): + * if self.obj is not None: + * PyBuffer_Release(&self.view) # <<<<<<<<<<<<<< + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * +*/ + PyBuffer_Release((&__pyx_v_self->view)); + + /* "View.MemoryView":378 + * + * def __dealloc__(memoryview self): + * if self.obj is not None: # <<<<<<<<<<<<<< + * PyBuffer_Release(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":380 + * if self.obj is not None: + * PyBuffer_Release(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL +*/ + __pyx_t_1 = (((Py_buffer *)(&__pyx_v_self->view))->obj == Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":382 + * elif (<__pyx_buffer *> &self.view).obj == Py_None: + * + * (<__pyx_buffer *> &self.view).obj = NULL # <<<<<<<<<<<<<< + * Py_DECREF(Py_None) + * +*/ + ((Py_buffer *)(&__pyx_v_self->view))->obj = NULL; + + /* "View.MemoryView":383 + * + * (<__pyx_buffer *> &self.view).obj = NULL + * Py_DECREF(Py_None) # <<<<<<<<<<<<<< + * + * cdef int i +*/ + Py_DECREF(Py_None); + + /* "View.MemoryView":380 + * if self.obj is not None: + * PyBuffer_Release(&self.view) + * elif (<__pyx_buffer *> &self.view).obj == Py_None: # <<<<<<<<<<<<<< + * + * (<__pyx_buffer *> &self.view).obj = NULL +*/ + } + __pyx_L3:; + + /* "View.MemoryView":387 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: +*/ + __pyx_t_1 = (__pyx_v_self->lock != NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":388 + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): # <<<<<<<<<<<<<< + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 +*/ + __pyx_t_1 = __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING(); + if (__pyx_t_1) { + __pyx_t_2 = 0; + } else { + __pyx_t_2 = __pyx_memoryview_thread_locks_used; + } + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":389 + * if self.lock != NULL: + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: +*/ + __pyx_t_1 = ((__pyx_memoryview_thread_locks[__pyx_v_i]) == __pyx_v_self->lock); + if (__pyx_t_1) { + + /* "View.MemoryView":390 + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 # <<<<<<<<<<<<<< + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( +*/ + __pyx_memoryview_thread_locks_used = (__pyx_memoryview_thread_locks_used - 1); + + /* "View.MemoryView":391 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) +*/ + __pyx_t_1 = (__pyx_v_i != __pyx_memoryview_thread_locks_used); + if (__pyx_t_1) { + + /* "View.MemoryView":393 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) # <<<<<<<<<<<<<< + * break + * else: +*/ + __pyx_t_5 = (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]); + __pyx_t_6 = (__pyx_memoryview_thread_locks[__pyx_v_i]); + + /* "View.MemoryView":392 + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break +*/ + (__pyx_memoryview_thread_locks[__pyx_v_i]) = __pyx_t_5; + (__pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used]) = __pyx_t_6; + + /* "View.MemoryView":391 + * if __pyx_memoryview_thread_locks[i] is self.lock: + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) +*/ + } + + /* "View.MemoryView":394 + * __pyx_memoryview_thread_locks[i], __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used] = ( + * __pyx_memoryview_thread_locks[__pyx_memoryview_thread_locks_used], __pyx_memoryview_thread_locks[i]) + * break # <<<<<<<<<<<<<< + * else: + * PyThread_free_lock(self.lock) +*/ + goto __pyx_L6_break; + + /* "View.MemoryView":389 + * if self.lock != NULL: + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: # <<<<<<<<<<<<<< + * __pyx_memoryview_thread_locks_used -= 1 + * if i != __pyx_memoryview_thread_locks_used: +*/ + } + } + /*else*/ { + + /* "View.MemoryView":396 + * break + * else: + * PyThread_free_lock(self.lock) # <<<<<<<<<<<<<< + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: +*/ + PyThread_free_lock(__pyx_v_self->lock); + } + __pyx_L6_break:; + + /* "View.MemoryView":387 + * cdef int i + * global __pyx_memoryview_thread_locks_used + * if self.lock != NULL: # <<<<<<<<<<<<<< + * for i in range(0 if __PYX_GET_CYTHON_COMPILING_IN_CPYTHON_FREETHREADING() else __pyx_memoryview_thread_locks_used): + * if __pyx_memoryview_thread_locks[i] is self.lock: +*/ + } + + /* "View.MemoryView":377 + * self.typeinfo = NULL + * + * def __dealloc__(memoryview self): # <<<<<<<<<<<<<< + * if self.obj is not None: + * PyBuffer_Release(&self.view) +*/ + + /* function exit code */ +} + +/* "View.MemoryView":398 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf +*/ + +static char *__pyx_memoryview_get_item_pointer(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + Py_ssize_t __pyx_v_dim; + char *__pyx_v_itemp; + PyObject *__pyx_v_idx = NULL; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t __pyx_t_3; + PyObject *(*__pyx_t_4)(PyObject *); + PyObject *__pyx_t_5 = NULL; + Py_ssize_t __pyx_t_6; + char *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_item_pointer", 0); + + /* "View.MemoryView":400 + * cdef char *get_item_pointer(memoryview self, object index) except NULL: + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf # <<<<<<<<<<<<<< + * + * for dim, idx in enumerate(index): +*/ + __pyx_v_itemp = ((char *)__pyx_v_self->view.buf); + + /* "View.MemoryView":402 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * +*/ + __pyx_t_1 = 0; + if (likely(PyList_CheckExact(__pyx_v_index)) || PyTuple_CheckExact(__pyx_v_index)) { + __pyx_t_2 = __pyx_v_index; __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = 0; + __pyx_t_4 = NULL; + } else { + __pyx_t_3 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_index); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 402, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 402, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_4)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 402, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + __pyx_t_5 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_3, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_3; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 402, __pyx_L1_error) + #endif + if (__pyx_t_3 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_5 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_3)); + #else + __pyx_t_5 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_3); + #endif + ++__pyx_t_3; + } + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 402, __pyx_L1_error) + } else { + __pyx_t_5 = __pyx_t_4(__pyx_t_2); + if (unlikely(!__pyx_t_5)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(1, 402, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_v_idx, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_v_dim = __pyx_t_1; + __pyx_t_1 = (__pyx_t_1 + 1); + + /* "View.MemoryView":403 + * + * for dim, idx in enumerate(index): + * itemp = pybuffer_index(&self.view, itemp, idx, dim) # <<<<<<<<<<<<<< + * + * return itemp +*/ + __pyx_t_6 = __Pyx_PyIndex_AsSsize_t(__pyx_v_idx); if (unlikely((__pyx_t_6 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 403, __pyx_L1_error) + __pyx_t_7 = __pyx_pybuffer_index((&__pyx_v_self->view), __pyx_v_itemp, __pyx_t_6, __pyx_v_dim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 403, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_7; + + /* "View.MemoryView":402 + * cdef char *itemp = self.view.buf + * + * for dim, idx in enumerate(index): # <<<<<<<<<<<<<< + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * +*/ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":405 + * itemp = pybuffer_index(&self.view, itemp, idx, dim) + * + * return itemp # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = __pyx_v_itemp; + goto __pyx_L0; + + /* "View.MemoryView":398 + * PyThread_free_lock(self.lock) + * + * cdef char *get_item_pointer(memoryview self, object index) except NULL: # <<<<<<<<<<<<<< + * cdef Py_ssize_t dim + * cdef char *itemp = self.view.buf +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.get_item_pointer", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_idx); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":408 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index); /*proto*/ +static PyObject *__pyx_memoryview___getitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_4__getitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_indices = NULL; + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + char *__pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__getitem__", 0); + + /* "View.MemoryView":409 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * +*/ + __pyx_t_1 = (__pyx_v_index == __pyx_builtin_Ellipsis); + if (__pyx_t_1) { + + /* "View.MemoryView":410 + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: + * return self # <<<<<<<<<<<<<< + * + * have_slices, indices = _unellipsify(index, self.view.ndim) +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_self); + __pyx_r = ((PyObject *)__pyx_v_self); + goto __pyx_L0; + + /* "View.MemoryView":409 + * + * def __getitem__(memoryview self, object index): + * if index is Ellipsis: # <<<<<<<<<<<<<< + * return self + * +*/ + } + + /* "View.MemoryView":412 + * return self + * + * have_slices, indices = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * cdef char *itemp +*/ + __pyx_t_2 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (likely(__pyx_t_2 != Py_None)) { + PyObject* sequence = __pyx_t_2; + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 412, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_4); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #endif + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 412, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_3; + __pyx_t_3 = 0; + __pyx_v_indices = __pyx_t_4; + __pyx_t_4 = 0; + + /* "View.MemoryView":415 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: +*/ + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 415, __pyx_L1_error) + if (__pyx_t_1) { + + /* "View.MemoryView":416 + * cdef char *itemp + * if have_slices: + * return memview_slice(self, indices) # <<<<<<<<<<<<<< + * else: + * itemp = self.get_item_pointer(indices) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = ((PyObject *)__pyx_memview_slice(__pyx_v_self, __pyx_v_indices)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":415 + * + * cdef char *itemp + * if have_slices: # <<<<<<<<<<<<<< + * return memview_slice(self, indices) + * else: +*/ + } + + /* "View.MemoryView":418 + * return memview_slice(self, indices) + * else: + * itemp = self.get_item_pointer(indices) # <<<<<<<<<<<<<< + * return self.convert_item_to_object(itemp) + * +*/ + /*else*/ { + __pyx_t_5 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_indices); if (unlikely(__pyx_t_5 == ((void *)NULL))) __PYX_ERR(1, 418, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_5; + + /* "View.MemoryView":419 + * else: + * itemp = self.get_item_pointer(indices) + * return self.convert_item_to_object(itemp) # <<<<<<<<<<<<<< + * + * def __setitem__(memoryview self, object index, object value): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->convert_item_to_object(__pyx_v_self, __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":408 + * + * + * def __getitem__(memoryview self, object index): # <<<<<<<<<<<<<< + * if index is Ellipsis: + * return self +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview.__getitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_indices); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":421 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError, "Cannot assign to read-only memoryview" +*/ + +/* Python wrapper */ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value); /*proto*/ +static int __pyx_memoryview___setitem__(PyObject *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setitem__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((PyObject *)__pyx_v_index), ((PyObject *)__pyx_v_value)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_6__setitem__(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + PyObject *__pyx_v_have_slices = NULL; + PyObject *__pyx_v_obj = NULL; + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setitem__", 0); + __Pyx_INCREF(__pyx_v_index); + + /* "View.MemoryView":422 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError, "Cannot assign to read-only memoryview" + * +*/ + if (unlikely(__pyx_v_self->view.readonly)) { + + /* "View.MemoryView":423 + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: + * raise TypeError, "Cannot assign to read-only memoryview" # <<<<<<<<<<<<<< + * + * have_slices, index = _unellipsify(index, self.view.ndim) +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_Cannot_assign_to_read_only_memor, 0, 0); + __PYX_ERR(1, 423, __pyx_L1_error) + + /* "View.MemoryView":422 + * + * def __setitem__(memoryview self, object index, object value): + * if self.view.readonly: # <<<<<<<<<<<<<< + * raise TypeError, "Cannot assign to read-only memoryview" + * +*/ + } + + /* "View.MemoryView":425 + * raise TypeError, "Cannot assign to read-only memoryview" + * + * have_slices, index = _unellipsify(index, self.view.ndim) # <<<<<<<<<<<<<< + * + * if have_slices: +*/ + __pyx_t_1 = _unellipsify(__pyx_v_index, __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (likely(__pyx_t_1 != Py_None)) { + PyObject* sequence = __pyx_t_1; + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(sequence); + if (unlikely(size != 2)) { + if (size > 2) __Pyx_RaiseTooManyValuesError(2); + else if (size >= 0) __Pyx_RaiseNeedMoreValuesError(size); + __PYX_ERR(1, 425, __pyx_L1_error) + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_2 = PyTuple_GET_ITEM(sequence, 0); + __Pyx_INCREF(__pyx_t_2); + __pyx_t_3 = PyTuple_GET_ITEM(sequence, 1); + __Pyx_INCREF(__pyx_t_3); + #else + __pyx_t_2 = __Pyx_PySequence_ITEM(sequence, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PySequence_ITEM(sequence, 1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 425, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + #endif + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } else { + __Pyx_RaiseNoneNotIterableError(); __PYX_ERR(1, 425, __pyx_L1_error) + } + __pyx_v_have_slices = __pyx_t_2; + __pyx_t_2 = 0; + __Pyx_DECREF_SET(__pyx_v_index, __pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":427 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj is not None: +*/ + __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_have_slices); if (unlikely((__pyx_t_4 < 0))) __PYX_ERR(1, 427, __pyx_L1_error) + if (__pyx_t_4) { + + /* "View.MemoryView":428 + * + * if have_slices: + * obj = self.is_slice(value) # <<<<<<<<<<<<<< + * if obj is not None: + * self.setitem_slice_assignment(self[index], obj) +*/ + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->is_slice(__pyx_v_self, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 428, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_obj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":429 + * if have_slices: + * obj = self.is_slice(value) + * if obj is not None: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: +*/ + __pyx_t_4 = (__pyx_v_obj != Py_None); + if (__pyx_t_4) { + + /* "View.MemoryView":430 + * obj = self.is_slice(value) + * if obj is not None: + * self.setitem_slice_assignment(self[index], obj) # <<<<<<<<<<<<<< + * else: + * self.setitem_slice_assign_scalar(self[index], value) +*/ + __pyx_t_1 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assignment(__pyx_v_self, __pyx_t_1, __pyx_v_obj); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "View.MemoryView":429 + * if have_slices: + * obj = self.is_slice(value) + * if obj is not None: # <<<<<<<<<<<<<< + * self.setitem_slice_assignment(self[index], obj) + * else: +*/ + goto __pyx_L5; + } + + /* "View.MemoryView":432 + * self.setitem_slice_assignment(self[index], obj) + * else: + * self.setitem_slice_assign_scalar(self[index], value) # <<<<<<<<<<<<<< + * else: + * self.setitem_indexed(index, value) +*/ + /*else*/ { + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_self), __pyx_v_index); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 432, __pyx_L1_error) + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_slice_assign_scalar(__pyx_v_self, ((struct __pyx_memoryview_obj *)__pyx_t_3), __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 432, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L5:; + + /* "View.MemoryView":427 + * have_slices, index = _unellipsify(index, self.view.ndim) + * + * if have_slices: # <<<<<<<<<<<<<< + * obj = self.is_slice(value) + * if obj is not None: +*/ + goto __pyx_L4; + } + + /* "View.MemoryView":434 + * self.setitem_slice_assign_scalar(self[index], value) + * else: + * self.setitem_indexed(index, value) # <<<<<<<<<<<<<< + * + * cdef is_slice(self, obj): +*/ + /*else*/ { + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->setitem_indexed(__pyx_v_self, __pyx_v_index, __pyx_v_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 434, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L4:; + + /* "View.MemoryView":421 + * return self.convert_item_to_object(itemp) + * + * def __setitem__(memoryview self, object index, object value): # <<<<<<<<<<<<<< + * if self.view.readonly: + * raise TypeError, "Cannot assign to read-only memoryview" +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__setitem__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_have_slices); + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":436 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: +*/ + +static PyObject *__pyx_memoryview_is_slice(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_obj) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_slice", 0); + __Pyx_INCREF(__pyx_v_obj); + + /* "View.MemoryView":437 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, +*/ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_obj, __pyx_mstate_global->__pyx_memoryview_type); + __pyx_t_2 = (!__pyx_t_1); + if (__pyx_t_2) { + + /* "View.MemoryView":438 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_4, &__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_5); + /*try:*/ { + + /* "View.MemoryView":439 + * if not isinstance(obj, memoryview): + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, # <<<<<<<<<<<<<< + * self.dtype_is_object) + * except TypeError: +*/ + __pyx_t_7 = NULL; + __pyx_t_8 = __Pyx_PyLong_From_int(((__pyx_v_self->flags & (~PyBUF_WRITABLE)) | PyBUF_ANY_CONTIGUOUS)); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 439, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "View.MemoryView":440 + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) # <<<<<<<<<<<<<< + * except TypeError: + * return None +*/ + __pyx_t_9 = __Pyx_PyBool_FromLong(__pyx_v_self->dtype_is_object); if (unlikely(!__pyx_t_9)) __PYX_ERR(1, 440, __pyx_L4_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_v_obj, __pyx_t_8, __pyx_t_9}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_memoryview_type, __pyx_callargs+__pyx_t_10, (4-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 439, __pyx_L4_error) + __Pyx_GOTREF((PyObject *)__pyx_t_6); + } + __Pyx_DECREF_SET(__pyx_v_obj, ((PyObject *)__pyx_t_6)); + __pyx_t_6 = 0; + + /* "View.MemoryView":438 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) +*/ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + goto __pyx_L9_try_end; + __pyx_L4_error:; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":441 + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) + * except TypeError: # <<<<<<<<<<<<<< + * return None + * +*/ + __pyx_t_11 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_TypeError)))); + if (__pyx_t_11) { + __Pyx_ErrRestore(0,0,0); + + /* "View.MemoryView":442 + * self.dtype_is_object) + * except TypeError: + * return None # <<<<<<<<<<<<<< + * + * return obj +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L7_except_return; + } + goto __pyx_L6_except_error; + + /* "View.MemoryView":438 + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): + * try: # <<<<<<<<<<<<<< + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, + * self.dtype_is_object) +*/ + __pyx_L6_except_error:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L1_error; + __pyx_L7_except_return:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_XGIVEREF(__pyx_t_5); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_4, __pyx_t_5); + goto __pyx_L0; + __pyx_L9_try_end:; + } + + /* "View.MemoryView":437 + * + * cdef is_slice(self, obj): + * if not isinstance(obj, memoryview): # <<<<<<<<<<<<<< + * try: + * obj = memoryview(obj, self.flags & ~PyBUF_WRITABLE | PyBUF_ANY_CONTIGUOUS, +*/ + } + + /* "View.MemoryView":444 + * return None + * + * return obj # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assignment(self, dst, src): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_obj); + __pyx_r = __pyx_v_obj; + goto __pyx_L0; + + /* "View.MemoryView":436 + * self.setitem_indexed(index, value) + * + * cdef is_slice(self, obj): # <<<<<<<<<<<<<< + * if not isinstance(obj, memoryview): + * try: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_obj); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":446 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice +*/ + +static PyObject *__pyx_memoryview_setitem_slice_assignment(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_dst, PyObject *__pyx_v_src) { + __Pyx_memviewslice __pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_src_slice; + __Pyx_memviewslice __pyx_v_msrc; + __Pyx_memviewslice __pyx_v_mdst; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assignment", 0); + + /* "View.MemoryView":449 + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice + * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] + * +*/ + if (!(likely(((__pyx_v_src) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_src, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 449, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_src), (&__pyx_v_src_slice)); if (unlikely(__pyx_t_1 == ((void *)NULL))) __PYX_ERR(1, 449, __pyx_L1_error) + __pyx_v_msrc = (__pyx_t_1[0]); + + /* "View.MemoryView":450 + * cdef __Pyx_memviewslice src_slice + * cdef __Pyx_memviewslice msrc = get_slice_from_memview(src, &src_slice)[0] + * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] # <<<<<<<<<<<<<< + * + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) +*/ + if (!(likely(((__pyx_v_dst) == Py_None) || likely(__Pyx_TypeTest(__pyx_v_dst, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 450, __pyx_L1_error) + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(((struct __pyx_memoryview_obj *)__pyx_v_dst), (&__pyx_v_dst_slice)); if (unlikely(__pyx_t_1 == ((void *)NULL))) __PYX_ERR(1, 450, __pyx_L1_error) + __pyx_v_mdst = (__pyx_t_1[0]); + + /* "View.MemoryView":452 + * cdef __Pyx_memviewslice mdst = get_slice_from_memview(dst, &dst_slice)[0] + * + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) # <<<<<<<<<<<<<< + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): +*/ + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_src, __pyx_mstate_global->__pyx_n_u_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_3 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 452, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_v_dst, __pyx_mstate_global->__pyx_n_u_ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 452, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyLong_As_int(__pyx_t_2); if (unlikely((__pyx_t_4 == (int)-1) && PyErr_Occurred())) __PYX_ERR(1, 452, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_5 = __pyx_memoryview_copy_contents(__pyx_v_msrc, __pyx_v_mdst, __pyx_t_3, __pyx_t_4, __pyx_v_self->dtype_is_object); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 452, __pyx_L1_error) + + /* "View.MemoryView":446 + * return obj + * + * cdef setitem_slice_assignment(self, dst, src): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice dst_slice + * cdef __Pyx_memviewslice src_slice +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assignment", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":454 + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL +*/ + +static PyObject *__pyx_memoryview_setitem_slice_assign_scalar(struct __pyx_memoryview_obj *__pyx_v_self, struct __pyx_memoryview_obj *__pyx_v_dst, PyObject *__pyx_v_value) { + int __pyx_v_array[128]; + void *__pyx_v_tmp; + void *__pyx_v_item; + __Pyx_memviewslice *__pyx_v_dst_slice; + __Pyx_memviewslice __pyx_v_tmp_slice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + int __pyx_t_5; + char const *__pyx_t_6; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + PyObject *__pyx_t_12 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_slice_assign_scalar", 0); + + /* "View.MemoryView":456 + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): + * cdef int array[128] + * cdef void *tmp = NULL # <<<<<<<<<<<<<< + * cdef void *item + * +*/ + __pyx_v_tmp = NULL; + + /* "View.MemoryView":461 + * cdef __Pyx_memviewslice *dst_slice + * cdef __Pyx_memviewslice tmp_slice + * dst_slice = get_slice_from_memview(dst, &tmp_slice) # <<<<<<<<<<<<<< + * + * if self.view.itemsize > sizeof(array): +*/ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_dst, (&__pyx_v_tmp_slice)); if (unlikely(__pyx_t_1 == ((void *)NULL))) __PYX_ERR(1, 461, __pyx_L1_error) + __pyx_v_dst_slice = __pyx_t_1; + + /* "View.MemoryView":463 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: +*/ + __pyx_t_2 = (((size_t)__pyx_v_self->view.itemsize) > (sizeof(__pyx_v_array))); + if (__pyx_t_2) { + + /* "View.MemoryView":464 + * + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) # <<<<<<<<<<<<<< + * if tmp == NULL: + * raise MemoryError +*/ + __pyx_v_tmp = PyMem_Malloc(__pyx_v_self->view.itemsize); + + /* "View.MemoryView":465 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp +*/ + __pyx_t_2 = (__pyx_v_tmp == NULL); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":466 + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: + * raise MemoryError # <<<<<<<<<<<<<< + * item = tmp + * else: +*/ + PyErr_NoMemory(); __PYX_ERR(1, 466, __pyx_L1_error) + + /* "View.MemoryView":465 + * if self.view.itemsize > sizeof(array): + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: # <<<<<<<<<<<<<< + * raise MemoryError + * item = tmp +*/ + } + + /* "View.MemoryView":467 + * if tmp == NULL: + * raise MemoryError + * item = tmp # <<<<<<<<<<<<<< + * else: + * item = array +*/ + __pyx_v_item = __pyx_v_tmp; + + /* "View.MemoryView":463 + * dst_slice = get_slice_from_memview(dst, &tmp_slice) + * + * if self.view.itemsize > sizeof(array): # <<<<<<<<<<<<<< + * tmp = PyMem_Malloc(self.view.itemsize) + * if tmp == NULL: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":469 + * item = tmp + * else: + * item = array # <<<<<<<<<<<<<< + * + * try: +*/ + /*else*/ { + __pyx_v_item = ((void *)__pyx_v_array); + } + __pyx_L3:; + + /* "View.MemoryView":471 + * item = array + * + * try: # <<<<<<<<<<<<<< + * if self.dtype_is_object: + * ( item)[0] = value +*/ + /*try:*/ { + + /* "View.MemoryView":472 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: +*/ + if (__pyx_v_self->dtype_is_object) { + + /* "View.MemoryView":473 + * try: + * if self.dtype_is_object: + * ( item)[0] = value # <<<<<<<<<<<<<< + * else: + * self.assign_item_from_object( item, value) +*/ + (((PyObject **)__pyx_v_item)[0]) = ((PyObject *)__pyx_v_value); + + /* "View.MemoryView":472 + * + * try: + * if self.dtype_is_object: # <<<<<<<<<<<<<< + * ( item)[0] = value + * else: +*/ + goto __pyx_L8; + } + + /* "View.MemoryView":475 + * ( item)[0] = value + * else: + * self.assign_item_from_object( item, value) # <<<<<<<<<<<<<< + * + * +*/ + /*else*/ { + __pyx_t_3 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, ((char *)__pyx_v_item), __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 475, __pyx_L6_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L8:; + + /* "View.MemoryView":479 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, +*/ + __pyx_t_2 = (__pyx_v_self->view.suboffsets != NULL); + if (__pyx_t_2) { + + /* "View.MemoryView":480 + * + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) # <<<<<<<<<<<<<< + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, + * item, self.dtype_is_object) +*/ + __pyx_t_4 = assert_direct_dimensions(__pyx_v_self->view.suboffsets, __pyx_v_self->view.ndim); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(1, 480, __pyx_L6_error) + + /* "View.MemoryView":479 + * + * + * if self.view.suboffsets != NULL: # <<<<<<<<<<<<<< + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, +*/ + } + + /* "View.MemoryView":481 + * if self.view.suboffsets != NULL: + * assert_direct_dimensions(self.view.suboffsets, self.view.ndim) + * slice_assign_scalar(dst_slice, dst.view.ndim, self.view.itemsize, # <<<<<<<<<<<<<< + * item, self.dtype_is_object) + * finally: +*/ + __pyx_memoryview_slice_assign_scalar(__pyx_v_dst_slice, __pyx_v_dst->view.ndim, __pyx_v_self->view.itemsize, __pyx_v_item, __pyx_v_self->dtype_is_object); + } + + /* "View.MemoryView":484 + * item, self.dtype_is_object) + * finally: + * PyMem_Free(tmp) # <<<<<<<<<<<<<< + * + * cdef setitem_indexed(self, index, value): +*/ + /*finally:*/ { + /*normal exit:*/{ + PyMem_Free(__pyx_v_tmp); + goto __pyx_L7; + } + __pyx_L6_error:; + /*exception exit:*/{ + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_ExceptionSwap(&__pyx_t_10, &__pyx_t_11, &__pyx_t_12); + if ( unlikely(__Pyx_GetException(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9) < 0)) __Pyx_ErrFetch(&__pyx_t_7, &__pyx_t_8, &__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_7); + __Pyx_XGOTREF(__pyx_t_8); + __Pyx_XGOTREF(__pyx_t_9); + __Pyx_XGOTREF(__pyx_t_10); + __Pyx_XGOTREF(__pyx_t_11); + __Pyx_XGOTREF(__pyx_t_12); + __pyx_t_4 = __pyx_lineno; __pyx_t_5 = __pyx_clineno; __pyx_t_6 = __pyx_filename; + { + PyMem_Free(__pyx_v_tmp); + } + __Pyx_XGIVEREF(__pyx_t_10); + __Pyx_XGIVEREF(__pyx_t_11); + __Pyx_XGIVEREF(__pyx_t_12); + __Pyx_ExceptionReset(__pyx_t_10, __pyx_t_11, __pyx_t_12); + __Pyx_XGIVEREF(__pyx_t_7); + __Pyx_XGIVEREF(__pyx_t_8); + __Pyx_XGIVEREF(__pyx_t_9); + __Pyx_ErrRestore(__pyx_t_7, __pyx_t_8, __pyx_t_9); + __pyx_t_7 = 0; __pyx_t_8 = 0; __pyx_t_9 = 0; __pyx_t_10 = 0; __pyx_t_11 = 0; __pyx_t_12 = 0; + __pyx_lineno = __pyx_t_4; __pyx_clineno = __pyx_t_5; __pyx_filename = __pyx_t_6; + goto __pyx_L1_error; + } + __pyx_L7:; + } + + /* "View.MemoryView":454 + * memoryview_copy_contents(msrc, mdst, src.ndim, dst.ndim, self.dtype_is_object) + * + * cdef setitem_slice_assign_scalar(self, memoryview dst, value): # <<<<<<<<<<<<<< + * cdef int array[128] + * cdef void *tmp = NULL +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_slice_assign_scalar", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":486 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) +*/ + +static PyObject *__pyx_memoryview_setitem_indexed(struct __pyx_memoryview_obj *__pyx_v_self, PyObject *__pyx_v_index, PyObject *__pyx_v_value) { + char *__pyx_v_itemp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + char *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("setitem_indexed", 0); + + /* "View.MemoryView":487 + * + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) # <<<<<<<<<<<<<< + * self.assign_item_from_object(itemp, value) + * +*/ + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->get_item_pointer(__pyx_v_self, __pyx_v_index); if (unlikely(__pyx_t_1 == ((void *)NULL))) __PYX_ERR(1, 487, __pyx_L1_error) + __pyx_v_itemp = __pyx_t_1; + + /* "View.MemoryView":488 + * cdef setitem_indexed(self, index, value): + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): +*/ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->assign_item_from_object(__pyx_v_self, __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 488, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":486 + * PyMem_Free(tmp) + * + * cdef setitem_indexed(self, index, value): # <<<<<<<<<<<<<< + * cdef char *itemp = self.get_item_pointer(index) + * self.assign_item_from_object(itemp, value) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.setitem_indexed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":490 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" +*/ + +static PyObject *__pyx_memoryview_convert_item_to_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_v_struct = NULL; + PyObject *__pyx_v_bytesitem = 0; + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + Py_ssize_t __pyx_t_8; + int __pyx_t_9; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":493 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef bytes bytesitem + * +*/ + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_struct, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 493, __pyx_L1_error) + __pyx_t_1 = __pyx_t_2; + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":496 + * cdef bytes bytesitem + * + * bytesitem = itemp[:self.view.itemsize] # <<<<<<<<<<<<<< + * try: + * result = struct.unpack(self.view.format, bytesitem) +*/ + __pyx_t_1 = __Pyx_PyBytes_FromStringAndSize(__pyx_v_itemp + 0, __pyx_v_self->view.itemsize - 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_bytesitem = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":497 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_2, &__pyx_t_3, &__pyx_t_4); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_4); + /*try:*/ { + + /* "View.MemoryView":498 + * bytesitem = itemp[:self.view.itemsize] + * try: + * result = struct.unpack(self.view.format, bytesitem) # <<<<<<<<<<<<<< + * except struct.error: + * raise ValueError, "Unable to convert item to object" +*/ + __pyx_t_5 = __pyx_v_struct; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 498, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_6, __pyx_v_bytesitem}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_unpack, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 498, __pyx_L3_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_result = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":497 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: +*/ + } + + /* "View.MemoryView":502 + * raise ValueError, "Unable to convert item to object" + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result +*/ + /*else:*/ { + __pyx_t_8 = __Pyx_ssize_strlen(__pyx_v_self->view.format); if (unlikely(__pyx_t_8 == ((Py_ssize_t)-1))) __PYX_ERR(1, 502, __pyx_L5_except_error) + __pyx_t_9 = (__pyx_t_8 == 1); + if (__pyx_t_9) { + + /* "View.MemoryView":503 + * else: + * if len(self.view.format) == 1: + * return result[0] # <<<<<<<<<<<<<< + * return result + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_GetItemInt(__pyx_v_result, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 503, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L6_except_return; + + /* "View.MemoryView":502 + * raise ValueError, "Unable to convert item to object" + * else: + * if len(self.view.format) == 1: # <<<<<<<<<<<<<< + * return result[0] + * return result +*/ + } + + /* "View.MemoryView":504 + * if len(self.view.format) == 1: + * return result[0] + * return result # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_result); + __pyx_r = __pyx_v_result; + goto __pyx_L6_except_return; + } + __pyx_L3_error:; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "View.MemoryView":499 + * try: + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: # <<<<<<<<<<<<<< + * raise ValueError, "Unable to convert item to object" + * else: +*/ + __Pyx_ErrFetch(&__pyx_t_1, &__pyx_t_6, &__pyx_t_5); + __pyx_t_10 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_mstate_global->__pyx_n_u_error); if (unlikely(!__pyx_t_10)) __PYX_ERR(1, 499, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_10); + __pyx_t_11 = __Pyx_PyErr_GivenExceptionMatches(__pyx_t_1, __pyx_t_10); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_ErrRestore(__pyx_t_1, __pyx_t_6, __pyx_t_5); + __pyx_t_1 = 0; __pyx_t_6 = 0; __pyx_t_5 = 0; + if (__pyx_t_11) { + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_1) < 0) __PYX_ERR(1, 499, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_1); + + /* "View.MemoryView":500 + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: + * raise ValueError, "Unable to convert item to object" # <<<<<<<<<<<<<< + * else: + * if len(self.view.format) == 1: +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Unable_to_convert_item_to_object, 0, 0); + __PYX_ERR(1, 500, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + + /* "View.MemoryView":497 + * + * bytesitem = itemp[:self.view.itemsize] + * try: # <<<<<<<<<<<<<< + * result = struct.unpack(self.view.format, bytesitem) + * except struct.error: +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L1_error; + __pyx_L6_except_return:; + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_4); + __Pyx_ExceptionReset(__pyx_t_2, __pyx_t_3, __pyx_t_4); + goto __pyx_L0; + } + + /* "View.MemoryView":490 + * self.assign_item_from_object(itemp, value) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_AddTraceback("View.MemoryView.memoryview.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesitem); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":506 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" +*/ + +static PyObject *__pyx_memoryview_assign_item_from_object(struct __pyx_memoryview_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_v_struct = NULL; + char __pyx_v_c; + PyObject *__pyx_v_bytesvalue = 0; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_t_3; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + Py_ssize_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + char *__pyx_t_10; + char *__pyx_t_11; + Py_ssize_t __pyx_t_12; + char *__pyx_t_13; + char *__pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":509 + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" + * import struct # <<<<<<<<<<<<<< + * cdef char c + * cdef bytes bytesvalue +*/ + __pyx_t_2 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_struct, 0, 0, NULL, 0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 509, __pyx_L1_error) + __pyx_t_1 = __pyx_t_2; + __Pyx_GOTREF(__pyx_t_1); + __pyx_v_struct = __pyx_t_1; + __pyx_t_1 = 0; + + /* "View.MemoryView":514 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: +*/ + __pyx_t_3 = PyTuple_Check(__pyx_v_value); + if (__pyx_t_3) { + + /* "View.MemoryView":515 + * + * if isinstance(value, tuple): + * bytesvalue = struct.pack(self.view.format, *value) # <<<<<<<<<<<<<< + * else: + * bytesvalue = struct.pack(self.view.format, value) +*/ + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_struct, __pyx_mstate_global->__pyx_n_u_pack); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyTuple_New(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4) != (0)) __PYX_ERR(1, 515, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PySequence_Tuple(__pyx_v_value); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyNumber_Add(__pyx_t_5, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_t_6, NULL); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_4))) __PYX_ERR(1, 515, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":514 + * cdef Py_ssize_t i + * + * if isinstance(value, tuple): # <<<<<<<<<<<<<< + * bytesvalue = struct.pack(self.view.format, *value) + * else: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":517 + * bytesvalue = struct.pack(self.view.format, *value) + * else: + * bytesvalue = struct.pack(self.view.format, value) # <<<<<<<<<<<<<< + * + * for i, c in enumerate(bytesvalue): +*/ + /*else*/ { + __pyx_t_6 = __pyx_v_struct; + __Pyx_INCREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyBytes_FromString(__pyx_v_self->view.format); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 517, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_1, __pyx_v_value}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_pack, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 517, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + if (!(likely(PyBytes_CheckExact(__pyx_t_4))||((__pyx_t_4) == Py_None) || __Pyx_RaiseUnexpectedTypeError("bytes", __pyx_t_4))) __PYX_ERR(1, 517, __pyx_L1_error) + __pyx_v_bytesvalue = ((PyObject*)__pyx_t_4); + __pyx_t_4 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":519 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * +*/ + __pyx_t_8 = 0; + if (unlikely(__pyx_v_bytesvalue == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' is not iterable"); + __PYX_ERR(1, 519, __pyx_L1_error) + } + __Pyx_INCREF(__pyx_v_bytesvalue); + __pyx_t_9 = __pyx_v_bytesvalue; + __pyx_t_11 = __Pyx_PyBytes_AsWritableString(__pyx_t_9); if (unlikely(__pyx_t_11 == ((char *)NULL))) __PYX_ERR(1, 519, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyBytes_GET_SIZE(__pyx_t_9); if (unlikely(__pyx_t_12 == ((Py_ssize_t)-1))) __PYX_ERR(1, 519, __pyx_L1_error) + __pyx_t_13 = (__pyx_t_11 + __pyx_t_12); + for (__pyx_t_14 = __pyx_t_11; __pyx_t_14 < __pyx_t_13; __pyx_t_14++) { + __pyx_t_10 = __pyx_t_14; + __pyx_v_c = (__pyx_t_10[0]); + + /* "View.MemoryView":520 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') +*/ + __pyx_v_i = __pyx_t_8; + + /* "View.MemoryView":519 + * bytesvalue = struct.pack(self.view.format, value) + * + * for i, c in enumerate(bytesvalue): # <<<<<<<<<<<<<< + * itemp[i] = c + * +*/ + __pyx_t_8 = (__pyx_t_8 + 1); + + /* "View.MemoryView":520 + * + * for i, c in enumerate(bytesvalue): + * itemp[i] = c # <<<<<<<<<<<<<< + * + * @cname('getbuffer') +*/ + (__pyx_v_itemp[__pyx_v_i]) = __pyx_v_c; + } + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "View.MemoryView":506 + * return result + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * """Only used if instantiated manually by the user, or if Cython doesn't + * know how to convert the type""" +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("View.MemoryView.memoryview.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_struct); + __Pyx_XDECREF(__pyx_v_bytesvalue); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":522 + * itemp[i] = c + * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: +*/ + +/* Python wrapper */ +CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags); /*proto*/ +CYTHON_UNUSED static int __pyx_memoryview_getbuffer(PyObject *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + int __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__getbuffer__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(((struct __pyx_memoryview_obj *)__pyx_v_self), ((Py_buffer *)__pyx_v_info), ((int)__pyx_v_flags)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static int __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_8__getbuffer__(struct __pyx_memoryview_obj *__pyx_v_self, Py_buffer *__pyx_v_info, int __pyx_v_flags) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t *__pyx_t_3; + char *__pyx_t_4; + void *__pyx_t_5; + int __pyx_t_6; + Py_ssize_t __pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + if (unlikely(__pyx_v_info == NULL)) { + PyErr_SetString(PyExc_BufferError, "PyObject_GetBuffer: view==NULL argument is obsolete"); + return -1; + } + __Pyx_RefNannySetupContext("__getbuffer__", 0); + __pyx_v_info->obj = Py_None; __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(__pyx_v_info->obj); + + /* "View.MemoryView":524 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError, "Cannot create writable memory view from read-only memoryview" + * +*/ + __pyx_t_2 = ((__pyx_v_flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L4_bool_binop_done; + } + __pyx_t_1 = __pyx_v_self->view.readonly; + __pyx_L4_bool_binop_done:; + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":525 + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: + * raise ValueError, "Cannot create writable memory view from read-only memoryview" # <<<<<<<<<<<<<< + * + * if flags & PyBUF_ND: +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Cannot_create_writable_memory_vi, 0, 0); + __PYX_ERR(1, 525, __pyx_L1_error) + + /* "View.MemoryView":524 + * @cname('getbuffer') + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: # <<<<<<<<<<<<<< + * raise ValueError, "Cannot create writable memory view from read-only memoryview" + * +*/ + } + + /* "View.MemoryView":527 + * raise ValueError, "Cannot create writable memory view from read-only memoryview" + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_ND) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":528 + * + * if flags & PyBUF_ND: + * info.shape = self.view.shape # <<<<<<<<<<<<<< + * else: + * info.shape = NULL +*/ + __pyx_t_3 = __pyx_v_self->view.shape; + __pyx_v_info->shape = __pyx_t_3; + + /* "View.MemoryView":527 + * raise ValueError, "Cannot create writable memory view from read-only memoryview" + * + * if flags & PyBUF_ND: # <<<<<<<<<<<<<< + * info.shape = self.view.shape + * else: +*/ + goto __pyx_L6; + } + + /* "View.MemoryView":530 + * info.shape = self.view.shape + * else: + * info.shape = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_STRIDES: +*/ + /*else*/ { + __pyx_v_info->shape = NULL; + } + __pyx_L6:; + + /* "View.MemoryView":532 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_STRIDES) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":533 + * + * if flags & PyBUF_STRIDES: + * info.strides = self.view.strides # <<<<<<<<<<<<<< + * else: + * info.strides = NULL +*/ + __pyx_t_3 = __pyx_v_self->view.strides; + __pyx_v_info->strides = __pyx_t_3; + + /* "View.MemoryView":532 + * info.shape = NULL + * + * if flags & PyBUF_STRIDES: # <<<<<<<<<<<<<< + * info.strides = self.view.strides + * else: +*/ + goto __pyx_L7; + } + + /* "View.MemoryView":535 + * info.strides = self.view.strides + * else: + * info.strides = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_INDIRECT: +*/ + /*else*/ { + __pyx_v_info->strides = NULL; + } + __pyx_L7:; + + /* "View.MemoryView":537 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_INDIRECT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":538 + * + * if flags & PyBUF_INDIRECT: + * info.suboffsets = self.view.suboffsets # <<<<<<<<<<<<<< + * else: + * info.suboffsets = NULL +*/ + __pyx_t_3 = __pyx_v_self->view.suboffsets; + __pyx_v_info->suboffsets = __pyx_t_3; + + /* "View.MemoryView":537 + * info.strides = NULL + * + * if flags & PyBUF_INDIRECT: # <<<<<<<<<<<<<< + * info.suboffsets = self.view.suboffsets + * else: +*/ + goto __pyx_L8; + } + + /* "View.MemoryView":540 + * info.suboffsets = self.view.suboffsets + * else: + * info.suboffsets = NULL # <<<<<<<<<<<<<< + * + * if flags & PyBUF_FORMAT: +*/ + /*else*/ { + __pyx_v_info->suboffsets = NULL; + } + __pyx_L8:; + + /* "View.MemoryView":542 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: +*/ + __pyx_t_1 = ((__pyx_v_flags & PyBUF_FORMAT) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":543 + * + * if flags & PyBUF_FORMAT: + * info.format = self.view.format # <<<<<<<<<<<<<< + * else: + * info.format = NULL +*/ + __pyx_t_4 = __pyx_v_self->view.format; + __pyx_v_info->format = __pyx_t_4; + + /* "View.MemoryView":542 + * info.suboffsets = NULL + * + * if flags & PyBUF_FORMAT: # <<<<<<<<<<<<<< + * info.format = self.view.format + * else: +*/ + goto __pyx_L9; + } + + /* "View.MemoryView":545 + * info.format = self.view.format + * else: + * info.format = NULL # <<<<<<<<<<<<<< + * + * info.buf = self.view.buf +*/ + /*else*/ { + __pyx_v_info->format = NULL; + } + __pyx_L9:; + + /* "View.MemoryView":547 + * info.format = NULL + * + * info.buf = self.view.buf # <<<<<<<<<<<<<< + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize +*/ + __pyx_t_5 = __pyx_v_self->view.buf; + __pyx_v_info->buf = __pyx_t_5; + + /* "View.MemoryView":548 + * + * info.buf = self.view.buf + * info.ndim = self.view.ndim # <<<<<<<<<<<<<< + * info.itemsize = self.view.itemsize + * info.len = self.view.len +*/ + __pyx_t_6 = __pyx_v_self->view.ndim; + __pyx_v_info->ndim = __pyx_t_6; + + /* "View.MemoryView":549 + * info.buf = self.view.buf + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize # <<<<<<<<<<<<<< + * info.len = self.view.len + * info.readonly = self.view.readonly +*/ + __pyx_t_7 = __pyx_v_self->view.itemsize; + __pyx_v_info->itemsize = __pyx_t_7; + + /* "View.MemoryView":550 + * info.ndim = self.view.ndim + * info.itemsize = self.view.itemsize + * info.len = self.view.len # <<<<<<<<<<<<<< + * info.readonly = self.view.readonly + * info.obj = self +*/ + __pyx_t_7 = __pyx_v_self->view.len; + __pyx_v_info->len = __pyx_t_7; + + /* "View.MemoryView":551 + * info.itemsize = self.view.itemsize + * info.len = self.view.len + * info.readonly = self.view.readonly # <<<<<<<<<<<<<< + * info.obj = self + * +*/ + __pyx_t_1 = __pyx_v_self->view.readonly; + __pyx_v_info->readonly = __pyx_t_1; + + /* "View.MemoryView":552 + * info.len = self.view.len + * info.readonly = self.view.readonly + * info.obj = self # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_INCREF((PyObject *)__pyx_v_self); + __Pyx_GIVEREF((PyObject *)__pyx_v_self); + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); + __pyx_v_info->obj = ((PyObject *)__pyx_v_self); + + /* "View.MemoryView":522 + * itemp[i] = c + * + * @cname('getbuffer') # <<<<<<<<<<<<<< + * def __getbuffer__(self, Py_buffer *info, int flags): + * if flags & PyBUF_WRITABLE and self.view.readonly: +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__getbuffer__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + if (__pyx_v_info->obj != NULL) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + goto __pyx_L2; + __pyx_L0:; + if (__pyx_v_info->obj == Py_None) { + __Pyx_GOTREF(__pyx_v_info->obj); + __Pyx_DECREF(__pyx_v_info->obj); __pyx_v_info->obj = 0; + } + __pyx_L2:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":555 + * + * + * @property # <<<<<<<<<<<<<< + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_1T___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":557 + * @property + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) # <<<<<<<<<<<<<< + * transpose_memslice(&result.from_slice) + * return result +*/ + __pyx_t_1 = __pyx_memoryview_copy_object(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 557, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_memoryviewslice_type))))) __PYX_ERR(1, 557, __pyx_L1_error) + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":558 + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) # <<<<<<<<<<<<<< + * return result + * +*/ + __pyx_t_2 = __pyx_memslice_transpose((&__pyx_v_result->from_slice)); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 558, __pyx_L1_error) + + /* "View.MemoryView":559 + * cdef _memoryviewslice result = memoryview_copy(self) + * transpose_memslice(&result.from_slice) + * return result # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_result); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":555 + * + * + * @property # <<<<<<<<<<<<<< + * def T(self): + * cdef _memoryviewslice result = memoryview_copy(self) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.T.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":561 + * return result + * + * @property # <<<<<<<<<<<<<< + * def base(self): + * return self._get_base() +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4base___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":563 + * @property + * def base(self): + * return self._get_base() # <<<<<<<<<<<<<< + * + * cdef _get_base(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = ((struct __pyx_vtabstruct_memoryview *)__pyx_v_self->__pyx_vtab)->_get_base(__pyx_v_self); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 563, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":561 + * return result + * + * @property # <<<<<<<<<<<<<< + * def base(self): + * return self._get_base() +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.base.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":565 + * return self._get_base() + * + * cdef _get_base(self): # <<<<<<<<<<<<<< + * return self.obj + * +*/ + +static PyObject *__pyx_memoryview__get_base(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_get_base", 0); + + /* "View.MemoryView":566 + * + * cdef _get_base(self): + * return self.obj # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->obj); + __pyx_r = __pyx_v_self->obj; + goto __pyx_L0; + + /* "View.MemoryView":565 + * return self._get_base() + * + * cdef _get_base(self): # <<<<<<<<<<<<<< + * return self.obj + * +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":568 + * return self.obj + * + * @property # <<<<<<<<<<<<<< + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_5shape___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_7genexpr__pyx_v_length; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":570 + * @property + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_1 = PyList_New(0); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_7genexpr__pyx_v_length = (__pyx_t_2[0]); + __pyx_t_5 = PyLong_FromSsize_t(__pyx_7genexpr__pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_1, (PyObject*)__pyx_t_5))) __PYX_ERR(1, 570, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + } /* exit inner scope */ + __pyx_t_5 = PyList_AsTuple(((PyObject*)__pyx_t_1)); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 570, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "View.MemoryView":568 + * return self.obj + * + * @property # <<<<<<<<<<<<<< + * def shape(self): + * return tuple([length for length in self.view.shape[:self.view.ndim]]) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.shape.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":572 + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def strides(self): + * if self.view.strides == NULL: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_7strides___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_8genexpr1__pyx_v_stride; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":574 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError, "Buffer view does not expose strides" +*/ + __pyx_t_1 = (__pyx_v_self->view.strides == NULL); + if (unlikely(__pyx_t_1)) { + + /* "View.MemoryView":576 + * if self.view.strides == NULL: + * + * raise ValueError, "Buffer view does not expose strides" # <<<<<<<<<<<<<< + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Buffer_view_does_not_expose_stri, 0, 0); + __PYX_ERR(1, 576, __pyx_L1_error) + + /* "View.MemoryView":574 + * @property + * def strides(self): + * if self.view.strides == NULL: # <<<<<<<<<<<<<< + * + * raise ValueError, "Buffer view does not expose strides" +*/ + } + + /* "View.MemoryView":578 + * raise ValueError, "Buffer view does not expose strides" + * + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 578, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.strides + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.strides; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_8genexpr1__pyx_v_stride = (__pyx_t_3[0]); + __pyx_t_6 = PyLong_FromSsize_t(__pyx_8genexpr1__pyx_v_stride); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 578, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 578, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 578, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "View.MemoryView":572 + * return tuple([length for length in self.view.shape[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def strides(self): + * if self.view.strides == NULL: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.strides.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":580 + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def suboffsets(self): + * if self.view.suboffsets == NULL: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_10suboffsets___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_8genexpr2__pyx_v_suboffset; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + Py_ssize_t *__pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":582 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * +*/ + __pyx_t_1 = (__pyx_v_self->view.suboffsets == NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":583 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PySequence_Multiply(__pyx_mstate_global->__pyx_tuple[1], __pyx_v_self->view.ndim); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":582 + * @property + * def suboffsets(self): + * if self.view.suboffsets == NULL: # <<<<<<<<<<<<<< + * return (-1,) * self.view.ndim + * +*/ + } + + /* "View.MemoryView":585 + * return (-1,) * self.view.ndim + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + { /* enter inner scope */ + __pyx_t_2 = PyList_New(0); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = (__pyx_v_self->view.suboffsets + __pyx_v_self->view.ndim); + for (__pyx_t_5 = __pyx_v_self->view.suboffsets; __pyx_t_5 < __pyx_t_4; __pyx_t_5++) { + __pyx_t_3 = __pyx_t_5; + __pyx_8genexpr2__pyx_v_suboffset = (__pyx_t_3[0]); + __pyx_t_6 = PyLong_FromSsize_t(__pyx_8genexpr2__pyx_v_suboffset); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (unlikely(__Pyx_ListComp_Append(__pyx_t_2, (PyObject*)__pyx_t_6))) __PYX_ERR(1, 585, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + } /* exit inner scope */ + __pyx_t_6 = PyList_AsTuple(((PyObject*)__pyx_t_2)); if (unlikely(!__pyx_t_6)) __PYX_ERR(1, 585, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "View.MemoryView":580 + * return tuple([stride for stride in self.view.strides[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def suboffsets(self): + * if self.view.suboffsets == NULL: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_AddTraceback("View.MemoryView.memoryview.suboffsets.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":587 + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def ndim(self): + * return self.view.ndim +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4ndim___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":589 + * @property + * def ndim(self): + * return self.view.ndim # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_self->view.ndim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":587 + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) + * + * @property # <<<<<<<<<<<<<< + * def ndim(self): + * return self.view.ndim +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.ndim.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":591 + * return self.view.ndim + * + * @property # <<<<<<<<<<<<<< + * def itemsize(self): + * return self.view.itemsize +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_8itemsize___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":593 + * @property + * def itemsize(self): + * return self.view.itemsize # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyLong_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":591 + * return self.view.ndim + * + * @property # <<<<<<<<<<<<<< + * def itemsize(self): + * return self.view.itemsize +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview.itemsize.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":595 + * return self.view.itemsize + * + * @property # <<<<<<<<<<<<<< + * def nbytes(self): + * return self.size * self.view.itemsize +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_6nbytes___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":597 + * @property + * def nbytes(self): + * return self.size * self.view.itemsize # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_size); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyLong_FromSsize_t(__pyx_v_self->view.itemsize); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_Multiply(__pyx_t_1, __pyx_t_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":595 + * return self.view.itemsize + * + * @property # <<<<<<<<<<<<<< + * def nbytes(self): + * return self.size * self.view.itemsize +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.nbytes.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":599 + * return self.size * self.view.itemsize + * + * @property # <<<<<<<<<<<<<< + * def size(self): + * if self._size is None: +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__get__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView_10memoryview_4size___get__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_v_result = NULL; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__get__", 0); + + /* "View.MemoryView":601 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * +*/ + __pyx_t_1 = (__pyx_v_self->_size == Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":602 + * def size(self): + * if self._size is None: + * result = 1 # <<<<<<<<<<<<<< + * + * for length in self.view.shape[:self.view.ndim]: +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __pyx_v_result = __pyx_mstate_global->__pyx_int_1; + + /* "View.MemoryView":604 + * result = 1 + * + * for length in self.view.shape[:self.view.ndim]: # <<<<<<<<<<<<<< + * result *= length + * +*/ + __pyx_t_3 = (__pyx_v_self->view.shape + __pyx_v_self->view.ndim); + for (__pyx_t_4 = __pyx_v_self->view.shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_t_5 = PyLong_FromSsize_t((__pyx_t_2[0])); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_5); + __pyx_t_5 = 0; + + /* "View.MemoryView":605 + * + * for length in self.view.shape[:self.view.ndim]: + * result *= length # <<<<<<<<<<<<<< + * + * self._size = result +*/ + __pyx_t_5 = PyNumber_InPlaceMultiply(__pyx_v_result, __pyx_v_length); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 605, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF_SET(__pyx_v_result, __pyx_t_5); + __pyx_t_5 = 0; + } + + /* "View.MemoryView":607 + * result *= length + * + * self._size = result # <<<<<<<<<<<<<< + * + * return self._size +*/ + __Pyx_INCREF(__pyx_v_result); + __Pyx_GIVEREF(__pyx_v_result); + __Pyx_GOTREF(__pyx_v_self->_size); + __Pyx_DECREF(__pyx_v_self->_size); + __pyx_v_self->_size = __pyx_v_result; + + /* "View.MemoryView":601 + * @property + * def size(self): + * if self._size is None: # <<<<<<<<<<<<<< + * result = 1 + * +*/ + } + + /* "View.MemoryView":609 + * self._size = result + * + * return self._size # <<<<<<<<<<<<<< + * + * def __len__(self): +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->_size); + __pyx_r = __pyx_v_self->_size; + goto __pyx_L0; + + /* "View.MemoryView":599 + * return self.size * self.view.itemsize + * + * @property # <<<<<<<<<<<<<< + * def size(self): + * if self._size is None: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.memoryview.size.__get__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":611 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] +*/ + +/* Python wrapper */ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self); /*proto*/ +static Py_ssize_t __pyx_memoryview___len__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + Py_ssize_t __pyx_r; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__len__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static Py_ssize_t __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_10__len__(struct __pyx_memoryview_obj *__pyx_v_self) { + Py_ssize_t __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":612 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * +*/ + __pyx_t_1 = (__pyx_v_self->view.ndim >= 1); + if (__pyx_t_1) { + + /* "View.MemoryView":613 + * def __len__(self): + * if self.view.ndim >= 1: + * return self.view.shape[0] # <<<<<<<<<<<<<< + * + * return 0 +*/ + __pyx_r = (__pyx_v_self->view.shape[0]); + goto __pyx_L0; + + /* "View.MemoryView":612 + * + * def __len__(self): + * if self.view.ndim >= 1: # <<<<<<<<<<<<<< + * return self.view.shape[0] + * +*/ + } + + /* "View.MemoryView":615 + * return self.view.shape[0] + * + * return 0 # <<<<<<<<<<<<<< + * + * def __repr__(self): +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":611 + * return self._size + * + * def __len__(self): # <<<<<<<<<<<<<< + * if self.view.ndim >= 1: + * return self.view.shape[0] +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":617 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___repr__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__repr__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_12__repr__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4[5]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__repr__", 0); + + /* "View.MemoryView":618 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_1), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":619 + * def __repr__(self): + * return "" % (self.base.__class__.__name__, + * id(self)) # <<<<<<<<<<<<<< + * + * def __str__(self): +*/ + __pyx_t_1 = __Pyx_PyObject_CallOneArg(__pyx_builtin_id, ((PyObject *)__pyx_v_self)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = __Pyx_PyObject_Format(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_x); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_MemoryView_of; + __pyx_t_4[1] = __pyx_t_2; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u_at_0x; + __pyx_t_4[3] = __pyx_t_3; + __pyx_t_4[4] = __pyx_mstate_global->__pyx_kp_u__3; + + /* "View.MemoryView":618 + * + * def __repr__(self): + * return "" % (self.base.__class__.__name__, # <<<<<<<<<<<<<< + * id(self)) + * +*/ + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_4, 5, 15 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2) | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3)); + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":617 + * return 0 + * + * def __repr__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__, + * id(self)) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview.__repr__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":621 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self); /*proto*/ +static PyObject *__pyx_memoryview___str__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__str__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_14__str__(struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3[3]; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__str__", 0); + + /* "View.MemoryView":622 + * + * def __str__(self): + * return "" % (self.base.__class__.__name__,) # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(((PyObject *)__pyx_v_self), __pyx_mstate_global->__pyx_n_u_base); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_class); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyObject_FormatSimpleAndDecref(PyObject_Repr(__pyx_t_1), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_3[0] = __pyx_mstate_global->__pyx_kp_u_MemoryView_of; + __pyx_t_3[1] = __pyx_t_2; + __pyx_t_3[2] = __pyx_mstate_global->__pyx_kp_u_object; + __pyx_t_1 = __Pyx_PyUnicode_Join(__pyx_t_3, 3, 15 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 8, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_2)); + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 622, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":621 + * id(self)) + * + * def __str__(self): # <<<<<<<<<<<<<< + * return "" % (self.base.__class__.__name__,) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.__str__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":625 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_is_c_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_c_contig (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("is_c_contig", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("is_c_contig", __pyx_kwds); return NULL;} + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_16is_c_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_c_contig", 0); + + /* "View.MemoryView":628 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * +*/ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((void *)NULL))) __PYX_ERR(1, 628, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":629 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'C', self.view.ndim) # <<<<<<<<<<<<<< + * + * def is_f_contig(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'C', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 629, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":625 + * + * + * def is_c_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_c_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":631 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_is_f_contig(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("is_f_contig (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("is_f_contig", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("is_f_contig", __pyx_kwds); return NULL;} + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_18is_f_contig(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice *__pyx_v_mslice; + __Pyx_memviewslice __pyx_v_tmp; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice *__pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("is_f_contig", 0); + + /* "View.MemoryView":634 + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) # <<<<<<<<<<<<<< + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * +*/ + __pyx_t_1 = __pyx_memoryview_get_slice_from_memoryview(__pyx_v_self, (&__pyx_v_tmp)); if (unlikely(__pyx_t_1 == ((void *)NULL))) __PYX_ERR(1, 634, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":635 + * cdef __Pyx_memviewslice tmp + * mslice = get_slice_from_memview(self, &tmp) + * return slice_is_contig(mslice[0], 'F', self.view.ndim) # <<<<<<<<<<<<<< + * + * def copy(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_memviewslice_is_contig((__pyx_v_mslice[0]), 'F', __pyx_v_self->view.ndim)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":631 + * return slice_is_contig(mslice[0], 'C', self.view.ndim) + * + * def is_f_contig(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *mslice + * cdef __Pyx_memviewslice tmp +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.is_f_contig", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":637 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_copy(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy", __pyx_kwds); return NULL;} + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_20copy(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_mslice; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy", 0); + + /* "View.MemoryView":639 + * def copy(self): + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &mslice) +*/ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_F_CONTIGUOUS)); + + /* "View.MemoryView":641 + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS + * + * slice_copy(self, &mslice) # <<<<<<<<<<<<<< + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, + * self.view.itemsize, +*/ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_mslice)); + + /* "View.MemoryView":642 + * + * slice_copy(self, &mslice) + * mslice = slice_copy_contig(&mslice, "c", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_C_CONTIGUOUS, +*/ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_mslice), ((char const *)"c"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_C_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 642, __pyx_L1_error) + __pyx_v_mslice = __pyx_t_1; + + /* "View.MemoryView":647 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &mslice) # <<<<<<<<<<<<<< + * + * def copy_fortran(self): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_mslice)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 647, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":637 + * return slice_is_contig(mslice[0], 'F', self.view.ndim) + * + * def copy(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice mslice + * cdef int flags = self.flags & ~PyBUF_F_CONTIGUOUS +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":649 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS +*/ + +/* Python wrapper */ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_memoryview_copy_fortran(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("copy_fortran (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("copy_fortran", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("copy_fortran", __pyx_kwds); return NULL;} + __pyx_r = __pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_memoryview___pyx_pf_15View_dot_MemoryView_10memoryview_22copy_fortran(struct __pyx_memoryview_obj *__pyx_v_self) { + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + int __pyx_v_flags; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("copy_fortran", 0); + + /* "View.MemoryView":651 + * def copy_fortran(self): + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS # <<<<<<<<<<<<<< + * + * slice_copy(self, &src) +*/ + __pyx_v_flags = (__pyx_v_self->flags & (~PyBUF_C_CONTIGUOUS)); + + /* "View.MemoryView":653 + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS + * + * slice_copy(self, &src) # <<<<<<<<<<<<<< + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, + * self.view.itemsize, +*/ + __pyx_memoryview_slice_copy(__pyx_v_self, (&__pyx_v_src)); + + /* "View.MemoryView":654 + * + * slice_copy(self, &src) + * dst = slice_copy_contig(&src, "fortran", self.view.ndim, # <<<<<<<<<<<<<< + * self.view.itemsize, + * flags|PyBUF_F_CONTIGUOUS, +*/ + __pyx_t_1 = __pyx_memoryview_copy_new_contig((&__pyx_v_src), ((char const *)"fortran"), __pyx_v_self->view.ndim, __pyx_v_self->view.itemsize, (__pyx_v_flags | PyBUF_F_CONTIGUOUS), __pyx_v_self->dtype_is_object); if (unlikely(PyErr_Occurred())) __PYX_ERR(1, 654, __pyx_L1_error) + __pyx_v_dst = __pyx_t_1; + + /* "View.MemoryView":659 + * self.dtype_is_object) + * + * return memoryview_copy_from_slice(self, &dst) # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_copy_object_from_slice(__pyx_v_self, (&__pyx_v_dst)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":649 + * return memoryview_copy_from_slice(self, &mslice) + * + * def copy_fortran(self): # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice src, dst + * cdef int flags = self.flags & ~PyBUF_C_CONTIGUOUS +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.memoryview.copy_fortran", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf___pyx_memoryview___reduce_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryview_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_memoryview_2__setstate_cython__(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryview_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryview_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.memoryview.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":662 + * + * + * @cname('__pyx_memoryview_new') # <<<<<<<<<<<<<< + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) +*/ + +static PyObject *__pyx_memoryview_new(PyObject *__pyx_v_o, int __pyx_v_flags, int __pyx_v_dtype_is_object, __Pyx_TypeInfo const *__pyx_v_typeinfo) { + struct __pyx_memoryview_obj *__pyx_v_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_cwrapper", 0); + + /* "View.MemoryView":664 + * @cname('__pyx_memoryview_new') + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) # <<<<<<<<<<<<<< + * result.typeinfo = typeinfo + * return result +*/ + __pyx_t_2 = NULL; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_flags); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[4] = {__pyx_t_2, __pyx_v_o, __pyx_t_3, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_memoryview_type, __pyx_callargs+__pyx_t_5, (4-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 664, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_1); + } + __pyx_v_result = ((struct __pyx_memoryview_obj *)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":665 + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo # <<<<<<<<<<<<<< + * return result + * +*/ + __pyx_v_result->typeinfo = __pyx_v_typeinfo; + + /* "View.MemoryView":666 + * cdef memoryview result = memoryview(o, flags, dtype_is_object) + * result.typeinfo = typeinfo + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_check') +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_result); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":662 + * + * + * @cname('__pyx_memoryview_new') # <<<<<<<<<<<<<< + * cdef memoryview_cwrapper(object o, int flags, bint dtype_is_object, const __Pyx_TypeInfo *typeinfo): + * cdef memoryview result = memoryview(o, flags, dtype_is_object) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview_cwrapper", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":668 + * return result + * + * @cname('__pyx_memoryview_check') # <<<<<<<<<<<<<< + * cdef inline bint memoryview_check(object o) noexcept: + * return isinstance(o, memoryview) +*/ + +static CYTHON_INLINE int __pyx_memoryview_check(PyObject *__pyx_v_o) { + int __pyx_r; + int __pyx_t_1; + + /* "View.MemoryView":670 + * @cname('__pyx_memoryview_check') + * cdef inline bint memoryview_check(object o) noexcept: + * return isinstance(o, memoryview) # <<<<<<<<<<<<<< + * + * cdef tuple _unellipsify(object index, int ndim): +*/ + __pyx_t_1 = __Pyx_TypeCheck(__pyx_v_o, __pyx_mstate_global->__pyx_memoryview_type); + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "View.MemoryView":668 + * return result + * + * @cname('__pyx_memoryview_check') # <<<<<<<<<<<<<< + * cdef inline bint memoryview_check(object o) noexcept: + * return isinstance(o, memoryview) +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":672 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with +*/ + +static PyObject *_unellipsify(PyObject *__pyx_v_index, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_idx; + PyObject *__pyx_v_tup = NULL; + PyObject *__pyx_v_result = NULL; + int __pyx_v_have_slices; + int __pyx_v_seen_ellipsis; + PyObject *__pyx_v_item = NULL; + Py_ssize_t __pyx_v_nslices; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + PyObject *__pyx_t_6[3]; + PyObject *__pyx_t_7 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("_unellipsify", 0); + + /* "View.MemoryView":678 + * """ + * cdef Py_ssize_t idx + * tup = index if isinstance(index, tuple) else (index,) # <<<<<<<<<<<<<< + * + * result = [slice(None)] * ndim +*/ + __pyx_t_2 = PyTuple_Check(__pyx_v_index); + if (__pyx_t_2) { + __Pyx_INCREF(((PyObject*)__pyx_v_index)); + __pyx_t_1 = __pyx_v_index; + } else { + __pyx_t_3 = PyTuple_New(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 678, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_v_index); + __Pyx_GIVEREF(__pyx_v_index); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_v_index) != (0)) __PYX_ERR(1, 678, __pyx_L1_error); + __pyx_t_1 = __pyx_t_3; + __pyx_t_3 = 0; + } + __pyx_v_tup = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":680 + * tup = index if isinstance(index, tuple) else (index,) + * + * result = [slice(None)] * ndim # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False +*/ + __pyx_t_1 = PyList_New(1 * ((__pyx_v_ndim<0) ? 0:__pyx_v_ndim)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_ndim; __pyx_temp++) { + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyList_SET_ITEM(__pyx_t_1, __pyx_temp, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(1, 680, __pyx_L1_error); + } + } + __pyx_v_result = ((PyObject*)__pyx_t_1); + __pyx_t_1 = 0; + + /* "View.MemoryView":681 + * + * result = [slice(None)] * ndim + * have_slices = False # <<<<<<<<<<<<<< + * seen_ellipsis = False + * idx = 0 +*/ + __pyx_v_have_slices = 0; + + /* "View.MemoryView":682 + * result = [slice(None)] * ndim + * have_slices = False + * seen_ellipsis = False # <<<<<<<<<<<<<< + * idx = 0 + * for item in tup: +*/ + __pyx_v_seen_ellipsis = 0; + + /* "View.MemoryView":683 + * have_slices = False + * seen_ellipsis = False + * idx = 0 # <<<<<<<<<<<<<< + * for item in tup: + * if item is Ellipsis: +*/ + __pyx_v_idx = 0; + + /* "View.MemoryView":684 + * seen_ellipsis = False + * idx = 0 + * for item in tup: # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: +*/ + if (unlikely(__pyx_v_tup == Py_None)) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); + __PYX_ERR(1, 684, __pyx_L1_error) + } + __pyx_t_1 = __pyx_v_tup; __Pyx_INCREF(__pyx_t_1); + __pyx_t_4 = 0; + for (;;) { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 684, __pyx_L1_error) + #endif + if (__pyx_t_4 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_3 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_1, __pyx_t_4)); + #else + __pyx_t_3 = __Pyx_PySequence_ITEM(__pyx_t_1, __pyx_t_4); + #endif + ++__pyx_t_4; + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 684, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_item, __pyx_t_3); + __pyx_t_3 = 0; + + /* "View.MemoryView":685 + * idx = 0 + * for item in tup: + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * idx += ndim - len(tup) +*/ + __pyx_t_2 = (__pyx_v_item == __pyx_builtin_Ellipsis); + if (__pyx_t_2) { + + /* "View.MemoryView":686 + * for item in tup: + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * idx += ndim - len(tup) + * seen_ellipsis = True +*/ + __pyx_t_2 = (!__pyx_v_seen_ellipsis); + if (__pyx_t_2) { + + /* "View.MemoryView":687 + * if item is Ellipsis: + * if not seen_ellipsis: + * idx += ndim - len(tup) # <<<<<<<<<<<<<< + * seen_ellipsis = True + * have_slices = True +*/ + if (unlikely(__pyx_v_tup == Py_None)) { + PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()"); + __PYX_ERR(1, 687, __pyx_L1_error) + } + __pyx_t_5 = __Pyx_PyTuple_GET_SIZE(__pyx_v_tup); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(1, 687, __pyx_L1_error) + __pyx_v_idx = (__pyx_v_idx + (__pyx_v_ndim - __pyx_t_5)); + + /* "View.MemoryView":688 + * if not seen_ellipsis: + * idx += ndim - len(tup) + * seen_ellipsis = True # <<<<<<<<<<<<<< + * have_slices = True + * else: +*/ + __pyx_v_seen_ellipsis = 1; + + /* "View.MemoryView":686 + * for item in tup: + * if item is Ellipsis: + * if not seen_ellipsis: # <<<<<<<<<<<<<< + * idx += ndim - len(tup) + * seen_ellipsis = True +*/ + } + + /* "View.MemoryView":689 + * idx += ndim - len(tup) + * seen_ellipsis = True + * have_slices = True # <<<<<<<<<<<<<< + * else: + * if isinstance(item, slice): +*/ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":685 + * idx = 0 + * for item in tup: + * if item is Ellipsis: # <<<<<<<<<<<<<< + * if not seen_ellipsis: + * idx += ndim - len(tup) +*/ + goto __pyx_L5; + } + + /* "View.MemoryView":691 + * have_slices = True + * else: + * if isinstance(item, slice): # <<<<<<<<<<<<<< + * have_slices = True + * elif not PyIndex_Check(item): +*/ + /*else*/ { + __pyx_t_2 = PySlice_Check(__pyx_v_item); + if (__pyx_t_2) { + + /* "View.MemoryView":692 + * else: + * if isinstance(item, slice): + * have_slices = True # <<<<<<<<<<<<<< + * elif not PyIndex_Check(item): + * raise TypeError, f"Cannot index with type '{type(item)}'" +*/ + __pyx_v_have_slices = 1; + + /* "View.MemoryView":691 + * have_slices = True + * else: + * if isinstance(item, slice): # <<<<<<<<<<<<<< + * have_slices = True + * elif not PyIndex_Check(item): +*/ + goto __pyx_L7; + } + + /* "View.MemoryView":693 + * if isinstance(item, slice): + * have_slices = True + * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item +*/ + __pyx_t_2 = (!(PyIndex_Check(__pyx_v_item) != 0)); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":694 + * have_slices = True + * elif not PyIndex_Check(item): + * raise TypeError, f"Cannot index with type '{type(item)}'" # <<<<<<<<<<<<<< + * result[idx] = item + * idx += 1 +*/ + __pyx_t_3 = __Pyx_PyObject_FormatSimple(((PyObject *)Py_TYPE(__pyx_v_item)), __pyx_mstate_global->__pyx_empty_unicode); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6[0] = __pyx_mstate_global->__pyx_kp_u_Cannot_index_with_type; + __pyx_t_6[1] = __pyx_t_3; + __pyx_t_6[2] = __pyx_mstate_global->__pyx_kp_u__4; + __pyx_t_7 = __Pyx_PyUnicode_Join(__pyx_t_6, 3, 24 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127 | __Pyx_PyUnicode_MAX_CHAR_VALUE(__pyx_t_3)); + if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 694, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_t_7, 0, 0); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __PYX_ERR(1, 694, __pyx_L1_error) + + /* "View.MemoryView":693 + * if isinstance(item, slice): + * have_slices = True + * elif not PyIndex_Check(item): # <<<<<<<<<<<<<< + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item +*/ + } + __pyx_L7:; + + /* "View.MemoryView":695 + * elif not PyIndex_Check(item): + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item # <<<<<<<<<<<<<< + * idx += 1 + * +*/ + if (unlikely((__Pyx_SetItemInt(__pyx_v_result, __pyx_v_idx, __pyx_v_item, Py_ssize_t, 1, PyLong_FromSsize_t, 1, 1, 1, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(1, 695, __pyx_L1_error) + } + __pyx_L5:; + + /* "View.MemoryView":696 + * raise TypeError, f"Cannot index with type '{type(item)}'" + * result[idx] = item + * idx += 1 # <<<<<<<<<<<<<< + * + * nslices = ndim - idx +*/ + __pyx_v_idx = (__pyx_v_idx + 1); + + /* "View.MemoryView":684 + * seen_ellipsis = False + * idx = 0 + * for item in tup: # <<<<<<<<<<<<<< + * if item is Ellipsis: + * if not seen_ellipsis: +*/ + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "View.MemoryView":698 + * idx += 1 + * + * nslices = ndim - idx # <<<<<<<<<<<<<< + * return have_slices or nslices, tuple(result) + * +*/ + __pyx_v_nslices = (__pyx_v_ndim - __pyx_v_idx); + + /* "View.MemoryView":699 + * + * nslices = ndim - idx + * return have_slices or nslices, tuple(result) # <<<<<<<<<<<<<< + * + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: +*/ + __Pyx_XDECREF(__pyx_r); + if (!__pyx_v_have_slices) { + } else { + __pyx_t_7 = __Pyx_PyBool_FromLong(__pyx_v_have_slices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __pyx_t_7; + __pyx_t_7 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_7 = PyLong_FromSsize_t(__pyx_v_nslices); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __pyx_t_7; + __pyx_t_7 = 0; + __pyx_L9_bool_binop_done:; + __pyx_t_7 = PyList_AsTuple(__pyx_v_result); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 699, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_1) != (0)) __PYX_ERR(1, 699, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(1, 699, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_7 = 0; + __pyx_r = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "View.MemoryView":672 + * return isinstance(o, memoryview) + * + * cdef tuple _unellipsify(object index, int ndim): # <<<<<<<<<<<<<< + * """ + * Replace all ellipses with full slices and fill incomplete indices with +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_AddTraceback("View.MemoryView._unellipsify", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v_tup); + __Pyx_XDECREF(__pyx_v_result); + __Pyx_XDECREF(__pyx_v_item); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":701 + * return have_slices or nslices, tuple(result) + * + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: +*/ + +static int assert_direct_dimensions(Py_ssize_t *__pyx_v_suboffsets, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_suboffset; + int __pyx_r; + Py_ssize_t *__pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "View.MemoryView":702 + * + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: + * for suboffset in suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * raise ValueError, "Indirect dimensions not supported" +*/ + __pyx_t_2 = (__pyx_v_suboffsets + __pyx_v_ndim); + for (__pyx_t_3 = __pyx_v_suboffsets; __pyx_t_3 < __pyx_t_2; __pyx_t_3++) { + __pyx_t_1 = __pyx_t_3; + __pyx_v_suboffset = (__pyx_t_1[0]); + + /* "View.MemoryView":703 + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError, "Indirect dimensions not supported" + * return 0 # return type just used as an error flag +*/ + __pyx_t_4 = (__pyx_v_suboffset >= 0); + if (unlikely(__pyx_t_4)) { + + /* "View.MemoryView":704 + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: + * raise ValueError, "Indirect dimensions not supported" # <<<<<<<<<<<<<< + * return 0 # return type just used as an error flag + * +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_mstate_global->__pyx_kp_u_Indirect_dimensions_not_supporte, 0, 0); + __PYX_ERR(1, 704, __pyx_L1_error) + + /* "View.MemoryView":703 + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * raise ValueError, "Indirect dimensions not supported" + * return 0 # return type just used as an error flag +*/ + } + } + + /* "View.MemoryView":705 + * if suboffset >= 0: + * raise ValueError, "Indirect dimensions not supported" + * return 0 # return type just used as an error flag # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":701 + * return have_slices or nslices, tuple(result) + * + * cdef int assert_direct_dimensions(Py_ssize_t *suboffsets, int ndim) except -1: # <<<<<<<<<<<<<< + * for suboffset in suboffsets[:ndim]: + * if suboffset >= 0: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView.assert_direct_dimensions", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":711 + * + * + * @cname('__pyx_memview_slice') # <<<<<<<<<<<<<< + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim +*/ + +static struct __pyx_memoryview_obj *__pyx_memview_slice(struct __pyx_memoryview_obj *__pyx_v_memview, PyObject *__pyx_v_indices) { + int __pyx_v_new_ndim; + int __pyx_v_suboffset_dim; + int __pyx_v_dim; + __Pyx_memviewslice __pyx_v_src; + __Pyx_memviewslice __pyx_v_dst; + __Pyx_memviewslice *__pyx_v_p_src; + struct __pyx_memoryviewslice_obj *__pyx_v_memviewsliceobj = 0; + __Pyx_memviewslice *__pyx_v_p_dst; + int *__pyx_v_p_suboffset_dim; + Py_ssize_t __pyx_v_start; + Py_ssize_t __pyx_v_stop; + Py_ssize_t __pyx_v_step; + Py_ssize_t __pyx_v_cindex; + int __pyx_v_have_start; + int __pyx_v_have_stop; + int __pyx_v_have_step; + PyObject *__pyx_v_index = NULL; + struct __pyx_memoryview_obj *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + struct __pyx_memoryview_obj *__pyx_t_3; + char *__pyx_t_4; + int __pyx_t_5; + Py_ssize_t __pyx_t_6; + PyObject *(*__pyx_t_7)(PyObject *); + PyObject *__pyx_t_8 = NULL; + Py_ssize_t __pyx_t_9; + int __pyx_t_10; + Py_ssize_t __pyx_t_11; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memview_slice", 0); + + /* "View.MemoryView":713 + * @cname('__pyx_memview_slice') + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim # <<<<<<<<<<<<<< + * cdef bint negative_step + * cdef __Pyx_memviewslice src, dst +*/ + __pyx_v_new_ndim = 0; + __pyx_v_suboffset_dim = -1; + + /* "View.MemoryView":720 + * + * + * memset(&dst, 0, sizeof(dst)) # <<<<<<<<<<<<<< + * + * cdef _memoryviewslice memviewsliceobj +*/ + (void)(memset((&__pyx_v_dst), 0, (sizeof(__pyx_v_dst)))); + + /* "View.MemoryView":724 + * cdef _memoryviewslice memviewsliceobj + * + * assert memview.view.ndim > 0 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): +*/ + #ifndef CYTHON_WITHOUT_ASSERTIONS + if (unlikely(__pyx_assertions_enabled())) { + __pyx_t_1 = (__pyx_v_memview->view.ndim > 0); + if (unlikely(!__pyx_t_1)) { + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_AssertionError))), 0, 0, 0); + __PYX_ERR(1, 724, __pyx_L1_error) + } + } + #else + if ((1)); else __PYX_ERR(1, 724, __pyx_L1_error) + #endif + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice +*/ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_mstate_global->__pyx_memoryviewslice_type); + if (__pyx_t_1) { + + /* "View.MemoryView":727 + * + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview # <<<<<<<<<<<<<< + * p_src = &memviewsliceobj.from_slice + * else: +*/ + __pyx_t_2 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_memoryviewslice_type))))) __PYX_ERR(1, 727, __pyx_L1_error) + __pyx_v_memviewsliceobj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":728 + * if isinstance(memview, _memoryviewslice): + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, &src) +*/ + __pyx_v_p_src = (&__pyx_v_memviewsliceobj->from_slice); + + /* "View.MemoryView":726 + * assert memview.view.ndim > 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * memviewsliceobj = memview + * p_src = &memviewsliceobj.from_slice +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":730 + * p_src = &memviewsliceobj.from_slice + * else: + * slice_copy(memview, &src) # <<<<<<<<<<<<<< + * p_src = &src + * +*/ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_src)); + + /* "View.MemoryView":731 + * else: + * slice_copy(memview, &src) + * p_src = &src # <<<<<<<<<<<<<< + * + * +*/ + __pyx_v_p_src = (&__pyx_v_src); + } + __pyx_L3:; + + /* "View.MemoryView":737 + * + * + * dst.memview = p_src.memview # <<<<<<<<<<<<<< + * dst.data = p_src.data + * +*/ + __pyx_t_3 = __pyx_v_p_src->memview; + __pyx_v_dst.memview = __pyx_t_3; + + /* "View.MemoryView":738 + * + * dst.memview = p_src.memview + * dst.data = p_src.data # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_4 = __pyx_v_p_src->data; + __pyx_v_dst.data = __pyx_t_4; + + /* "View.MemoryView":743 + * + * + * cdef __Pyx_memviewslice *p_dst = &dst # <<<<<<<<<<<<<< + * cdef int *p_suboffset_dim = &suboffset_dim + * cdef Py_ssize_t start, stop, step, cindex +*/ + __pyx_v_p_dst = (&__pyx_v_dst); + + /* "View.MemoryView":744 + * + * cdef __Pyx_memviewslice *p_dst = &dst + * cdef int *p_suboffset_dim = &suboffset_dim # <<<<<<<<<<<<<< + * cdef Py_ssize_t start, stop, step, cindex + * cdef bint have_start, have_stop, have_step +*/ + __pyx_v_p_suboffset_dim = (&__pyx_v_suboffset_dim); + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * cindex = index +*/ + __pyx_t_5 = 0; + if (likely(PyList_CheckExact(__pyx_v_indices)) || PyTuple_CheckExact(__pyx_v_indices)) { + __pyx_t_2 = __pyx_v_indices; __Pyx_INCREF(__pyx_t_2); + __pyx_t_6 = 0; + __pyx_t_7 = NULL; + } else { + __pyx_t_6 = -1; __pyx_t_2 = PyObject_GetIter(__pyx_v_indices); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 748, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_2); if (unlikely(!__pyx_t_7)) __PYX_ERR(1, 748, __pyx_L1_error) + } + for (;;) { + if (likely(!__pyx_t_7)) { + if (likely(PyList_CheckExact(__pyx_t_2))) { + { + Py_ssize_t __pyx_temp = __Pyx_PyList_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 748, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + __pyx_t_8 = __Pyx_PyList_GetItemRefFast(__pyx_t_2, __pyx_t_6, __Pyx_ReferenceSharing_OwnStrongReference); + ++__pyx_t_6; + } else { + { + Py_ssize_t __pyx_temp = __Pyx_PyTuple_GET_SIZE(__pyx_t_2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely((__pyx_temp < 0))) __PYX_ERR(1, 748, __pyx_L1_error) + #endif + if (__pyx_t_6 >= __pyx_temp) break; + } + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + __pyx_t_8 = __Pyx_NewRef(PyTuple_GET_ITEM(__pyx_t_2, __pyx_t_6)); + #else + __pyx_t_8 = __Pyx_PySequence_ITEM(__pyx_t_2, __pyx_t_6); + #endif + ++__pyx_t_6; + } + if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 748, __pyx_L1_error) + } else { + __pyx_t_8 = __pyx_t_7(__pyx_t_2); + if (unlikely(!__pyx_t_8)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(1, 748, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_8); + __Pyx_XDECREF_SET(__pyx_v_index, __pyx_t_8); + __pyx_t_8 = 0; + __pyx_v_dim = __pyx_t_5; + __pyx_t_5 = (__pyx_t_5 + 1); + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * cindex = index + * slice_memviewslice( +*/ + __pyx_t_1 = (PyIndex_Check(__pyx_v_index) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":750 + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): + * cindex = index # <<<<<<<<<<<<<< + * slice_memviewslice( + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], +*/ + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_v_index); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 750, __pyx_L1_error) + __pyx_v_cindex = __pyx_t_9; + + /* "View.MemoryView":751 + * if PyIndex_Check(index): + * cindex = index + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, +*/ + __pyx_t_10 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_cindex, 0, 0, 0, 0, 0, 0); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 751, __pyx_L1_error) + + /* "View.MemoryView":749 + * + * for dim, index in enumerate(indices): + * if PyIndex_Check(index): # <<<<<<<<<<<<<< + * cindex = index + * slice_memviewslice( +*/ + goto __pyx_L6; + } + + /* "View.MemoryView":757 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 +*/ + __pyx_t_1 = (__pyx_v_index == Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":758 + * False) + * elif index is None: + * p_dst.shape[new_ndim] = 1 # <<<<<<<<<<<<<< + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 +*/ + (__pyx_v_p_dst->shape[__pyx_v_new_ndim]) = 1; + + /* "View.MemoryView":759 + * elif index is None: + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 # <<<<<<<<<<<<<< + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 +*/ + (__pyx_v_p_dst->strides[__pyx_v_new_ndim]) = 0; + + /* "View.MemoryView":760 + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 # <<<<<<<<<<<<<< + * new_ndim += 1 + * else: +*/ + (__pyx_v_p_dst->suboffsets[__pyx_v_new_ndim]) = -1L; + + /* "View.MemoryView":761 + * p_dst.strides[new_ndim] = 0 + * p_dst.suboffsets[new_ndim] = -1 + * new_ndim += 1 # <<<<<<<<<<<<<< + * else: + * start = index.start or 0 +*/ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + + /* "View.MemoryView":757 + * 0, 0, 0, # have_{start,stop,step} + * False) + * elif index is None: # <<<<<<<<<<<<<< + * p_dst.shape[new_ndim] = 1 + * p_dst.strides[new_ndim] = 0 +*/ + goto __pyx_L6; + } + + /* "View.MemoryView":763 + * new_ndim += 1 + * else: + * start = index.start or 0 # <<<<<<<<<<<<<< + * stop = index.stop or 0 + * step = index.step or 0 +*/ + /*else*/ { + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 763, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 763, __pyx_L1_error) + __pyx_t_9 = __pyx_t_11; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L7_bool_binop_done; + } + __pyx_t_9 = 0; + __pyx_L7_bool_binop_done:; + __pyx_v_start = __pyx_t_9; + + /* "View.MemoryView":764 + * else: + * start = index.start or 0 + * stop = index.stop or 0 # <<<<<<<<<<<<<< + * step = index.step or 0 + * +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 764, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 764, __pyx_L1_error) + __pyx_t_9 = __pyx_t_11; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L9_bool_binop_done; + } + __pyx_t_9 = 0; + __pyx_L9_bool_binop_done:; + __pyx_v_stop = __pyx_t_9; + + /* "View.MemoryView":765 + * start = index.start or 0 + * stop = index.stop or 0 + * step = index.step or 0 # <<<<<<<<<<<<<< + * + * have_start = index.start is not None +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 765, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_1 < 0))) __PYX_ERR(1, 765, __pyx_L1_error) + if (!__pyx_t_1) { + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } else { + __pyx_t_11 = __Pyx_PyIndex_AsSsize_t(__pyx_t_8); if (unlikely((__pyx_t_11 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 765, __pyx_L1_error) + __pyx_t_9 = __pyx_t_11; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_9 = 0; + __pyx_L11_bool_binop_done:; + __pyx_v_step = __pyx_t_9; + + /* "View.MemoryView":767 + * step = index.step or 0 + * + * have_start = index.start is not None # <<<<<<<<<<<<<< + * have_stop = index.stop is not None + * have_step = index.step is not None +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_start); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 767, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = (__pyx_t_8 != Py_None); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_have_start = __pyx_t_1; + + /* "View.MemoryView":768 + * + * have_start = index.start is not None + * have_stop = index.stop is not None # <<<<<<<<<<<<<< + * have_step = index.step is not None + * +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_stop); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 768, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = (__pyx_t_8 != Py_None); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_have_stop = __pyx_t_1; + + /* "View.MemoryView":769 + * have_start = index.start is not None + * have_stop = index.stop is not None + * have_step = index.step is not None # <<<<<<<<<<<<<< + * + * slice_memviewslice( +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_index, __pyx_mstate_global->__pyx_n_u_step); if (unlikely(!__pyx_t_8)) __PYX_ERR(1, 769, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = (__pyx_t_8 != Py_None); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_v_have_step = __pyx_t_1; + + /* "View.MemoryView":771 + * have_step = index.step is not None + * + * slice_memviewslice( # <<<<<<<<<<<<<< + * p_dst, p_src.shape[dim], p_src.strides[dim], p_src.suboffsets[dim], + * dim, new_ndim, p_suboffset_dim, +*/ + __pyx_t_10 = __pyx_memoryview_slice_memviewslice(__pyx_v_p_dst, (__pyx_v_p_src->shape[__pyx_v_dim]), (__pyx_v_p_src->strides[__pyx_v_dim]), (__pyx_v_p_src->suboffsets[__pyx_v_dim]), __pyx_v_dim, __pyx_v_new_ndim, __pyx_v_p_suboffset_dim, __pyx_v_start, __pyx_v_stop, __pyx_v_step, __pyx_v_have_start, __pyx_v_have_stop, __pyx_v_have_step, 1); if (unlikely(__pyx_t_10 == ((int)-1))) __PYX_ERR(1, 771, __pyx_L1_error) + + /* "View.MemoryView":777 + * have_start, have_stop, have_step, + * True) + * new_ndim += 1 # <<<<<<<<<<<<<< + * + * if isinstance(memview, _memoryviewslice): +*/ + __pyx_v_new_ndim = (__pyx_v_new_ndim + 1); + } + __pyx_L6:; + + /* "View.MemoryView":748 + * cdef bint have_start, have_stop, have_step + * + * for dim, index in enumerate(indices): # <<<<<<<<<<<<<< + * if PyIndex_Check(index): + * cindex = index +*/ + } + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "View.MemoryView":779 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, +*/ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_mstate_global->__pyx_memoryviewslice_type); + if (__pyx_t_1) { + + /* "View.MemoryView":780 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, +*/ + __Pyx_XDECREF((PyObject *)__pyx_r); + + /* "View.MemoryView":781 + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, # <<<<<<<<<<<<<< + * memviewsliceobj.to_dtype_func, + * memview.dtype_is_object) +*/ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 781, __pyx_L1_error) } + + /* "View.MemoryView":782 + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * else: +*/ + if (unlikely(!__pyx_v_memviewsliceobj)) { __Pyx_RaiseUnboundLocalError("memviewsliceobj"); __PYX_ERR(1, 782, __pyx_L1_error) } + + /* "View.MemoryView":780 + * + * if isinstance(memview, _memoryviewslice): + * return memoryview_fromslice(dst, new_ndim, # <<<<<<<<<<<<<< + * memviewsliceobj.to_object_func, + * memviewsliceobj.to_dtype_func, +*/ + __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, __pyx_v_memviewsliceobj->to_object_func, __pyx_v_memviewsliceobj->to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 780, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":779 + * new_ndim += 1 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * return memoryview_fromslice(dst, new_ndim, + * memviewsliceobj.to_object_func, +*/ + } + + /* "View.MemoryView":785 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * +*/ + /*else*/ { + __Pyx_XDECREF((PyObject *)__pyx_r); + + /* "View.MemoryView":786 + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_2 = __pyx_memoryview_fromslice(__pyx_v_dst, __pyx_v_new_ndim, NULL, NULL, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 785, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "View.MemoryView":785 + * memview.dtype_is_object) + * else: + * return memoryview_fromslice(dst, new_ndim, NULL, NULL, # <<<<<<<<<<<<<< + * memview.dtype_is_object) + * +*/ + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_memoryview_type))))) __PYX_ERR(1, 785, __pyx_L1_error) + __pyx_r = ((struct __pyx_memoryview_obj *)__pyx_t_2); + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":711 + * + * + * @cname('__pyx_memview_slice') # <<<<<<<<<<<<<< + * cdef memoryview memview_slice(memoryview memview, object indices): + * cdef int new_ndim = 0, suboffset_dim = -1, dim +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_AddTraceback("View.MemoryView.memview_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_memviewsliceobj); + __Pyx_XDECREF(__pyx_v_index); + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":793 + * + * + * @cname('__pyx_memoryview_slice_memviewslice') # <<<<<<<<<<<<<< + * cdef int slice_memviewslice( + * __Pyx_memviewslice *dst, +*/ + +static int __pyx_memoryview_slice_memviewslice(__Pyx_memviewslice *__pyx_v_dst, Py_ssize_t __pyx_v_shape, Py_ssize_t __pyx_v_stride, Py_ssize_t __pyx_v_suboffset, int __pyx_v_dim, int __pyx_v_new_ndim, int *__pyx_v_suboffset_dim, Py_ssize_t __pyx_v_start, Py_ssize_t __pyx_v_stop, Py_ssize_t __pyx_v_step, int __pyx_v_have_start, int __pyx_v_have_stop, int __pyx_v_have_step, int __pyx_v_is_slice) { + Py_ssize_t __pyx_v_new_shape; + int __pyx_v_negative_step; + int __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "View.MemoryView":814 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: +*/ + __pyx_t_1 = (!__pyx_v_is_slice); + if (__pyx_t_1) { + + /* "View.MemoryView":816 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: +*/ + __pyx_t_1 = (__pyx_v_start < 0); + if (__pyx_t_1) { + + /* "View.MemoryView":817 + * + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if not 0 <= start < shape: + * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) +*/ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":816 + * if not is_slice: + * + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if not 0 <= start < shape: +*/ + } + + /* "View.MemoryView":818 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) + * else: +*/ + __pyx_t_1 = (0 <= __pyx_v_start); + if (__pyx_t_1) { + __pyx_t_1 = (__pyx_v_start < __pyx_v_shape); + } + __pyx_t_2 = (!__pyx_t_1); + if (__pyx_t_2) { + + /* "View.MemoryView":819 + * start += shape + * if not 0 <= start < shape: + * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) # <<<<<<<<<<<<<< + * else: + * +*/ + __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_IndexError, __pyx_mstate_global->__pyx_kp_u_Index_out_of_bounds_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 819, __pyx_L1_error) + + /* "View.MemoryView":818 + * if start < 0: + * start += shape + * if not 0 <= start < shape: # <<<<<<<<<<<<<< + * _err_dim(PyExc_IndexError, "Index out of bounds (axis %d)", dim) + * else: +*/ + } + + /* "View.MemoryView":814 + * cdef bint negative_step + * + * if not is_slice: # <<<<<<<<<<<<<< + * + * if start < 0: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":822 + * else: + * + * if have_step: # <<<<<<<<<<<<<< + * negative_step = step < 0 + * if step == 0: +*/ + /*else*/ { + __pyx_t_2 = (__pyx_v_have_step != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":823 + * + * if have_step: + * negative_step = step < 0 # <<<<<<<<<<<<<< + * if step == 0: + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) +*/ + __pyx_v_negative_step = (__pyx_v_step < 0); + + /* "View.MemoryView":824 + * if have_step: + * negative_step = step < 0 + * if step == 0: # <<<<<<<<<<<<<< + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) + * else: +*/ + __pyx_t_2 = (__pyx_v_step == 0); + if (__pyx_t_2) { + + /* "View.MemoryView":825 + * negative_step = step < 0 + * if step == 0: + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) # <<<<<<<<<<<<<< + * else: + * negative_step = False +*/ + __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_mstate_global->__pyx_kp_u_Step_may_not_be_zero_axis_d, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 825, __pyx_L1_error) + + /* "View.MemoryView":824 + * if have_step: + * negative_step = step < 0 + * if step == 0: # <<<<<<<<<<<<<< + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) + * else: +*/ + } + + /* "View.MemoryView":822 + * else: + * + * if have_step: # <<<<<<<<<<<<<< + * negative_step = step < 0 + * if step == 0: +*/ + goto __pyx_L6; + } + + /* "View.MemoryView":827 + * _err_dim(PyExc_ValueError, "Step may not be zero (axis %d)", dim) + * else: + * negative_step = False # <<<<<<<<<<<<<< + * step = 1 + * +*/ + /*else*/ { + __pyx_v_negative_step = 0; + + /* "View.MemoryView":828 + * else: + * negative_step = False + * step = 1 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_v_step = 1; + } + __pyx_L6:; + + /* "View.MemoryView":831 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape +*/ + __pyx_t_2 = (__pyx_v_have_start != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":832 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: +*/ + __pyx_t_2 = (__pyx_v_start < 0); + if (__pyx_t_2) { + + /* "View.MemoryView":833 + * if have_start: + * if start < 0: + * start += shape # <<<<<<<<<<<<<< + * if start < 0: + * start = 0 +*/ + __pyx_v_start = (__pyx_v_start + __pyx_v_shape); + + /* "View.MemoryView":834 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: +*/ + __pyx_t_2 = (__pyx_v_start < 0); + if (__pyx_t_2) { + + /* "View.MemoryView":835 + * start += shape + * if start < 0: + * start = 0 # <<<<<<<<<<<<<< + * elif start >= shape: + * if negative_step: +*/ + __pyx_v_start = 0; + + /* "View.MemoryView":834 + * if start < 0: + * start += shape + * if start < 0: # <<<<<<<<<<<<<< + * start = 0 + * elif start >= shape: +*/ + } + + /* "View.MemoryView":832 + * + * if have_start: + * if start < 0: # <<<<<<<<<<<<<< + * start += shape + * if start < 0: +*/ + goto __pyx_L9; + } + + /* "View.MemoryView":836 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 +*/ + __pyx_t_2 = (__pyx_v_start >= __pyx_v_shape); + if (__pyx_t_2) { + + /* "View.MemoryView":837 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: +*/ + if (__pyx_v_negative_step) { + + /* "View.MemoryView":838 + * elif start >= shape: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = shape +*/ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":837 + * start = 0 + * elif start >= shape: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: +*/ + goto __pyx_L11; + } + + /* "View.MemoryView":840 + * start = shape - 1 + * else: + * start = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: +*/ + /*else*/ { + __pyx_v_start = __pyx_v_shape; + } + __pyx_L11:; + + /* "View.MemoryView":836 + * if start < 0: + * start = 0 + * elif start >= shape: # <<<<<<<<<<<<<< + * if negative_step: + * start = shape - 1 +*/ + } + __pyx_L9:; + + /* "View.MemoryView":831 + * + * + * if have_start: # <<<<<<<<<<<<<< + * if start < 0: + * start += shape +*/ + goto __pyx_L8; + } + + /* "View.MemoryView":842 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: +*/ + /*else*/ { + if (__pyx_v_negative_step) { + + /* "View.MemoryView":843 + * else: + * if negative_step: + * start = shape - 1 # <<<<<<<<<<<<<< + * else: + * start = 0 +*/ + __pyx_v_start = (__pyx_v_shape - 1); + + /* "View.MemoryView":842 + * start = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * start = shape - 1 + * else: +*/ + goto __pyx_L12; + } + + /* "View.MemoryView":845 + * start = shape - 1 + * else: + * start = 0 # <<<<<<<<<<<<<< + * + * if have_stop: +*/ + /*else*/ { + __pyx_v_start = 0; + } + __pyx_L12:; + } + __pyx_L8:; + + /* "View.MemoryView":847 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape +*/ + __pyx_t_2 = (__pyx_v_have_stop != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":848 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: +*/ + __pyx_t_2 = (__pyx_v_stop < 0); + if (__pyx_t_2) { + + /* "View.MemoryView":849 + * if have_stop: + * if stop < 0: + * stop += shape # <<<<<<<<<<<<<< + * if stop < 0: + * stop = 0 +*/ + __pyx_v_stop = (__pyx_v_stop + __pyx_v_shape); + + /* "View.MemoryView":850 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: +*/ + __pyx_t_2 = (__pyx_v_stop < 0); + if (__pyx_t_2) { + + /* "View.MemoryView":851 + * stop += shape + * if stop < 0: + * stop = 0 # <<<<<<<<<<<<<< + * elif stop > shape: + * stop = shape +*/ + __pyx_v_stop = 0; + + /* "View.MemoryView":850 + * if stop < 0: + * stop += shape + * if stop < 0: # <<<<<<<<<<<<<< + * stop = 0 + * elif stop > shape: +*/ + } + + /* "View.MemoryView":848 + * + * if have_stop: + * if stop < 0: # <<<<<<<<<<<<<< + * stop += shape + * if stop < 0: +*/ + goto __pyx_L14; + } + + /* "View.MemoryView":852 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: +*/ + __pyx_t_2 = (__pyx_v_stop > __pyx_v_shape); + if (__pyx_t_2) { + + /* "View.MemoryView":853 + * stop = 0 + * elif stop > shape: + * stop = shape # <<<<<<<<<<<<<< + * else: + * if negative_step: +*/ + __pyx_v_stop = __pyx_v_shape; + + /* "View.MemoryView":852 + * if stop < 0: + * stop = 0 + * elif stop > shape: # <<<<<<<<<<<<<< + * stop = shape + * else: +*/ + } + __pyx_L14:; + + /* "View.MemoryView":847 + * start = 0 + * + * if have_stop: # <<<<<<<<<<<<<< + * if stop < 0: + * stop += shape +*/ + goto __pyx_L13; + } + + /* "View.MemoryView":855 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: +*/ + /*else*/ { + if (__pyx_v_negative_step) { + + /* "View.MemoryView":856 + * else: + * if negative_step: + * stop = -1 # <<<<<<<<<<<<<< + * else: + * stop = shape +*/ + __pyx_v_stop = -1L; + + /* "View.MemoryView":855 + * stop = shape + * else: + * if negative_step: # <<<<<<<<<<<<<< + * stop = -1 + * else: +*/ + goto __pyx_L16; + } + + /* "View.MemoryView":858 + * stop = -1 + * else: + * stop = shape # <<<<<<<<<<<<<< + * + * +*/ + /*else*/ { + __pyx_v_stop = __pyx_v_shape; + } + __pyx_L16:; + } + __pyx_L13:; + + /* "View.MemoryView":862 + * + * with cython.cdivision(True): + * new_shape = (stop - start) // step # <<<<<<<<<<<<<< + * + * if (stop - start) - step * new_shape: +*/ + __pyx_v_new_shape = ((__pyx_v_stop - __pyx_v_start) / __pyx_v_step); + + /* "View.MemoryView":864 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * +*/ + __pyx_t_2 = (((__pyx_v_stop - __pyx_v_start) - (__pyx_v_step * __pyx_v_new_shape)) != 0); + if (__pyx_t_2) { + + /* "View.MemoryView":865 + * + * if (stop - start) - step * new_shape: + * new_shape += 1 # <<<<<<<<<<<<<< + * + * if new_shape < 0: +*/ + __pyx_v_new_shape = (__pyx_v_new_shape + 1); + + /* "View.MemoryView":864 + * new_shape = (stop - start) // step + * + * if (stop - start) - step * new_shape: # <<<<<<<<<<<<<< + * new_shape += 1 + * +*/ + } + + /* "View.MemoryView":867 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * +*/ + __pyx_t_2 = (__pyx_v_new_shape < 0); + if (__pyx_t_2) { + + /* "View.MemoryView":868 + * + * if new_shape < 0: + * new_shape = 0 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_v_new_shape = 0; + + /* "View.MemoryView":867 + * new_shape += 1 + * + * if new_shape < 0: # <<<<<<<<<<<<<< + * new_shape = 0 + * +*/ + } + + /* "View.MemoryView":871 + * + * + * dst.strides[new_ndim] = stride * step # <<<<<<<<<<<<<< + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset +*/ + (__pyx_v_dst->strides[__pyx_v_new_ndim]) = (__pyx_v_stride * __pyx_v_step); + + /* "View.MemoryView":872 + * + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape # <<<<<<<<<<<<<< + * dst.suboffsets[new_ndim] = suboffset + * +*/ + (__pyx_v_dst->shape[__pyx_v_new_ndim]) = __pyx_v_new_shape; + + /* "View.MemoryView":873 + * dst.strides[new_ndim] = stride * step + * dst.shape[new_ndim] = new_shape + * dst.suboffsets[new_ndim] = suboffset # <<<<<<<<<<<<<< + * + * +*/ + (__pyx_v_dst->suboffsets[__pyx_v_new_ndim]) = __pyx_v_suboffset; + } + __pyx_L3:; + + /* "View.MemoryView":876 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: +*/ + __pyx_t_2 = ((__pyx_v_suboffset_dim[0]) < 0); + if (__pyx_t_2) { + + /* "View.MemoryView":877 + * + * if suboffset_dim[0] < 0: + * dst.data += start * stride # <<<<<<<<<<<<<< + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride +*/ + __pyx_v_dst->data = (__pyx_v_dst->data + (__pyx_v_start * __pyx_v_stride)); + + /* "View.MemoryView":876 + * + * + * if suboffset_dim[0] < 0: # <<<<<<<<<<<<<< + * dst.data += start * stride + * else: +*/ + goto __pyx_L19; + } + + /* "View.MemoryView":879 + * dst.data += start * stride + * else: + * dst.suboffsets[suboffset_dim[0]] += start * stride # <<<<<<<<<<<<<< + * + * if suboffset >= 0: +*/ + /*else*/ { + __pyx_t_3 = (__pyx_v_suboffset_dim[0]); + (__pyx_v_dst->suboffsets[__pyx_t_3]) = ((__pyx_v_dst->suboffsets[__pyx_t_3]) + (__pyx_v_start * __pyx_v_stride)); + } + __pyx_L19:; + + /* "View.MemoryView":881 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: +*/ + __pyx_t_2 = (__pyx_v_suboffset >= 0); + if (__pyx_t_2) { + + /* "View.MemoryView":882 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset +*/ + __pyx_t_2 = (!__pyx_v_is_slice); + if (__pyx_t_2) { + + /* "View.MemoryView":883 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: +*/ + __pyx_t_2 = (__pyx_v_new_ndim == 0); + if (__pyx_t_2) { + + /* "View.MemoryView":884 + * if not is_slice: + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset # <<<<<<<<<<<<<< + * else: + * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " +*/ + __pyx_v_dst->data = ((((char **)__pyx_v_dst->data)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":883 + * if suboffset >= 0: + * if not is_slice: + * if new_ndim == 0: # <<<<<<<<<<<<<< + * dst.data = ( dst.data)[0] + suboffset + * else: +*/ + goto __pyx_L22; + } + + /* "View.MemoryView":886 + * dst.data = ( dst.data)[0] + suboffset + * else: + * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " # <<<<<<<<<<<<<< + * "must be indexed and not sliced", dim) + * else: +*/ + /*else*/ { + + /* "View.MemoryView":887 + * else: + * _err_dim(PyExc_IndexError, "All dimensions preceding dimension %d " + * "must be indexed and not sliced", dim) # <<<<<<<<<<<<<< + * else: + * suboffset_dim[0] = new_ndim +*/ + __pyx_t_3 = __pyx_memoryview_err_dim(PyExc_IndexError, __pyx_mstate_global->__pyx_kp_u_All_dimensions_preceding_dimensi, __pyx_v_dim); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 886, __pyx_L1_error) + } + __pyx_L22:; + + /* "View.MemoryView":882 + * + * if suboffset >= 0: + * if not is_slice: # <<<<<<<<<<<<<< + * if new_ndim == 0: + * dst.data = ( dst.data)[0] + suboffset +*/ + goto __pyx_L21; + } + + /* "View.MemoryView":889 + * "must be indexed and not sliced", dim) + * else: + * suboffset_dim[0] = new_ndim # <<<<<<<<<<<<<< + * + * return 0 +*/ + /*else*/ { + (__pyx_v_suboffset_dim[0]) = __pyx_v_new_ndim; + } + __pyx_L21:; + + /* "View.MemoryView":881 + * dst.suboffsets[suboffset_dim[0]] += start * stride + * + * if suboffset >= 0: # <<<<<<<<<<<<<< + * if not is_slice: + * if new_ndim == 0: +*/ + } + + /* "View.MemoryView":891 + * suboffset_dim[0] = new_ndim + * + * return 0 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":793 + * + * + * @cname('__pyx_memoryview_slice_memviewslice') # <<<<<<<<<<<<<< + * cdef int slice_memviewslice( + * __Pyx_memviewslice *dst, +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("View.MemoryView.slice_memviewslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":896 + * + * + * @cname('__pyx_pybuffer_index') # <<<<<<<<<<<<<< + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: +*/ + +static char *__pyx_pybuffer_index(Py_buffer *__pyx_v_view, char *__pyx_v_bufp, Py_ssize_t __pyx_v_index, Py_ssize_t __pyx_v_dim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_suboffset; + Py_ssize_t __pyx_v_itemsize; + char *__pyx_v_resultp; + char *__pyx_r; + __Pyx_RefNannyDeclarations + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4[3]; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("pybuffer_index", 0); + + /* "View.MemoryView":899 + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 # <<<<<<<<<<<<<< + * cdef Py_ssize_t itemsize = view.itemsize + * cdef char *resultp +*/ + __pyx_v_suboffset = -1L; + + /* "View.MemoryView":900 + * Py_ssize_t dim) except NULL: + * cdef Py_ssize_t shape, stride, suboffset = -1 + * cdef Py_ssize_t itemsize = view.itemsize # <<<<<<<<<<<<<< + * cdef char *resultp + * +*/ + __pyx_t_1 = __pyx_v_view->itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":903 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len // itemsize + * stride = itemsize +*/ + __pyx_t_2 = (__pyx_v_view->ndim == 0); + if (__pyx_t_2) { + + /* "View.MemoryView":904 + * + * if view.ndim == 0: + * shape = view.len // itemsize # <<<<<<<<<<<<<< + * stride = itemsize + * else: +*/ + if (unlikely(__pyx_v_itemsize == 0)) { + PyErr_SetString(PyExc_ZeroDivisionError, "integer division or modulo by zero"); + __PYX_ERR(1, 904, __pyx_L1_error) + } + else if (sizeof(Py_ssize_t) == sizeof(long) && (!(((Py_ssize_t)-1) > 0)) && unlikely(__pyx_v_itemsize == (Py_ssize_t)-1) && unlikely(__Pyx_UNARY_NEG_WOULD_OVERFLOW(__pyx_v_view->len))) { + PyErr_SetString(PyExc_OverflowError, "value too large to perform division"); + __PYX_ERR(1, 904, __pyx_L1_error) + } + __pyx_v_shape = __Pyx_div_Py_ssize_t(__pyx_v_view->len, __pyx_v_itemsize, 0); + + /* "View.MemoryView":905 + * if view.ndim == 0: + * shape = view.len // itemsize + * stride = itemsize # <<<<<<<<<<<<<< + * else: + * shape = view.shape[dim] +*/ + __pyx_v_stride = __pyx_v_itemsize; + + /* "View.MemoryView":903 + * cdef char *resultp + * + * if view.ndim == 0: # <<<<<<<<<<<<<< + * shape = view.len // itemsize + * stride = itemsize +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":907 + * stride = itemsize + * else: + * shape = view.shape[dim] # <<<<<<<<<<<<<< + * stride = view.strides[dim] + * if view.suboffsets != NULL: +*/ + /*else*/ { + __pyx_v_shape = (__pyx_v_view->shape[__pyx_v_dim]); + + /* "View.MemoryView":908 + * else: + * shape = view.shape[dim] + * stride = view.strides[dim] # <<<<<<<<<<<<<< + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] +*/ + __pyx_v_stride = (__pyx_v_view->strides[__pyx_v_dim]); + + /* "View.MemoryView":909 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * +*/ + __pyx_t_2 = (__pyx_v_view->suboffsets != NULL); + if (__pyx_t_2) { + + /* "View.MemoryView":910 + * stride = view.strides[dim] + * if view.suboffsets != NULL: + * suboffset = view.suboffsets[dim] # <<<<<<<<<<<<<< + * + * if index < 0: +*/ + __pyx_v_suboffset = (__pyx_v_view->suboffsets[__pyx_v_dim]); + + /* "View.MemoryView":909 + * shape = view.shape[dim] + * stride = view.strides[dim] + * if view.suboffsets != NULL: # <<<<<<<<<<<<<< + * suboffset = view.suboffsets[dim] + * +*/ + } + } + __pyx_L3:; + + /* "View.MemoryView":912 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: +*/ + __pyx_t_2 = (__pyx_v_index < 0); + if (__pyx_t_2) { + + /* "View.MemoryView":913 + * + * if index < 0: + * index += view.shape[dim] # <<<<<<<<<<<<<< + * if index < 0: + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" +*/ + __pyx_v_index = (__pyx_v_index + (__pyx_v_view->shape[__pyx_v_dim])); + + /* "View.MemoryView":914 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * +*/ + __pyx_t_2 = (__pyx_v_index < 0); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":915 + * index += view.shape[dim] + * if index < 0: + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< + * + * if index >= shape: +*/ + __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a; + __pyx_t_4[1] = __pyx_t_3; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u__5; + __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_4, 3, 37 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127); + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 915, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_IndexError))), __pyx_t_5, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 915, __pyx_L1_error) + + /* "View.MemoryView":914 + * if index < 0: + * index += view.shape[dim] + * if index < 0: # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * +*/ + } + + /* "View.MemoryView":912 + * suboffset = view.suboffsets[dim] + * + * if index < 0: # <<<<<<<<<<<<<< + * index += view.shape[dim] + * if index < 0: +*/ + } + + /* "View.MemoryView":917 + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * +*/ + __pyx_t_2 = (__pyx_v_index >= __pyx_v_shape); + if (unlikely(__pyx_t_2)) { + + /* "View.MemoryView":918 + * + * if index >= shape: + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" # <<<<<<<<<<<<<< + * + * resultp = bufp + index * stride +*/ + __pyx_t_5 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_dim, 0, ' ', 'd'); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_Out_of_bounds_on_buffer_access_a; + __pyx_t_4[1] = __pyx_t_5; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u__5; + __pyx_t_3 = __Pyx_PyUnicode_Join(__pyx_t_4, 3, 37 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_5) + 1, 127); + if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_IndexError))), __pyx_t_3, 0, 0); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __PYX_ERR(1, 918, __pyx_L1_error) + + /* "View.MemoryView":917 + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * + * if index >= shape: # <<<<<<<<<<<<<< + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * +*/ + } + + /* "View.MemoryView":920 + * raise IndexError, f"Out of bounds on buffer access (axis {dim})" + * + * resultp = bufp + index * stride # <<<<<<<<<<<<<< + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset +*/ + __pyx_v_resultp = (__pyx_v_bufp + (__pyx_v_index * __pyx_v_stride)); + + /* "View.MemoryView":921 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * +*/ + __pyx_t_2 = (__pyx_v_suboffset >= 0); + if (__pyx_t_2) { + + /* "View.MemoryView":922 + * resultp = bufp + index * stride + * if suboffset >= 0: + * resultp = ( resultp)[0] + suboffset # <<<<<<<<<<<<<< + * + * return resultp +*/ + __pyx_v_resultp = ((((char **)__pyx_v_resultp)[0]) + __pyx_v_suboffset); + + /* "View.MemoryView":921 + * + * resultp = bufp + index * stride + * if suboffset >= 0: # <<<<<<<<<<<<<< + * resultp = ( resultp)[0] + suboffset + * +*/ + } + + /* "View.MemoryView":924 + * resultp = ( resultp)[0] + suboffset + * + * return resultp # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = __pyx_v_resultp; + goto __pyx_L0; + + /* "View.MemoryView":896 + * + * + * @cname('__pyx_pybuffer_index') # <<<<<<<<<<<<<< + * cdef char *pybuffer_index(Py_buffer *view, char *bufp, Py_ssize_t index, + * Py_ssize_t dim) except NULL: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView.pybuffer_index", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":929 + * + * + * @cname('__pyx_memslice_transpose') # <<<<<<<<<<<<<< + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: + * cdef int ndim = memslice.memview.view.ndim +*/ + +static int __pyx_memslice_transpose(__Pyx_memviewslice *__pyx_v_memslice) { + int __pyx_v_ndim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + int __pyx_v_i; + int __pyx_v_j; + int __pyx_r; + int __pyx_t_1; + Py_ssize_t *__pyx_t_2; + long __pyx_t_3; + long __pyx_t_4; + Py_ssize_t __pyx_t_5; + Py_ssize_t __pyx_t_6; + int __pyx_t_7; + int __pyx_t_8; + int __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "View.MemoryView":931 + * @cname('__pyx_memslice_transpose') + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: + * cdef int ndim = memslice.memview.view.ndim # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t *shape = memslice.shape +*/ + __pyx_t_1 = __pyx_v_memslice->memview->view.ndim; + __pyx_v_ndim = __pyx_t_1; + + /* "View.MemoryView":933 + * cdef int ndim = memslice.memview.view.ndim + * + * cdef Py_ssize_t *shape = memslice.shape # <<<<<<<<<<<<<< + * cdef Py_ssize_t *strides = memslice.strides + * +*/ + __pyx_t_2 = __pyx_v_memslice->shape; + __pyx_v_shape = __pyx_t_2; + + /* "View.MemoryView":934 + * + * cdef Py_ssize_t *shape = memslice.shape + * cdef Py_ssize_t *strides = memslice.strides # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_2 = __pyx_v_memslice->strides; + __pyx_v_strides = __pyx_t_2; + + /* "View.MemoryView":938 + * + * cdef int i, j + * for i in range(ndim // 2): # <<<<<<<<<<<<<< + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] +*/ + __pyx_t_3 = __Pyx_div_long(__pyx_v_ndim, 2, 1); + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_1 = 0; __pyx_t_1 < __pyx_t_4; __pyx_t_1+=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":939 + * cdef int i, j + * for i in range(ndim // 2): + * j = ndim - 1 - i # <<<<<<<<<<<<<< + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] +*/ + __pyx_v_j = ((__pyx_v_ndim - 1) - __pyx_v_i); + + /* "View.MemoryView":940 + * for i in range(ndim // 2): + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] # <<<<<<<<<<<<<< + * shape[i], shape[j] = shape[j], shape[i] + * +*/ + __pyx_t_5 = (__pyx_v_strides[__pyx_v_j]); + __pyx_t_6 = (__pyx_v_strides[__pyx_v_i]); + (__pyx_v_strides[__pyx_v_i]) = __pyx_t_5; + (__pyx_v_strides[__pyx_v_j]) = __pyx_t_6; + + /* "View.MemoryView":941 + * j = ndim - 1 - i + * strides[i], strides[j] = strides[j], strides[i] + * shape[i], shape[j] = shape[j], shape[i] # <<<<<<<<<<<<<< + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: +*/ + __pyx_t_6 = (__pyx_v_shape[__pyx_v_j]); + __pyx_t_5 = (__pyx_v_shape[__pyx_v_i]); + (__pyx_v_shape[__pyx_v_i]) = __pyx_t_6; + (__pyx_v_shape[__pyx_v_j]) = __pyx_t_5; + + /* "View.MemoryView":943 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") + * +*/ + __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_i]) >= 0); + if (!__pyx_t_8) { + } else { + __pyx_t_7 = __pyx_t_8; + goto __pyx_L6_bool_binop_done; + } + __pyx_t_8 = ((__pyx_v_memslice->suboffsets[__pyx_v_j]) >= 0); + __pyx_t_7 = __pyx_t_8; + __pyx_L6_bool_binop_done:; + if (__pyx_t_7) { + + /* "View.MemoryView":944 + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") # <<<<<<<<<<<<<< + * + * return 0 +*/ + __pyx_t_9 = __pyx_memoryview_err(PyExc_ValueError, __pyx_mstate_global->__pyx_kp_u_Cannot_transpose_memoryview_with); if (unlikely(__pyx_t_9 == ((int)-1))) __PYX_ERR(1, 944, __pyx_L1_error) + + /* "View.MemoryView":943 + * shape[i], shape[j] = shape[j], shape[i] + * + * if memslice.suboffsets[i] >= 0 or memslice.suboffsets[j] >= 0: # <<<<<<<<<<<<<< + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") + * +*/ + } + } + + /* "View.MemoryView":946 + * _err(PyExc_ValueError, "Cannot transpose memoryview with indirect dimensions") + * + * return 0 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":929 + * + * + * @cname('__pyx_memslice_transpose') # <<<<<<<<<<<<<< + * cdef int transpose_memslice(__Pyx_memviewslice *memslice) except -1 nogil: + * cdef int ndim = memslice.memview.view.ndim +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("View.MemoryView.transpose_memslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":964 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) + * +*/ + +/* Python wrapper */ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self); /*proto*/ +static void __pyx_memoryviewslice___dealloc__(PyObject *__pyx_v_self) { + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__dealloc__ (wrapper)", 0); + __pyx_kwvalues = __Pyx_KwValues_VARARGS(__pyx_args, __pyx_nargs); + __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); +} + +static void __pyx_memoryviewslice___pyx_pf_15View_dot_MemoryView_16_memoryviewslice___dealloc__(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + + /* "View.MemoryView":965 + * + * def __dealloc__(self): + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) # <<<<<<<<<<<<<< + * + * cdef convert_item_to_object(self, char *itemp): +*/ + __PYX_XCLEAR_MEMVIEW((&__pyx_v_self->from_slice), 1); + + /* "View.MemoryView":964 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * def __dealloc__(self): # <<<<<<<<<<<<<< + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) + * +*/ + + /* function exit code */ +} + +/* "View.MemoryView":967 + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) +*/ + +static PyObject *__pyx_memoryviewslice_convert_item_to_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("convert_item_to_object", 0); + + /* "View.MemoryView":968 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: +*/ + __pyx_t_1 = (__pyx_v_self->to_object_func != NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":969 + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) # <<<<<<<<<<<<<< + * else: + * return memoryview.convert_item_to_object(self, itemp) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_v_self->to_object_func(__pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "View.MemoryView":968 + * + * cdef convert_item_to_object(self, char *itemp): + * if self.to_object_func != NULL: # <<<<<<<<<<<<<< + * return self.to_object_func(itemp) + * else: +*/ + } + + /* "View.MemoryView":971 + * return self.to_object_func(itemp) + * else: + * return memoryview.convert_item_to_object(self, itemp) # <<<<<<<<<<<<<< + * + * cdef assign_item_from_object(self, char *itemp, object value): +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_memoryview_convert_item_to_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + } + + /* "View.MemoryView":967 + * __PYX_XCLEAR_MEMVIEW(&self.from_slice, 1) + * + * cdef convert_item_to_object(self, char *itemp): # <<<<<<<<<<<<<< + * if self.to_object_func != NULL: + * return self.to_object_func(itemp) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.convert_item_to_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":973 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) +*/ + +static PyObject *__pyx_memoryviewslice_assign_item_from_object(struct __pyx_memoryviewslice_obj *__pyx_v_self, char *__pyx_v_itemp, PyObject *__pyx_v_value) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + int __pyx_t_2; + PyObject *__pyx_t_3 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("assign_item_from_object", 0); + + /* "View.MemoryView":974 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: +*/ + __pyx_t_1 = (__pyx_v_self->to_dtype_func != NULL); + if (__pyx_t_1) { + + /* "View.MemoryView":975 + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) # <<<<<<<<<<<<<< + * else: + * memoryview.assign_item_from_object(self, itemp, value) +*/ + __pyx_t_2 = __pyx_v_self->to_dtype_func(__pyx_v_itemp, __pyx_v_value); if (unlikely(__pyx_t_2 == ((int)0))) __PYX_ERR(1, 975, __pyx_L1_error) + + /* "View.MemoryView":974 + * + * cdef assign_item_from_object(self, char *itemp, object value): + * if self.to_dtype_func != NULL: # <<<<<<<<<<<<<< + * self.to_dtype_func(itemp, value) + * else: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":977 + * self.to_dtype_func(itemp, value) + * else: + * memoryview.assign_item_from_object(self, itemp, value) # <<<<<<<<<<<<<< + * + * cdef _get_base(self): +*/ + /*else*/ { + __pyx_t_3 = __pyx_memoryview_assign_item_from_object(((struct __pyx_memoryview_obj *)__pyx_v_self), __pyx_v_itemp, __pyx_v_value); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 977, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L3:; + + /* "View.MemoryView":973 + * return memoryview.convert_item_to_object(self, itemp) + * + * cdef assign_item_from_object(self, char *itemp, object value): # <<<<<<<<<<<<<< + * if self.to_dtype_func != NULL: + * self.to_dtype_func(itemp, value) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.assign_item_from_object", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":979 + * memoryview.assign_item_from_object(self, itemp, value) + * + * cdef _get_base(self): # <<<<<<<<<<<<<< + * return self.from_object + * +*/ + +static PyObject *__pyx_memoryviewslice__get_base(struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("_get_base", 0); + + /* "View.MemoryView":980 + * + * cdef _get_base(self): + * return self.from_object # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v_self->from_object); + __pyx_r = __pyx_v_self->from_object; + goto __pyx_L0; + + /* "View.MemoryView":979 + * memoryview.assign_item_from_object(self, itemp, value) + * + * cdef _get_base(self): # <<<<<<<<<<<<<< + * return self.from_object + * +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_1__reduce_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__reduce_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + if (unlikely(__pyx_nargs > 0)) { __Pyx_RaiseArgtupleInvalid("__reduce_cython__", 1, 0, 0, __pyx_nargs); return NULL; } + const Py_ssize_t __pyx_kwds_len = unlikely(__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len < 0)) return NULL; + if (unlikely(__pyx_kwds_len > 0)) {__Pyx_RejectKeywords("__reduce_cython__", __pyx_kwds); return NULL;} + __pyx_r = __pyx_pf___pyx_memoryviewslice___reduce_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self)); + + /* function exit code */ + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice___reduce_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__reduce_cython__", 0); + + /* "(tree fragment)":2 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 2, __pyx_L1_error) + + /* "(tree fragment)":1 + * def __reduce_cython__(self): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__reduce_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyObject *__pyx_pw___pyx_memoryviewslice_3__setstate_cython__(PyObject *__pyx_v_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + CYTHON_UNUSED PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[1] = {0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__setstate_cython__ (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 3, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__setstate_cython__", 0) < (0)) __PYX_ERR(1, 3, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 1; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, i); __PYX_ERR(1, 3, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 1)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 3, __pyx_L3_error) + } + __pyx_v___pyx_state = values[0]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__setstate_cython__", 1, 1, 1, __pyx_nargs); __PYX_ERR(1, 3, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + __pyx_r = __pyx_pf___pyx_memoryviewslice_2__setstate_cython__(((struct __pyx_memoryviewslice_obj *)__pyx_v_self), __pyx_v___pyx_state); + + /* function exit code */ + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf___pyx_memoryviewslice_2__setstate_cython__(CYTHON_UNUSED struct __pyx_memoryviewslice_obj *__pyx_v_self, CYTHON_UNUSED PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__setstate_cython__", 0); + + /* "(tree fragment)":4 + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" # <<<<<<<<<<<<<< +*/ + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_TypeError))), __pyx_mstate_global->__pyx_kp_u_no_default___reduce___due_to_non, 0, 0); + __PYX_ERR(1, 4, __pyx_L1_error) + + /* "(tree fragment)":3 + * def __reduce_cython__(self): + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" + * def __setstate_cython__(self, __pyx_state): # <<<<<<<<<<<<<< + * raise TypeError, "no default __reduce__ due to non-trivial __cinit__" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._memoryviewslice.__setstate_cython__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":999 + * pass # ignore failure, it's a minor issue + * + * @cname('__pyx_memoryview_fromslice') # <<<<<<<<<<<<<< + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, + * int ndim, +*/ + +static PyObject *__pyx_memoryview_fromslice(__Pyx_memviewslice __pyx_v_memviewslice, int __pyx_v_ndim, PyObject *(*__pyx_v_to_object_func)(char *), int (*__pyx_v_to_dtype_func)(char *, PyObject *), int __pyx_v_dtype_is_object) { + struct __pyx_memoryviewslice_obj *__pyx_v_result = 0; + Py_ssize_t __pyx_v_suboffset; + PyObject *__pyx_v_length = NULL; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + __Pyx_TypeInfo const *__pyx_t_4; + Py_buffer __pyx_t_5; + Py_ssize_t *__pyx_t_6; + Py_ssize_t *__pyx_t_7; + Py_ssize_t *__pyx_t_8; + Py_ssize_t __pyx_t_9; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_fromslice", 0); + + /* "View.MemoryView":1008 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * +*/ + __pyx_t_1 = (((PyObject *)__pyx_v_memviewslice.memview) == Py_None); + if (__pyx_t_1) { + + /* "View.MemoryView":1009 + * + * if memviewslice.memview == Py_None: + * return None # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "View.MemoryView":1008 + * cdef _memoryviewslice result + * + * if memviewslice.memview == Py_None: # <<<<<<<<<<<<<< + * return None + * +*/ + } + + /* "View.MemoryView":1014 + * + * + * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) # <<<<<<<<<<<<<< + * + * result.from_slice = memviewslice +*/ + __pyx_t_2 = __Pyx_PyBool_FromLong(__pyx_v_dtype_is_object); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1014, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1014, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, Py_None) != (0)) __PYX_ERR(1, 1014, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(1, 1014, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_t_2) != (0)) __PYX_ERR(1, 1014, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_2 = ((PyObject *)__pyx_tp_new__memoryviewslice(((PyTypeObject *)__pyx_mstate_global->__pyx_memoryviewslice_type), __pyx_t_3, NULL)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1014, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_2); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1016 + * result = _memoryviewslice.__new__(_memoryviewslice, None, 0, dtype_is_object) + * + * result.from_slice = memviewslice # <<<<<<<<<<<<<< + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * +*/ + __pyx_v_result->from_slice = __pyx_v_memviewslice; + + /* "View.MemoryView":1017 + * + * result.from_slice = memviewslice + * __PYX_INC_MEMVIEW(&memviewslice, 1) # <<<<<<<<<<<<<< + * + * result.from_object = ( memviewslice.memview)._get_base() +*/ + __PYX_INC_MEMVIEW((&__pyx_v_memviewslice), 1); + + /* "View.MemoryView":1019 + * __PYX_INC_MEMVIEW(&memviewslice, 1) + * + * result.from_object = ( memviewslice.memview)._get_base() # <<<<<<<<<<<<<< + * result.typeinfo = memviewslice.memview.typeinfo + * +*/ + __pyx_t_2 = ((struct __pyx_vtabstruct_memoryview *)((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->__pyx_vtab)->_get_base(((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1019, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_2); + __Pyx_GOTREF(__pyx_v_result->from_object); + __Pyx_DECREF(__pyx_v_result->from_object); + __pyx_v_result->from_object = __pyx_t_2; + __pyx_t_2 = 0; + + /* "View.MemoryView":1020 + * + * result.from_object = ( memviewslice.memview)._get_base() + * result.typeinfo = memviewslice.memview.typeinfo # <<<<<<<<<<<<<< + * + * result.view = memviewslice.memview.view +*/ + __pyx_t_4 = __pyx_v_memviewslice.memview->typeinfo; + __pyx_v_result->__pyx_base.typeinfo = __pyx_t_4; + + /* "View.MemoryView":1022 + * result.typeinfo = memviewslice.memview.typeinfo + * + * result.view = memviewslice.memview.view # <<<<<<<<<<<<<< + * result.view.buf = memviewslice.data + * result.view.ndim = ndim +*/ + __pyx_t_5 = __pyx_v_memviewslice.memview->view; + __pyx_v_result->__pyx_base.view = __pyx_t_5; + + /* "View.MemoryView":1023 + * + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data # <<<<<<<<<<<<<< + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None +*/ + __pyx_v_result->__pyx_base.view.buf = ((void *)__pyx_v_memviewslice.data); + + /* "View.MemoryView":1024 + * result.view = memviewslice.memview.view + * result.view.buf = memviewslice.data + * result.view.ndim = ndim # <<<<<<<<<<<<<< + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) +*/ + __pyx_v_result->__pyx_base.view.ndim = __pyx_v_ndim; + + /* "View.MemoryView":1025 + * result.view.buf = memviewslice.data + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None # <<<<<<<<<<<<<< + * Py_INCREF(Py_None) + * +*/ + ((Py_buffer *)(&__pyx_v_result->__pyx_base.view))->obj = Py_None; + + /* "View.MemoryView":1026 + * result.view.ndim = ndim + * (<__pyx_buffer *> &result.view).obj = Py_None + * Py_INCREF(Py_None) # <<<<<<<<<<<<<< + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: +*/ + Py_INCREF(Py_None); + + /* "View.MemoryView":1028 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: +*/ + __pyx_t_1 = ((((struct __pyx_memoryview_obj *)__pyx_v_memviewslice.memview)->flags & PyBUF_WRITABLE) != 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1029 + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: + * result.flags = PyBUF_RECORDS # <<<<<<<<<<<<<< + * else: + * result.flags = PyBUF_RECORDS_RO +*/ + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS; + + /* "View.MemoryView":1028 + * Py_INCREF(Py_None) + * + * if (memviewslice.memview).flags & PyBUF_WRITABLE: # <<<<<<<<<<<<<< + * result.flags = PyBUF_RECORDS + * else: +*/ + goto __pyx_L4; + } + + /* "View.MemoryView":1031 + * result.flags = PyBUF_RECORDS + * else: + * result.flags = PyBUF_RECORDS_RO # <<<<<<<<<<<<<< + * + * result.view.shape = result.from_slice.shape +*/ + /*else*/ { + __pyx_v_result->__pyx_base.flags = PyBUF_RECORDS_RO; + } + __pyx_L4:; + + /* "View.MemoryView":1033 + * result.flags = PyBUF_RECORDS_RO + * + * result.view.shape = result.from_slice.shape # <<<<<<<<<<<<<< + * result.view.strides = result.from_slice.strides + * +*/ + __pyx_v_result->__pyx_base.view.shape = ((Py_ssize_t *)__pyx_v_result->from_slice.shape); + + /* "View.MemoryView":1034 + * + * result.view.shape = result.from_slice.shape + * result.view.strides = result.from_slice.strides # <<<<<<<<<<<<<< + * + * +*/ + __pyx_v_result->__pyx_base.view.strides = ((Py_ssize_t *)__pyx_v_result->from_slice.strides); + + /* "View.MemoryView":1037 + * + * + * result.view.suboffsets = NULL # <<<<<<<<<<<<<< + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: +*/ + __pyx_v_result->__pyx_base.view.suboffsets = NULL; + + /* "View.MemoryView":1038 + * + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: # <<<<<<<<<<<<<< + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets +*/ + __pyx_t_7 = (__pyx_v_result->from_slice.suboffsets + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->from_slice.suboffsets; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_v_suboffset = (__pyx_t_6[0]); + + /* "View.MemoryView":1039 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break +*/ + __pyx_t_1 = (__pyx_v_suboffset >= 0); + if (__pyx_t_1) { + + /* "View.MemoryView":1040 + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets # <<<<<<<<<<<<<< + * break + * +*/ + __pyx_v_result->__pyx_base.view.suboffsets = ((Py_ssize_t *)__pyx_v_result->from_slice.suboffsets); + + /* "View.MemoryView":1041 + * if suboffset >= 0: + * result.view.suboffsets = result.from_slice.suboffsets + * break # <<<<<<<<<<<<<< + * + * result.view.len = result.view.itemsize +*/ + goto __pyx_L6_break; + + /* "View.MemoryView":1039 + * result.view.suboffsets = NULL + * for suboffset in result.from_slice.suboffsets[:ndim]: + * if suboffset >= 0: # <<<<<<<<<<<<<< + * result.view.suboffsets = result.from_slice.suboffsets + * break +*/ + } + } + __pyx_L6_break:; + + /* "View.MemoryView":1043 + * break + * + * result.view.len = result.view.itemsize # <<<<<<<<<<<<<< + * for length in result.view.shape[:ndim]: + * result.view.len *= length +*/ + __pyx_t_9 = __pyx_v_result->__pyx_base.view.itemsize; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + + /* "View.MemoryView":1044 + * + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: # <<<<<<<<<<<<<< + * result.view.len *= length + * +*/ + __pyx_t_7 = (__pyx_v_result->__pyx_base.view.shape + __pyx_v_ndim); + for (__pyx_t_8 = __pyx_v_result->__pyx_base.view.shape; __pyx_t_8 < __pyx_t_7; __pyx_t_8++) { + __pyx_t_6 = __pyx_t_8; + __pyx_t_2 = PyLong_FromSsize_t((__pyx_t_6[0])); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1044, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_XDECREF_SET(__pyx_v_length, __pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1045 + * result.view.len = result.view.itemsize + * for length in result.view.shape[:ndim]: + * result.view.len *= length # <<<<<<<<<<<<<< + * + * result.to_object_func = to_object_func +*/ + __pyx_t_2 = PyLong_FromSsize_t(__pyx_v_result->__pyx_base.view.len); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyNumber_InPlaceMultiply(__pyx_t_2, __pyx_v_length); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_9 = __Pyx_PyIndex_AsSsize_t(__pyx_t_3); if (unlikely((__pyx_t_9 == (Py_ssize_t)-1) && PyErr_Occurred())) __PYX_ERR(1, 1045, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_v_result->__pyx_base.view.len = __pyx_t_9; + } + + /* "View.MemoryView":1047 + * result.view.len *= length + * + * result.to_object_func = to_object_func # <<<<<<<<<<<<<< + * result.to_dtype_func = to_dtype_func + * +*/ + __pyx_v_result->to_object_func = __pyx_v_to_object_func; + + /* "View.MemoryView":1048 + * + * result.to_object_func = to_object_func + * result.to_dtype_func = to_dtype_func # <<<<<<<<<<<<<< + * + * return result +*/ + __pyx_v_result->to_dtype_func = __pyx_v_to_dtype_func; + + /* "View.MemoryView":1050 + * result.to_dtype_func = to_dtype_func + * + * return result # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF((PyObject *)__pyx_v_result); + __pyx_r = ((PyObject *)__pyx_v_result); + goto __pyx_L0; + + /* "View.MemoryView":999 + * pass # ignore failure, it's a minor issue + * + * @cname('__pyx_memoryview_fromslice') # <<<<<<<<<<<<<< + * cdef memoryview_fromslice(__Pyx_memviewslice memviewslice, + * int ndim, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.memoryview_fromslice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_result); + __Pyx_XDECREF(__pyx_v_length); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1052 + * return result + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, + * __Pyx_memviewslice *mslice) except NULL: +*/ + +static __Pyx_memviewslice *__pyx_memoryview_get_slice_from_memoryview(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_mslice) { + struct __pyx_memoryviewslice_obj *__pyx_v_obj = 0; + __Pyx_memviewslice *__pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("get_slice_from_memview", 0); + + /* "View.MemoryView":1056 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice +*/ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_mstate_global->__pyx_memoryviewslice_type); + if (__pyx_t_1) { + + /* "View.MemoryView":1057 + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): + * obj = memview # <<<<<<<<<<<<<< + * return &obj.from_slice + * else: +*/ + __pyx_t_2 = ((PyObject *)__pyx_v_memview); + __Pyx_INCREF(__pyx_t_2); + if (!(likely(((__pyx_t_2) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_2, __pyx_mstate_global->__pyx_memoryviewslice_type))))) __PYX_ERR(1, 1057, __pyx_L1_error) + __pyx_v_obj = ((struct __pyx_memoryviewslice_obj *)__pyx_t_2); + __pyx_t_2 = 0; + + /* "View.MemoryView":1058 + * if isinstance(memview, _memoryviewslice): + * obj = memview + * return &obj.from_slice # <<<<<<<<<<<<<< + * else: + * slice_copy(memview, mslice) +*/ + __pyx_r = (&__pyx_v_obj->from_slice); + goto __pyx_L0; + + /* "View.MemoryView":1056 + * __Pyx_memviewslice *mslice) except NULL: + * cdef _memoryviewslice obj + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * obj = memview + * return &obj.from_slice +*/ + } + + /* "View.MemoryView":1060 + * return &obj.from_slice + * else: + * slice_copy(memview, mslice) # <<<<<<<<<<<<<< + * return mslice + * +*/ + /*else*/ { + __pyx_memoryview_slice_copy(__pyx_v_memview, __pyx_v_mslice); + + /* "View.MemoryView":1061 + * else: + * slice_copy(memview, mslice) + * return mslice # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_slice_copy') +*/ + __pyx_r = __pyx_v_mslice; + goto __pyx_L0; + } + + /* "View.MemoryView":1052 + * return result + * + * @cname('__pyx_memoryview_get_slice_from_memoryview') # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice *get_slice_from_memview(memoryview memview, + * __Pyx_memviewslice *mslice) except NULL: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView.get_slice_from_memview", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF((PyObject *)__pyx_v_obj); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1063 + * return mslice + * + * @cname('__pyx_memoryview_slice_copy') # <<<<<<<<<<<<<< + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: + * cdef int dim +*/ + +static void __pyx_memoryview_slice_copy(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_dst) { + int __pyx_v_dim; + Py_ssize_t *__pyx_v_shape; + Py_ssize_t *__pyx_v_strides; + Py_ssize_t *__pyx_v_suboffsets; + Py_ssize_t *__pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + Py_ssize_t __pyx_t_5; + int __pyx_t_6; + + /* "View.MemoryView":1068 + * cdef (Py_ssize_t*) shape, strides, suboffsets + * + * shape = memview.view.shape # <<<<<<<<<<<<<< + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets +*/ + __pyx_t_1 = __pyx_v_memview->view.shape; + __pyx_v_shape = __pyx_t_1; + + /* "View.MemoryView":1069 + * + * shape = memview.view.shape + * strides = memview.view.strides # <<<<<<<<<<<<<< + * suboffsets = memview.view.suboffsets + * +*/ + __pyx_t_1 = __pyx_v_memview->view.strides; + __pyx_v_strides = __pyx_t_1; + + /* "View.MemoryView":1070 + * shape = memview.view.shape + * strides = memview.view.strides + * suboffsets = memview.view.suboffsets # <<<<<<<<<<<<<< + * + * dst.memview = <__pyx_memoryview *> memview +*/ + __pyx_t_1 = __pyx_v_memview->view.suboffsets; + __pyx_v_suboffsets = __pyx_t_1; + + /* "View.MemoryView":1072 + * suboffsets = memview.view.suboffsets + * + * dst.memview = <__pyx_memoryview *> memview # <<<<<<<<<<<<<< + * dst.data = memview.view.buf + * +*/ + __pyx_v_dst->memview = ((struct __pyx_memoryview_obj *)__pyx_v_memview); + + /* "View.MemoryView":1073 + * + * dst.memview = <__pyx_memoryview *> memview + * dst.data = memview.view.buf # <<<<<<<<<<<<<< + * + * for dim in range(memview.view.ndim): +*/ + __pyx_v_dst->data = ((char *)__pyx_v_memview->view.buf); + + /* "View.MemoryView":1075 + * dst.data = memview.view.buf + * + * for dim in range(memview.view.ndim): # <<<<<<<<<<<<<< + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] +*/ + __pyx_t_2 = __pyx_v_memview->view.ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_dim = __pyx_t_4; + + /* "View.MemoryView":1076 + * + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] # <<<<<<<<<<<<<< + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 +*/ + (__pyx_v_dst->shape[__pyx_v_dim]) = (__pyx_v_shape[__pyx_v_dim]); + + /* "View.MemoryView":1077 + * for dim in range(memview.view.ndim): + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] # <<<<<<<<<<<<<< + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * +*/ + (__pyx_v_dst->strides[__pyx_v_dim]) = (__pyx_v_strides[__pyx_v_dim]); + + /* "View.MemoryView":1078 + * dst.shape[dim] = shape[dim] + * dst.strides[dim] = strides[dim] + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object') +*/ + __pyx_t_6 = (__pyx_v_suboffsets != 0); + if (__pyx_t_6) { + __pyx_t_5 = (__pyx_v_suboffsets[__pyx_v_dim]); + } else { + __pyx_t_5 = -1L; + } + (__pyx_v_dst->suboffsets[__pyx_v_dim]) = __pyx_t_5; + } + + /* "View.MemoryView":1063 + * return mslice + * + * @cname('__pyx_memoryview_slice_copy') # <<<<<<<<<<<<<< + * cdef void slice_copy(memoryview memview, __Pyx_memviewslice *dst) noexcept: + * cdef int dim +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1080 + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + * @cname('__pyx_memoryview_copy_object') # <<<<<<<<<<<<<< + * cdef memoryview_copy(memoryview memview): + * "Create a new memoryview object" +*/ + +static PyObject *__pyx_memoryview_copy_object(struct __pyx_memoryview_obj *__pyx_v_memview) { + __Pyx_memviewslice __pyx_v_memviewslice; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy", 0); + + /* "View.MemoryView":1084 + * "Create a new memoryview object" + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) # <<<<<<<<<<<<<< + * return memoryview_copy_from_slice(memview, &memviewslice) + * +*/ + __pyx_memoryview_slice_copy(__pyx_v_memview, (&__pyx_v_memviewslice)); + + /* "View.MemoryView":1085 + * cdef __Pyx_memviewslice memviewslice + * slice_copy(memview, &memviewslice) + * return memoryview_copy_from_slice(memview, &memviewslice) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_object_from_slice') +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __pyx_memoryview_copy_object_from_slice(__pyx_v_memview, (&__pyx_v_memviewslice)); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1085, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1080 + * dst.suboffsets[dim] = suboffsets[dim] if suboffsets else -1 + * + * @cname('__pyx_memoryview_copy_object') # <<<<<<<<<<<<<< + * cdef memoryview_copy(memoryview memview): + * "Create a new memoryview object" +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1087 + * return memoryview_copy_from_slice(memview, &memviewslice) + * + * @cname('__pyx_memoryview_copy_object_from_slice') # <<<<<<<<<<<<<< + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): + * """ +*/ + +static PyObject *__pyx_memoryview_copy_object_from_slice(struct __pyx_memoryview_obj *__pyx_v_memview, __Pyx_memviewslice *__pyx_v_memviewslice) { + PyObject *(*__pyx_v_to_object_func)(char *); + int (*__pyx_v_to_dtype_func)(char *, PyObject *); + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *(*__pyx_t_2)(char *); + int (*__pyx_t_3)(char *, PyObject *); + PyObject *__pyx_t_4 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("memoryview_copy_from_slice", 0); + + /* "View.MemoryView":1095 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func +*/ + __pyx_t_1 = __Pyx_TypeCheck(((PyObject *)__pyx_v_memview), __pyx_mstate_global->__pyx_memoryviewslice_type); + if (__pyx_t_1) { + + /* "View.MemoryView":1096 + * + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func # <<<<<<<<<<<<<< + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: +*/ + __pyx_t_2 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_object_func; + __pyx_v_to_object_func = __pyx_t_2; + + /* "View.MemoryView":1097 + * if isinstance(memview, _memoryviewslice): + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func # <<<<<<<<<<<<<< + * else: + * to_object_func = NULL +*/ + __pyx_t_3 = ((struct __pyx_memoryviewslice_obj *)__pyx_v_memview)->to_dtype_func; + __pyx_v_to_dtype_func = __pyx_t_3; + + /* "View.MemoryView":1095 + * cdef int (*to_dtype_func)(char *, object) except 0 + * + * if isinstance(memview, _memoryviewslice): # <<<<<<<<<<<<<< + * to_object_func = (<_memoryviewslice> memview).to_object_func + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":1099 + * to_dtype_func = (<_memoryviewslice> memview).to_dtype_func + * else: + * to_object_func = NULL # <<<<<<<<<<<<<< + * to_dtype_func = NULL + * +*/ + /*else*/ { + __pyx_v_to_object_func = NULL; + + /* "View.MemoryView":1100 + * else: + * to_object_func = NULL + * to_dtype_func = NULL # <<<<<<<<<<<<<< + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, +*/ + __pyx_v_to_dtype_func = NULL; + } + __pyx_L3:; + + /* "View.MemoryView":1102 + * to_dtype_func = NULL + * + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, # <<<<<<<<<<<<<< + * to_object_func, to_dtype_func, + * memview.dtype_is_object) +*/ + __Pyx_XDECREF(__pyx_r); + + /* "View.MemoryView":1104 + * return memoryview_fromslice(memviewslice[0], memview.view.ndim, + * to_object_func, to_dtype_func, + * memview.dtype_is_object) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_4 = __pyx_memoryview_fromslice((__pyx_v_memviewslice[0]), __pyx_v_memview->view.ndim, __pyx_v_to_object_func, __pyx_v_to_dtype_func, __pyx_v_memview->dtype_is_object); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 1102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "View.MemoryView":1087 + * return memoryview_copy_from_slice(memview, &memviewslice) + * + * @cname('__pyx_memoryview_copy_object_from_slice') # <<<<<<<<<<<<<< + * cdef memoryview_copy_from_slice(memoryview memview, __Pyx_memviewslice *memviewslice): + * """ +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_from_slice", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "View.MemoryView":1110 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< + * return -arg if arg < 0 else arg + * +*/ + +static Py_ssize_t abs_py_ssize_t(Py_ssize_t __pyx_v_arg) { + Py_ssize_t __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + + /* "View.MemoryView":1111 + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: + * return -arg if arg < 0 else arg # <<<<<<<<<<<<<< + * + * @cname('__pyx_get_best_slice_order') +*/ + __pyx_t_2 = (__pyx_v_arg < 0); + if (__pyx_t_2) { + __pyx_t_1 = (-__pyx_v_arg); + } else { + __pyx_t_1 = __pyx_v_arg; + } + __pyx_r = __pyx_t_1; + goto __pyx_L0; + + /* "View.MemoryView":1110 + * + * + * cdef Py_ssize_t abs_py_ssize_t(Py_ssize_t arg) noexcept nogil: # <<<<<<<<<<<<<< + * return -arg if arg < 0 else arg + * +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1113 + * return -arg if arg < 0 else arg + * + * @cname('__pyx_get_best_slice_order') # <<<<<<<<<<<<<< + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: + * """ +*/ + +static char __pyx_get_best_slice_order(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim) { + int __pyx_v_i; + Py_ssize_t __pyx_v_c_stride; + Py_ssize_t __pyx_v_f_stride; + char __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1119 + * """ + * cdef int i + * cdef Py_ssize_t c_stride = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t f_stride = 0 + * +*/ + __pyx_v_c_stride = 0; + + /* "View.MemoryView":1120 + * cdef int i + * cdef Py_ssize_t c_stride = 0 + * cdef Py_ssize_t f_stride = 0 # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): +*/ + __pyx_v_f_stride = 0; + + /* "View.MemoryView":1122 + * cdef Py_ssize_t f_stride = 0 + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] +*/ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1123 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break +*/ + __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); + if (__pyx_t_2) { + + /* "View.MemoryView":1124 + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * +*/ + __pyx_v_c_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1125 + * if mslice.shape[i] > 1: + * c_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * for i in range(ndim): +*/ + goto __pyx_L4_break; + + /* "View.MemoryView":1123 + * + * for i in range(ndim - 1, -1, -1): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * c_stride = mslice.strides[i] + * break +*/ + } + } + __pyx_L4_break:; + + /* "View.MemoryView":1127 + * break + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] +*/ + __pyx_t_1 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_1; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1128 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break +*/ + __pyx_t_2 = ((__pyx_v_mslice->shape[__pyx_v_i]) > 1); + if (__pyx_t_2) { + + /* "View.MemoryView":1129 + * for i in range(ndim): + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] # <<<<<<<<<<<<<< + * break + * +*/ + __pyx_v_f_stride = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1130 + * if mslice.shape[i] > 1: + * f_stride = mslice.strides[i] + * break # <<<<<<<<<<<<<< + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): +*/ + goto __pyx_L7_break; + + /* "View.MemoryView":1128 + * + * for i in range(ndim): + * if mslice.shape[i] > 1: # <<<<<<<<<<<<<< + * f_stride = mslice.strides[i] + * break +*/ + } + } + __pyx_L7_break:; + + /* "View.MemoryView":1132 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: +*/ + __pyx_t_2 = (abs_py_ssize_t(__pyx_v_c_stride) <= abs_py_ssize_t(__pyx_v_f_stride)); + if (__pyx_t_2) { + + /* "View.MemoryView":1133 + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): + * return 'C' # <<<<<<<<<<<<<< + * else: + * return 'F' +*/ + __pyx_r = 'C'; + goto __pyx_L0; + + /* "View.MemoryView":1132 + * break + * + * if abs_py_ssize_t(c_stride) <= abs_py_ssize_t(f_stride): # <<<<<<<<<<<<<< + * return 'C' + * else: +*/ + } + + /* "View.MemoryView":1135 + * return 'C' + * else: + * return 'F' # <<<<<<<<<<<<<< + * + * @cython.cdivision(True) +*/ + /*else*/ { + __pyx_r = 'F'; + goto __pyx_L0; + } + + /* "View.MemoryView":1113 + * return -arg if arg < 0 else arg + * + * @cname('__pyx_get_best_slice_order') # <<<<<<<<<<<<<< + * cdef char get_best_order(__Pyx_memviewslice *mslice, int ndim) noexcept nogil: + * """ +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1137 + * return 'F' + * + * @cython.cdivision(True) # <<<<<<<<<<<<<< + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, + * char *dst_data, Py_ssize_t *dst_strides, +*/ + +static void _copy_strided_to_strided(char *__pyx_v_src_data, Py_ssize_t *__pyx_v_src_strides, char *__pyx_v_dst_data, Py_ssize_t *__pyx_v_dst_strides, Py_ssize_t *__pyx_v_src_shape, Py_ssize_t *__pyx_v_dst_shape, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + CYTHON_UNUSED Py_ssize_t __pyx_v_src_extent; + Py_ssize_t __pyx_v_dst_extent; + Py_ssize_t __pyx_v_src_stride; + Py_ssize_t __pyx_v_dst_stride; + int __pyx_t_1; + int __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + Py_ssize_t __pyx_t_5; + + /* "View.MemoryView":1145 + * + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] +*/ + __pyx_v_src_extent = (__pyx_v_src_shape[0]); + + /* "View.MemoryView":1146 + * cdef Py_ssize_t i + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] +*/ + __pyx_v_dst_extent = (__pyx_v_dst_shape[0]); + + /* "View.MemoryView":1147 + * cdef Py_ssize_t src_extent = src_shape[0] + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t dst_stride = dst_strides[0] + * +*/ + __pyx_v_src_stride = (__pyx_v_src_strides[0]); + + /* "View.MemoryView":1148 + * cdef Py_ssize_t dst_extent = dst_shape[0] + * cdef Py_ssize_t src_stride = src_strides[0] + * cdef Py_ssize_t dst_stride = dst_strides[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: +*/ + __pyx_v_dst_stride = (__pyx_v_dst_strides[0]); + + /* "View.MemoryView":1150 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): +*/ + __pyx_t_1 = (__pyx_v_ndim == 1); + if (__pyx_t_1) { + + /* "View.MemoryView":1151 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) +*/ + __pyx_t_2 = (__pyx_v_src_stride > 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + __pyx_t_2 = (__pyx_v_dst_stride > 0); + if (__pyx_t_2) { + } else { + __pyx_t_1 = __pyx_t_2; + goto __pyx_L5_bool_binop_done; + } + + /* "View.MemoryView":1152 + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: +*/ + __pyx_t_2 = (((size_t)__pyx_v_src_stride) == __pyx_v_itemsize); + if (__pyx_t_2) { + __pyx_t_2 = (__pyx_v_itemsize == ((size_t)__pyx_v_dst_stride)); + } + __pyx_t_1 = __pyx_t_2; + __pyx_L5_bool_binop_done:; + + /* "View.MemoryView":1151 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) +*/ + if (__pyx_t_1) { + + /* "View.MemoryView":1153 + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): +*/ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, (__pyx_v_itemsize * __pyx_v_dst_extent))); + + /* "View.MemoryView":1151 + * + * if ndim == 1: + * if (src_stride > 0 and dst_stride > 0 and # <<<<<<<<<<<<<< + * src_stride == itemsize == dst_stride): + * memcpy(dst_data, src_data, itemsize * dst_extent) +*/ + goto __pyx_L4; + } + + /* "View.MemoryView":1155 + * memcpy(dst_data, src_data, itemsize * dst_extent) + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride +*/ + /*else*/ { + __pyx_t_3 = __pyx_v_dst_extent; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":1156 + * else: + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) # <<<<<<<<<<<<<< + * src_data += src_stride + * dst_data += dst_stride +*/ + (void)(memcpy(__pyx_v_dst_data, __pyx_v_src_data, __pyx_v_itemsize)); + + /* "View.MemoryView":1157 + * for i in range(dst_extent): + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * else: +*/ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1158 + * memcpy(dst_data, src_data, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * else: + * for i in range(dst_extent): +*/ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L4:; + + /* "View.MemoryView":1150 + * cdef Py_ssize_t dst_stride = dst_strides[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * if (src_stride > 0 and dst_stride > 0 and + * src_stride == itemsize == dst_stride): +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":1160 + * dst_data += dst_stride + * else: + * for i in range(dst_extent): # <<<<<<<<<<<<<< + * _copy_strided_to_strided(src_data, src_strides + 1, + * dst_data, dst_strides + 1, +*/ + /*else*/ { + __pyx_t_3 = __pyx_v_dst_extent; + __pyx_t_4 = __pyx_t_3; + for (__pyx_t_5 = 0; __pyx_t_5 < __pyx_t_4; __pyx_t_5+=1) { + __pyx_v_i = __pyx_t_5; + + /* "View.MemoryView":1161 + * else: + * for i in range(dst_extent): + * _copy_strided_to_strided(src_data, src_strides + 1, # <<<<<<<<<<<<<< + * dst_data, dst_strides + 1, + * src_shape + 1, dst_shape + 1, +*/ + _copy_strided_to_strided(__pyx_v_src_data, (__pyx_v_src_strides + 1), __pyx_v_dst_data, (__pyx_v_dst_strides + 1), (__pyx_v_src_shape + 1), (__pyx_v_dst_shape + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize); + + /* "View.MemoryView":1165 + * src_shape + 1, dst_shape + 1, + * ndim - 1, itemsize) + * src_data += src_stride # <<<<<<<<<<<<<< + * dst_data += dst_stride + * +*/ + __pyx_v_src_data = (__pyx_v_src_data + __pyx_v_src_stride); + + /* "View.MemoryView":1166 + * ndim - 1, itemsize) + * src_data += src_stride + * dst_data += dst_stride # <<<<<<<<<<<<<< + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, +*/ + __pyx_v_dst_data = (__pyx_v_dst_data + __pyx_v_dst_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1137 + * return 'F' + * + * @cython.cdivision(True) # <<<<<<<<<<<<<< + * cdef void _copy_strided_to_strided(char *src_data, Py_ssize_t *src_strides, + * char *dst_data, Py_ssize_t *dst_strides, +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1168 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) noexcept nogil: +*/ + +static void copy_strided_to_strided(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize) { + + /* "View.MemoryView":1171 + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) noexcept nogil: + * _copy_strided_to_strided(src.data, src.strides, dst.data, dst.strides, # <<<<<<<<<<<<<< + * src.shape, dst.shape, ndim, itemsize) + * +*/ + _copy_strided_to_strided(__pyx_v_src->data, __pyx_v_src->strides, __pyx_v_dst->data, __pyx_v_dst->strides, __pyx_v_src->shape, __pyx_v_dst->shape, __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1168 + * dst_data += dst_stride + * + * cdef void copy_strided_to_strided(__Pyx_memviewslice *src, # <<<<<<<<<<<<<< + * __Pyx_memviewslice *dst, + * int ndim, size_t itemsize) noexcept nogil: +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1174 + * src.shape, dst.shape, ndim, itemsize) + * + * @cname('__pyx_memoryview_slice_get_size') # <<<<<<<<<<<<<< + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: + * "Return the size of the memory occupied by the slice in number of bytes" +*/ + +static Py_ssize_t __pyx_memoryview_slice_get_size(__Pyx_memviewslice *__pyx_v_src, int __pyx_v_ndim) { + Py_ssize_t __pyx_v_shape; + Py_ssize_t __pyx_v_size; + Py_ssize_t __pyx_r; + Py_ssize_t __pyx_t_1; + Py_ssize_t *__pyx_t_2; + Py_ssize_t *__pyx_t_3; + Py_ssize_t *__pyx_t_4; + + /* "View.MemoryView":1177 + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: + * "Return the size of the memory occupied by the slice in number of bytes" + * cdef Py_ssize_t shape, size = src.memview.view.itemsize # <<<<<<<<<<<<<< + * + * for shape in src.shape[:ndim]: +*/ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_size = __pyx_t_1; + + /* "View.MemoryView":1179 + * cdef Py_ssize_t shape, size = src.memview.view.itemsize + * + * for shape in src.shape[:ndim]: # <<<<<<<<<<<<<< + * size *= shape + * +*/ + __pyx_t_3 = (__pyx_v_src->shape + __pyx_v_ndim); + for (__pyx_t_4 = __pyx_v_src->shape; __pyx_t_4 < __pyx_t_3; __pyx_t_4++) { + __pyx_t_2 = __pyx_t_4; + __pyx_v_shape = (__pyx_t_2[0]); + + /* "View.MemoryView":1180 + * + * for shape in src.shape[:ndim]: + * size *= shape # <<<<<<<<<<<<<< + * + * return size +*/ + __pyx_v_size = (__pyx_v_size * __pyx_v_shape); + } + + /* "View.MemoryView":1182 + * size *= shape + * + * return size # <<<<<<<<<<<<<< + * + * @cname('__pyx_fill_contig_strides_array') +*/ + __pyx_r = __pyx_v_size; + goto __pyx_L0; + + /* "View.MemoryView":1174 + * src.shape, dst.shape, ndim, itemsize) + * + * @cname('__pyx_memoryview_slice_get_size') # <<<<<<<<<<<<<< + * cdef Py_ssize_t slice_get_size(__Pyx_memviewslice *src, int ndim) noexcept nogil: + * "Return the size of the memory occupied by the slice in number of bytes" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1184 + * return size + * + * @cname('__pyx_fill_contig_strides_array') # <<<<<<<<<<<<<< + * cdef Py_ssize_t fill_contig_strides_array( + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, +*/ + +static Py_ssize_t __pyx_fill_contig_strides_array(Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, Py_ssize_t __pyx_v_stride, int __pyx_v_ndim, char __pyx_v_order) { + int __pyx_v_idx; + Py_ssize_t __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1194 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride +*/ + __pyx_t_1 = (__pyx_v_order == 'F'); + if (__pyx_t_1) { + + /* "View.MemoryView":1195 + * + * if order == 'F': + * for idx in range(ndim): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] +*/ + __pyx_t_2 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_idx = __pyx_t_4; + + /* "View.MemoryView":1196 + * if order == 'F': + * for idx in range(ndim): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * else: +*/ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1197 + * for idx in range(ndim): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * else: + * for idx in range(ndim - 1, -1, -1): +*/ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + + /* "View.MemoryView":1194 + * cdef int idx + * + * if order == 'F': # <<<<<<<<<<<<<< + * for idx in range(ndim): + * strides[idx] = stride +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":1199 + * stride *= shape[idx] + * else: + * for idx in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * strides[idx] = stride + * stride *= shape[idx] +*/ + /*else*/ { + for (__pyx_t_2 = (__pyx_v_ndim - 1); __pyx_t_2 > -1; __pyx_t_2-=1) { + __pyx_v_idx = __pyx_t_2; + + /* "View.MemoryView":1200 + * else: + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride # <<<<<<<<<<<<<< + * stride *= shape[idx] + * +*/ + (__pyx_v_strides[__pyx_v_idx]) = __pyx_v_stride; + + /* "View.MemoryView":1201 + * for idx in range(ndim - 1, -1, -1): + * strides[idx] = stride + * stride *= shape[idx] # <<<<<<<<<<<<<< + * + * return stride +*/ + __pyx_v_stride = (__pyx_v_stride * (__pyx_v_shape[__pyx_v_idx])); + } + } + __pyx_L3:; + + /* "View.MemoryView":1203 + * stride *= shape[idx] + * + * return stride # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_copy_data_to_temp') +*/ + __pyx_r = __pyx_v_stride; + goto __pyx_L0; + + /* "View.MemoryView":1184 + * return size + * + * @cname('__pyx_fill_contig_strides_array') # <<<<<<<<<<<<<< + * cdef Py_ssize_t fill_contig_strides_array( + * Py_ssize_t *shape, Py_ssize_t *strides, Py_ssize_t stride, +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1205 + * return stride + * + * @cname('__pyx_memoryview_copy_data_to_temp') # <<<<<<<<<<<<<< + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, + * __Pyx_memviewslice *tmpslice, +*/ + +static void *__pyx_memoryview_copy_data_to_temp(__Pyx_memviewslice *__pyx_v_src, __Pyx_memviewslice *__pyx_v_tmpslice, char __pyx_v_order, int __pyx_v_ndim) { + int __pyx_v_i; + void *__pyx_v_result; + size_t __pyx_v_itemsize; + size_t __pyx_v_size; + void *__pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + struct __pyx_memoryview_obj *__pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "View.MemoryView":1217 + * cdef void *result + * + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef size_t size = slice_get_size(src, ndim) + * +*/ + __pyx_t_1 = __pyx_v_src->memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1218 + * + * cdef size_t itemsize = src.memview.view.itemsize + * cdef size_t size = slice_get_size(src, ndim) # <<<<<<<<<<<<<< + * + * result = malloc(size) +*/ + __pyx_v_size = __pyx_memoryview_slice_get_size(__pyx_v_src, __pyx_v_ndim); + + /* "View.MemoryView":1220 + * cdef size_t size = slice_get_size(src, ndim) + * + * result = malloc(size) # <<<<<<<<<<<<<< + * if not result: + * _err_no_memory() +*/ + __pyx_v_result = malloc(__pyx_v_size); + + /* "View.MemoryView":1221 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err_no_memory() + * +*/ + __pyx_t_2 = (!(__pyx_v_result != 0)); + if (__pyx_t_2) { + + /* "View.MemoryView":1222 + * result = malloc(size) + * if not result: + * _err_no_memory() # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_3 = __pyx_memoryview_err_no_memory(); if (unlikely(__pyx_t_3 == ((int)-1))) __PYX_ERR(1, 1222, __pyx_L1_error) + + /* "View.MemoryView":1221 + * + * result = malloc(size) + * if not result: # <<<<<<<<<<<<<< + * _err_no_memory() + * +*/ + } + + /* "View.MemoryView":1225 + * + * + * tmpslice.data = result # <<<<<<<<<<<<<< + * tmpslice.memview = src.memview + * for i in range(ndim): +*/ + __pyx_v_tmpslice->data = ((char *)__pyx_v_result); + + /* "View.MemoryView":1226 + * + * tmpslice.data = result + * tmpslice.memview = src.memview # <<<<<<<<<<<<<< + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] +*/ + __pyx_t_4 = __pyx_v_src->memview; + __pyx_v_tmpslice->memview = __pyx_t_4; + + /* "View.MemoryView":1227 + * tmpslice.data = result + * tmpslice.memview = src.memview + * for i in range(ndim): # <<<<<<<<<<<<<< + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 +*/ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1228 + * tmpslice.memview = src.memview + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] # <<<<<<<<<<<<<< + * tmpslice.suboffsets[i] = -1 + * +*/ + (__pyx_v_tmpslice->shape[__pyx_v_i]) = (__pyx_v_src->shape[__pyx_v_i]); + + /* "View.MemoryView":1229 + * for i in range(ndim): + * tmpslice.shape[i] = src.shape[i] + * tmpslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) +*/ + (__pyx_v_tmpslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1231 + * tmpslice.suboffsets[i] = -1 + * + * fill_contig_strides_array(&tmpslice.shape[0], &tmpslice.strides[0], itemsize, ndim, order) # <<<<<<<<<<<<<< + * + * +*/ + (void)(__pyx_fill_contig_strides_array((&(__pyx_v_tmpslice->shape[0])), (&(__pyx_v_tmpslice->strides[0])), __pyx_v_itemsize, __pyx_v_ndim, __pyx_v_order)); + + /* "View.MemoryView":1234 + * + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 +*/ + __pyx_t_3 = __pyx_v_ndim; + __pyx_t_5 = __pyx_t_3; + for (__pyx_t_6 = 0; __pyx_t_6 < __pyx_t_5; __pyx_t_6+=1) { + __pyx_v_i = __pyx_t_6; + + /* "View.MemoryView":1235 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * +*/ + __pyx_t_2 = ((__pyx_v_tmpslice->shape[__pyx_v_i]) == 1); + if (__pyx_t_2) { + + /* "View.MemoryView":1236 + * for i in range(ndim): + * if tmpslice.shape[i] == 1: + * tmpslice.strides[i] = 0 # <<<<<<<<<<<<<< + * + * if slice_is_contig(src[0], order, ndim): +*/ + (__pyx_v_tmpslice->strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1235 + * + * for i in range(ndim): + * if tmpslice.shape[i] == 1: # <<<<<<<<<<<<<< + * tmpslice.strides[i] = 0 + * +*/ + } + } + + /* "View.MemoryView":1238 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: +*/ + __pyx_t_2 = __pyx_memviewslice_is_contig((__pyx_v_src[0]), __pyx_v_order, __pyx_v_ndim); + if (__pyx_t_2) { + + /* "View.MemoryView":1239 + * + * if slice_is_contig(src[0], order, ndim): + * memcpy(result, src.data, size) # <<<<<<<<<<<<<< + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) +*/ + (void)(memcpy(__pyx_v_result, __pyx_v_src->data, __pyx_v_size)); + + /* "View.MemoryView":1238 + * tmpslice.strides[i] = 0 + * + * if slice_is_contig(src[0], order, ndim): # <<<<<<<<<<<<<< + * memcpy(result, src.data, size) + * else: +*/ + goto __pyx_L9; + } + + /* "View.MemoryView":1241 + * memcpy(result, src.data, size) + * else: + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) # <<<<<<<<<<<<<< + * + * return result +*/ + /*else*/ { + copy_strided_to_strided(__pyx_v_src, __pyx_v_tmpslice, __pyx_v_ndim, __pyx_v_itemsize); + } + __pyx_L9:; + + /* "View.MemoryView":1243 + * copy_strided_to_strided(src, tmpslice, ndim, itemsize) + * + * return result # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "View.MemoryView":1205 + * return stride + * + * @cname('__pyx_memoryview_copy_data_to_temp') # <<<<<<<<<<<<<< + * cdef void *copy_data_to_temp(__Pyx_memviewslice *src, + * __Pyx_memviewslice *tmpslice, +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("View.MemoryView.copy_data_to_temp", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1247 + * + * + * @cname('__pyx_memoryview_err_extents') # <<<<<<<<<<<<<< + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: +*/ + +static int __pyx_memoryview_err_extents(int __pyx_v_i, Py_ssize_t __pyx_v_extent1, Py_ssize_t __pyx_v_extent2) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4[7]; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_RefNannySetupContext("_err_extents", 0); + + /* "View.MemoryView":1250 + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: + * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_dim') +*/ + __pyx_t_1 = __Pyx_PyUnicode_From_int(__pyx_v_i, 0, ' ', 'd'); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent1, 0, ' ', 'd'); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyUnicode_From_Py_ssize_t(__pyx_v_extent2, 0, ' ', 'd'); if (unlikely(!__pyx_t_3)) __PYX_ERR(1, 1250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4[0] = __pyx_mstate_global->__pyx_kp_u_got_differing_extents_in_dimensi; + __pyx_t_4[1] = __pyx_t_1; + __pyx_t_4[2] = __pyx_mstate_global->__pyx_kp_u_got; + __pyx_t_4[3] = __pyx_t_2; + __pyx_t_4[4] = __pyx_mstate_global->__pyx_kp_u_and; + __pyx_t_4[5] = __pyx_t_3; + __pyx_t_4[6] = __pyx_mstate_global->__pyx_kp_u__5; + __pyx_t_5 = __Pyx_PyUnicode_Join(__pyx_t_4, 7, 35 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_1) + 6 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_2) + 5 + __Pyx_PyUnicode_GET_LENGTH(__pyx_t_3) + 1, 127); + if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 1250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_Raise(((PyObject *)(((PyTypeObject*)PyExc_ValueError))), __pyx_t_5, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(1, 1250, __pyx_L1_error) + + /* "View.MemoryView":1247 + * + * + * @cname('__pyx_memoryview_err_extents') # <<<<<<<<<<<<<< + * cdef int _err_extents(int i, Py_ssize_t extent1, + * Py_ssize_t extent2) except -1 with gil: +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("View.MemoryView._err_extents", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_RefNannyFinishContext(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + return __pyx_r; +} + +/* "View.MemoryView":1252 + * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" + * + * @cname('__pyx_memoryview_err_dim') # <<<<<<<<<<<<<< + * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: + * raise error, msg % dim +*/ + +static int __pyx_memoryview_err_dim(PyObject *__pyx_v_error, PyObject *__pyx_v_msg, int __pyx_v_dim) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_RefNannySetupContext("_err_dim", 0); + __Pyx_INCREF(__pyx_v_msg); + + /* "View.MemoryView":1254 + * @cname('__pyx_memoryview_err_dim') + * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: + * raise error, msg % dim # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err') +*/ + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_dim); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = __Pyx_PyUnicode_FormatSafe(__pyx_v_msg, __pyx_t_1); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 1254, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_t_2, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(1, 1254, __pyx_L1_error) + + /* "View.MemoryView":1252 + * raise ValueError, f"got differing extents in dimension {i} (got {extent1} and {extent2})" + * + * @cname('__pyx_memoryview_err_dim') # <<<<<<<<<<<<<< + * cdef int _err_dim(PyObject *error, str msg, int dim) except -1 with gil: + * raise error, msg % dim +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_AddTraceback("View.MemoryView._err_dim", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_RefNannyFinishContext(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + return __pyx_r; +} + +/* "View.MemoryView":1256 + * raise error, msg % dim + * + * @cname('__pyx_memoryview_err') # <<<<<<<<<<<<<< + * cdef int _err(PyObject *error, str msg) except -1 with gil: + * raise error, msg +*/ + +static int __pyx_memoryview_err(PyObject *__pyx_v_error, PyObject *__pyx_v_msg) { + int __pyx_r; + __Pyx_RefNannyDeclarations + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_RefNannySetupContext("_err", 0); + __Pyx_INCREF(__pyx_v_msg); + + /* "View.MemoryView":1258 + * @cname('__pyx_memoryview_err') + * cdef int _err(PyObject *error, str msg) except -1 with gil: + * raise error, msg # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_err_no_memory') +*/ + __Pyx_Raise(((PyObject *)__pyx_v_error), __pyx_v_msg, 0, 0); + __PYX_ERR(1, 1258, __pyx_L1_error) + + /* "View.MemoryView":1256 + * raise error, msg % dim + * + * @cname('__pyx_memoryview_err') # <<<<<<<<<<<<<< + * cdef int _err(PyObject *error, str msg) except -1 with gil: + * raise error, msg +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._err", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_XDECREF(__pyx_v_msg); + __Pyx_RefNannyFinishContext(); + __Pyx_PyGILState_Release(__pyx_gilstate_save); + return __pyx_r; +} + +/* "View.MemoryView":1260 + * raise error, msg + * + * @cname('__pyx_memoryview_err_no_memory') # <<<<<<<<<<<<<< + * cdef int _err_no_memory() except -1 with gil: + * raise MemoryError +*/ + +static int __pyx_memoryview_err_no_memory(void) { + int __pyx_r; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + + /* "View.MemoryView":1262 + * @cname('__pyx_memoryview_err_no_memory') + * cdef int _err_no_memory() except -1 with gil: + * raise MemoryError # <<<<<<<<<<<<<< + * + * +*/ + PyErr_NoMemory(); __PYX_ERR(1, 1262, __pyx_L1_error) + + /* "View.MemoryView":1260 + * raise error, msg + * + * @cname('__pyx_memoryview_err_no_memory') # <<<<<<<<<<<<<< + * cdef int _err_no_memory() except -1 with gil: + * raise MemoryError +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("View.MemoryView._err_no_memory", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + return __pyx_r; +} + +/* "View.MemoryView":1265 + * + * + * @cname('__pyx_memoryview_copy_contents') # <<<<<<<<<<<<<< + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, + * __Pyx_memviewslice dst, +*/ + +static int __pyx_memoryview_copy_contents(__Pyx_memviewslice __pyx_v_src, __Pyx_memviewslice __pyx_v_dst, int __pyx_v_src_ndim, int __pyx_v_dst_ndim, int __pyx_v_dtype_is_object) { + void *__pyx_v_tmpdata; + size_t __pyx_v_itemsize; + int __pyx_v_i; + char __pyx_v_order; + int __pyx_v_broadcasting; + int __pyx_v_direct_copy; + __Pyx_memviewslice __pyx_v_tmp; + int __pyx_v_ndim; + int __pyx_r; + Py_ssize_t __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + int __pyx_t_4; + int __pyx_t_5; + int __pyx_t_6; + void *__pyx_t_7; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyGILState_STATE __pyx_gilstate_save; + + /* "View.MemoryView":1274 + * Check for overlapping memory and verify the shapes. + * """ + * cdef void *tmpdata = NULL # <<<<<<<<<<<<<< + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i +*/ + __pyx_v_tmpdata = NULL; + + /* "View.MemoryView":1275 + * """ + * cdef void *tmpdata = NULL + * cdef size_t itemsize = src.memview.view.itemsize # <<<<<<<<<<<<<< + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) +*/ + __pyx_t_1 = __pyx_v_src.memview->view.itemsize; + __pyx_v_itemsize = __pyx_t_1; + + /* "View.MemoryView":1277 + * cdef size_t itemsize = src.memview.view.itemsize + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) # <<<<<<<<<<<<<< + * cdef bint broadcasting = False + * cdef bint direct_copy = False +*/ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_src), __pyx_v_src_ndim); + + /* "View.MemoryView":1278 + * cdef int i + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False # <<<<<<<<<<<<<< + * cdef bint direct_copy = False + * cdef __Pyx_memviewslice tmp +*/ + __pyx_v_broadcasting = 0; + + /* "View.MemoryView":1279 + * cdef char order = get_best_order(&src, src_ndim) + * cdef bint broadcasting = False + * cdef bint direct_copy = False # <<<<<<<<<<<<<< + * cdef __Pyx_memviewslice tmp + * +*/ + __pyx_v_direct_copy = 0; + + /* "View.MemoryView":1282 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: +*/ + __pyx_t_2 = (__pyx_v_src_ndim < __pyx_v_dst_ndim); + if (__pyx_t_2) { + + /* "View.MemoryView":1283 + * + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) +*/ + __pyx_memoryview_broadcast_leading((&__pyx_v_src), __pyx_v_src_ndim, __pyx_v_dst_ndim); + + /* "View.MemoryView":1282 + * cdef __Pyx_memviewslice tmp + * + * if src_ndim < dst_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":1284 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * +*/ + __pyx_t_2 = (__pyx_v_dst_ndim < __pyx_v_src_ndim); + if (__pyx_t_2) { + + /* "View.MemoryView":1285 + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: + * broadcast_leading(&dst, dst_ndim, src_ndim) # <<<<<<<<<<<<<< + * + * cdef int ndim = max(src_ndim, dst_ndim) +*/ + __pyx_memoryview_broadcast_leading((&__pyx_v_dst), __pyx_v_dst_ndim, __pyx_v_src_ndim); + + /* "View.MemoryView":1284 + * if src_ndim < dst_ndim: + * broadcast_leading(&src, src_ndim, dst_ndim) + * elif dst_ndim < src_ndim: # <<<<<<<<<<<<<< + * broadcast_leading(&dst, dst_ndim, src_ndim) + * +*/ + } + __pyx_L3:; + + /* "View.MemoryView":1287 + * broadcast_leading(&dst, dst_ndim, src_ndim) + * + * cdef int ndim = max(src_ndim, dst_ndim) # <<<<<<<<<<<<<< + * + * for i in range(ndim): +*/ + __pyx_t_3 = __pyx_v_dst_ndim; + __pyx_t_4 = __pyx_v_src_ndim; + __pyx_t_2 = (__pyx_t_3 > __pyx_t_4); + if (__pyx_t_2) { + __pyx_t_5 = __pyx_t_3; + } else { + __pyx_t_5 = __pyx_t_4; + } + __pyx_v_ndim = __pyx_t_5; + + /* "View.MemoryView":1289 + * cdef int ndim = max(src_ndim, dst_ndim) + * + * for i in range(ndim): # <<<<<<<<<<<<<< + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: +*/ + __pyx_t_5 = __pyx_v_ndim; + __pyx_t_3 = __pyx_t_5; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1290 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True +*/ + __pyx_t_2 = ((__pyx_v_src.shape[__pyx_v_i]) != (__pyx_v_dst.shape[__pyx_v_i])); + if (__pyx_t_2) { + + /* "View.MemoryView":1291 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 +*/ + __pyx_t_2 = ((__pyx_v_src.shape[__pyx_v_i]) == 1); + if (__pyx_t_2) { + + /* "View.MemoryView":1292 + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: + * broadcasting = True # <<<<<<<<<<<<<< + * src.strides[i] = 0 + * else: +*/ + __pyx_v_broadcasting = 1; + + /* "View.MemoryView":1293 + * if src.shape[i] == 1: + * broadcasting = True + * src.strides[i] = 0 # <<<<<<<<<<<<<< + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) +*/ + (__pyx_v_src.strides[__pyx_v_i]) = 0; + + /* "View.MemoryView":1291 + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: + * if src.shape[i] == 1: # <<<<<<<<<<<<<< + * broadcasting = True + * src.strides[i] = 0 +*/ + goto __pyx_L7; + } + + /* "View.MemoryView":1295 + * src.strides[i] = 0 + * else: + * _err_extents(i, dst.shape[i], src.shape[i]) # <<<<<<<<<<<<<< + * + * if src.suboffsets[i] >= 0: +*/ + /*else*/ { + __pyx_t_6 = __pyx_memoryview_err_extents(__pyx_v_i, (__pyx_v_dst.shape[__pyx_v_i]), (__pyx_v_src.shape[__pyx_v_i])); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1295, __pyx_L1_error) + } + __pyx_L7:; + + /* "View.MemoryView":1290 + * + * for i in range(ndim): + * if src.shape[i] != dst.shape[i]: # <<<<<<<<<<<<<< + * if src.shape[i] == 1: + * broadcasting = True +*/ + } + + /* "View.MemoryView":1297 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) + * +*/ + __pyx_t_2 = ((__pyx_v_src.suboffsets[__pyx_v_i]) >= 0); + if (__pyx_t_2) { + + /* "View.MemoryView":1298 + * + * if src.suboffsets[i] >= 0: + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) # <<<<<<<<<<<<<< + * + * if slices_overlap(&src, &dst, ndim, itemsize): +*/ + __pyx_t_6 = __pyx_memoryview_err_dim(PyExc_ValueError, __pyx_mstate_global->__pyx_kp_u_Dimension_d_is_not_direct, __pyx_v_i); if (unlikely(__pyx_t_6 == ((int)-1))) __PYX_ERR(1, 1298, __pyx_L1_error) + + /* "View.MemoryView":1297 + * _err_extents(i, dst.shape[i], src.shape[i]) + * + * if src.suboffsets[i] >= 0: # <<<<<<<<<<<<<< + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) + * +*/ + } + } + + /* "View.MemoryView":1300 + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): +*/ + __pyx_t_2 = __pyx_slices_overlap((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + if (__pyx_t_2) { + + /* "View.MemoryView":1302 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * +*/ + __pyx_t_2 = (!__pyx_memviewslice_is_contig(__pyx_v_src, __pyx_v_order, __pyx_v_ndim)); + if (__pyx_t_2) { + + /* "View.MemoryView":1303 + * + * if not slice_is_contig(src, order, ndim): + * order = get_best_order(&dst, ndim) # <<<<<<<<<<<<<< + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) +*/ + __pyx_v_order = __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim); + + /* "View.MemoryView":1302 + * if slices_overlap(&src, &dst, ndim, itemsize): + * + * if not slice_is_contig(src, order, ndim): # <<<<<<<<<<<<<< + * order = get_best_order(&dst, ndim) + * +*/ + } + + /* "View.MemoryView":1305 + * order = get_best_order(&dst, ndim) + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) # <<<<<<<<<<<<<< + * src = tmp + * +*/ + __pyx_t_7 = __pyx_memoryview_copy_data_to_temp((&__pyx_v_src), (&__pyx_v_tmp), __pyx_v_order, __pyx_v_ndim); if (unlikely(__pyx_t_7 == ((void *)NULL))) __PYX_ERR(1, 1305, __pyx_L1_error) + __pyx_v_tmpdata = __pyx_t_7; + + /* "View.MemoryView":1306 + * + * tmpdata = copy_data_to_temp(&src, &tmp, order, ndim) + * src = tmp # <<<<<<<<<<<<<< + * + * if not broadcasting: +*/ + __pyx_v_src = __pyx_v_tmp; + + /* "View.MemoryView":1300 + * _err_dim(PyExc_ValueError, "Dimension %d is not direct", i) + * + * if slices_overlap(&src, &dst, ndim, itemsize): # <<<<<<<<<<<<<< + * + * if not slice_is_contig(src, order, ndim): +*/ + } + + /* "View.MemoryView":1308 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_2 = (!__pyx_v_broadcasting); + if (__pyx_t_2) { + + /* "View.MemoryView":1311 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): +*/ + __pyx_t_2 = __pyx_memviewslice_is_contig(__pyx_v_src, 'C', __pyx_v_ndim); + if (__pyx_t_2) { + + /* "View.MemoryView":1312 + * + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) # <<<<<<<<<<<<<< + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) +*/ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'C', __pyx_v_ndim); + + /* "View.MemoryView":1311 + * + * + * if slice_is_contig(src, 'C', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): +*/ + goto __pyx_L12; + } + + /* "View.MemoryView":1313 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * +*/ + __pyx_t_2 = __pyx_memviewslice_is_contig(__pyx_v_src, 'F', __pyx_v_ndim); + if (__pyx_t_2) { + + /* "View.MemoryView":1314 + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): + * direct_copy = slice_is_contig(dst, 'F', ndim) # <<<<<<<<<<<<<< + * + * if direct_copy: +*/ + __pyx_v_direct_copy = __pyx_memviewslice_is_contig(__pyx_v_dst, 'F', __pyx_v_ndim); + + /* "View.MemoryView":1313 + * if slice_is_contig(src, 'C', ndim): + * direct_copy = slice_is_contig(dst, 'C', ndim) + * elif slice_is_contig(src, 'F', ndim): # <<<<<<<<<<<<<< + * direct_copy = slice_is_contig(dst, 'F', ndim) + * +*/ + } + __pyx_L12:; + + /* "View.MemoryView":1316 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) +*/ + if (__pyx_v_direct_copy) { + + /* "View.MemoryView":1318 + * if direct_copy: + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) +*/ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1319 + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * free(tmpdata) +*/ + (void)(memcpy(__pyx_v_dst.data, __pyx_v_src.data, __pyx_memoryview_slice_get_size((&__pyx_v_src), __pyx_v_ndim))); + + /* "View.MemoryView":1320 + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< + * free(tmpdata) + * return 0 +*/ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1321 + * memcpy(dst.data, src.data, slice_get_size(&src, ndim)) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * +*/ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1322 + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * if order == 'F' == get_best_order(&dst, ndim): +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1316 + * direct_copy = slice_is_contig(dst, 'F', ndim) + * + * if direct_copy: # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) +*/ + } + + /* "View.MemoryView":1308 + * src = tmp + * + * if not broadcasting: # <<<<<<<<<<<<<< + * + * +*/ + } + + /* "View.MemoryView":1324 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_2 = (__pyx_v_order == 'F'); + if (__pyx_t_2) { + __pyx_t_2 = ('F' == __pyx_get_best_slice_order((&__pyx_v_dst), __pyx_v_ndim)); + } + if (__pyx_t_2) { + + /* "View.MemoryView":1327 + * + * + * transpose_memslice(&src) # <<<<<<<<<<<<<< + * transpose_memslice(&dst) + * +*/ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_src)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1327, __pyx_L1_error) + + /* "View.MemoryView":1328 + * + * transpose_memslice(&src) + * transpose_memslice(&dst) # <<<<<<<<<<<<<< + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) +*/ + __pyx_t_5 = __pyx_memslice_transpose((&__pyx_v_dst)); if (unlikely(__pyx_t_5 == ((int)-1))) __PYX_ERR(1, 1328, __pyx_L1_error) + + /* "View.MemoryView":1324 + * return 0 + * + * if order == 'F' == get_best_order(&dst, ndim): # <<<<<<<<<<<<<< + * + * +*/ + } + + /* "View.MemoryView":1330 + * transpose_memslice(&dst) + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) +*/ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1331 + * + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) # <<<<<<<<<<<<<< + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * +*/ + copy_strided_to_strided((&__pyx_v_src), (&__pyx_v_dst), __pyx_v_ndim, __pyx_v_itemsize); + + /* "View.MemoryView":1332 + * refcount_copying(&dst, dtype_is_object, ndim, inc=False) + * copy_strided_to_strided(&src, &dst, ndim, itemsize) + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< + * + * free(tmpdata) +*/ + __pyx_memoryview_refcount_copying((&__pyx_v_dst), __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1334 + * refcount_copying(&dst, dtype_is_object, ndim, inc=True) + * + * free(tmpdata) # <<<<<<<<<<<<<< + * return 0 + * +*/ + free(__pyx_v_tmpdata); + + /* "View.MemoryView":1335 + * + * free(tmpdata) + * return 0 # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_broadcast_leading') +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "View.MemoryView":1265 + * + * + * @cname('__pyx_memoryview_copy_contents') # <<<<<<<<<<<<<< + * cdef int memoryview_copy_contents(__Pyx_memviewslice src, + * __Pyx_memviewslice dst, +*/ + + /* function exit code */ + __pyx_L1_error:; + __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + __Pyx_AddTraceback("View.MemoryView.memoryview_copy_contents", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __Pyx_PyGILState_Release(__pyx_gilstate_save); + __pyx_L0:; + return __pyx_r; +} + +/* "View.MemoryView":1337 + * return 0 + * + * @cname('__pyx_memoryview_broadcast_leading') # <<<<<<<<<<<<<< + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, + * int ndim, +*/ + +static void __pyx_memoryview_broadcast_leading(__Pyx_memviewslice *__pyx_v_mslice, int __pyx_v_ndim, int __pyx_v_ndim_other) { + int __pyx_v_i; + int __pyx_v_offset; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + + /* "View.MemoryView":1342 + * int ndim_other) noexcept nogil: + * cdef int i + * cdef int offset = ndim_other - ndim # <<<<<<<<<<<<<< + * + * for i in range(ndim - 1, -1, -1): +*/ + __pyx_v_offset = (__pyx_v_ndim_other - __pyx_v_ndim); + + /* "View.MemoryView":1344 + * cdef int offset = ndim_other - ndim + * + * for i in range(ndim - 1, -1, -1): # <<<<<<<<<<<<<< + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] +*/ + for (__pyx_t_1 = (__pyx_v_ndim - 1); __pyx_t_1 > -1; __pyx_t_1-=1) { + __pyx_v_i = __pyx_t_1; + + /* "View.MemoryView":1345 + * + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] # <<<<<<<<<<<<<< + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] +*/ + (__pyx_v_mslice->shape[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->shape[__pyx_v_i]); + + /* "View.MemoryView":1346 + * for i in range(ndim - 1, -1, -1): + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] # <<<<<<<<<<<<<< + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * +*/ + (__pyx_v_mslice->strides[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->strides[__pyx_v_i]); + + /* "View.MemoryView":1347 + * mslice.shape[i + offset] = mslice.shape[i] + * mslice.strides[i + offset] = mslice.strides[i] + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] # <<<<<<<<<<<<<< + * + * for i in range(offset): +*/ + (__pyx_v_mslice->suboffsets[(__pyx_v_i + __pyx_v_offset)]) = (__pyx_v_mslice->suboffsets[__pyx_v_i]); + } + + /* "View.MemoryView":1349 + * mslice.suboffsets[i + offset] = mslice.suboffsets[i] + * + * for i in range(offset): # <<<<<<<<<<<<<< + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] +*/ + __pyx_t_1 = __pyx_v_offset; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1350 + * + * for i in range(offset): + * mslice.shape[i] = 1 # <<<<<<<<<<<<<< + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 +*/ + (__pyx_v_mslice->shape[__pyx_v_i]) = 1; + + /* "View.MemoryView":1351 + * for i in range(offset): + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] # <<<<<<<<<<<<<< + * mslice.suboffsets[i] = -1 + * +*/ + (__pyx_v_mslice->strides[__pyx_v_i]) = (__pyx_v_mslice->strides[0]); + + /* "View.MemoryView":1352 + * mslice.shape[i] = 1 + * mslice.strides[i] = mslice.strides[0] + * mslice.suboffsets[i] = -1 # <<<<<<<<<<<<<< + * + * +*/ + (__pyx_v_mslice->suboffsets[__pyx_v_i]) = -1L; + } + + /* "View.MemoryView":1337 + * return 0 + * + * @cname('__pyx_memoryview_broadcast_leading') # <<<<<<<<<<<<<< + * cdef void broadcast_leading(__Pyx_memviewslice *mslice, + * int ndim, +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1359 + * + * + * @cname('__pyx_memoryview_refcount_copying') # <<<<<<<<<<<<<< + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: + * +*/ + +static void __pyx_memoryview_refcount_copying(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_dtype_is_object, int __pyx_v_ndim, int __pyx_v_inc) { + + /* "View.MemoryView":1362 + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + * +*/ + if (__pyx_v_dtype_is_object) { + + /* "View.MemoryView":1363 + * + * if dtype_is_object: + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') +*/ + __pyx_memoryview_refcount_objects_in_slice_with_gil(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1362 + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: + * + * if dtype_is_object: # <<<<<<<<<<<<<< + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + * +*/ + } + + /* "View.MemoryView":1359 + * + * + * @cname('__pyx_memoryview_refcount_copying') # <<<<<<<<<<<<<< + * cdef void refcount_copying(__Pyx_memviewslice *dst, bint dtype_is_object, int ndim, bint inc) noexcept nogil: + * +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1365 + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') # <<<<<<<<<<<<<< + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, + * Py_ssize_t *strides, int ndim, +*/ + +static void __pyx_memoryview_refcount_objects_in_slice_with_gil(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + PyGILState_STATE __pyx_gilstate_save = __Pyx_PyGILState_Ensure(); + + /* "View.MemoryView":1369 + * Py_ssize_t *strides, int ndim, + * bint inc) noexcept with gil: + * refcount_objects_in_slice(data, shape, strides, ndim, inc) # <<<<<<<<<<<<<< + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') +*/ + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, __pyx_v_shape, __pyx_v_strides, __pyx_v_ndim, __pyx_v_inc); + + /* "View.MemoryView":1365 + * refcount_objects_in_slice_with_gil(dst.data, dst.shape, dst.strides, ndim, inc) + * + * @cname('__pyx_memoryview_refcount_objects_in_slice_with_gil') # <<<<<<<<<<<<<< + * cdef void refcount_objects_in_slice_with_gil(char *data, Py_ssize_t *shape, + * Py_ssize_t *strides, int ndim, +*/ + + /* function exit code */ + __Pyx_PyGILState_Release(__pyx_gilstate_save); +} + +/* "View.MemoryView":1371 + * refcount_objects_in_slice(data, shape, strides, ndim, inc) + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') # <<<<<<<<<<<<<< + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, + * Py_ssize_t *strides, int ndim, bint inc) noexcept: +*/ + +static void __pyx_memoryview_refcount_objects_in_slice(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, int __pyx_v_inc) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_t_4; + + /* "View.MemoryView":1375 + * Py_ssize_t *strides, int ndim, bint inc) noexcept: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * + * for i in range(shape[0]): +*/ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1377 + * cdef Py_ssize_t stride = strides[0] + * + * for i in range(shape[0]): # <<<<<<<<<<<<<< + * if ndim == 1: + * if inc: +*/ + __pyx_t_1 = (__pyx_v_shape[0]); + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "View.MemoryView":1378 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) +*/ + __pyx_t_4 = (__pyx_v_ndim == 1); + if (__pyx_t_4) { + + /* "View.MemoryView":1379 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: +*/ + if (__pyx_v_inc) { + + /* "View.MemoryView":1380 + * if ndim == 1: + * if inc: + * Py_INCREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * Py_DECREF(( data)[0]) +*/ + Py_INCREF((((PyObject **)__pyx_v_data)[0])); + + /* "View.MemoryView":1379 + * for i in range(shape[0]): + * if ndim == 1: + * if inc: # <<<<<<<<<<<<<< + * Py_INCREF(( data)[0]) + * else: +*/ + goto __pyx_L6; + } + + /* "View.MemoryView":1382 + * Py_INCREF(( data)[0]) + * else: + * Py_DECREF(( data)[0]) # <<<<<<<<<<<<<< + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) +*/ + /*else*/ { + Py_DECREF((((PyObject **)__pyx_v_data)[0])); + } + __pyx_L6:; + + /* "View.MemoryView":1378 + * + * for i in range(shape[0]): + * if ndim == 1: # <<<<<<<<<<<<<< + * if inc: + * Py_INCREF(( data)[0]) +*/ + goto __pyx_L5; + } + + /* "View.MemoryView":1384 + * Py_DECREF(( data)[0]) + * else: + * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) # <<<<<<<<<<<<<< + * + * data += stride +*/ + /*else*/ { + __pyx_memoryview_refcount_objects_in_slice(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_inc); + } + __pyx_L5:; + + /* "View.MemoryView":1386 + * refcount_objects_in_slice(data, shape + 1, strides + 1, ndim - 1, inc) + * + * data += stride # <<<<<<<<<<<<<< + * + * +*/ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + + /* "View.MemoryView":1371 + * refcount_objects_in_slice(data, shape, strides, ndim, inc) + * + * @cname('__pyx_memoryview_refcount_objects_in_slice') # <<<<<<<<<<<<<< + * cdef void refcount_objects_in_slice(char *data, Py_ssize_t *shape, + * Py_ssize_t *strides, int ndim, bint inc) noexcept: +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1391 + * + * + * @cname('__pyx_memoryview_slice_assign_scalar') # <<<<<<<<<<<<<< + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, + * size_t itemsize, void *item, +*/ + +static void __pyx_memoryview_slice_assign_scalar(__Pyx_memviewslice *__pyx_v_dst, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item, int __pyx_v_dtype_is_object) { + + /* "View.MemoryView":1395 + * size_t itemsize, void *item, + * bint dtype_is_object) noexcept nogil: + * refcount_copying(dst, dtype_is_object, ndim, inc=False) # <<<<<<<<<<<<<< + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, inc=True) +*/ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 0); + + /* "View.MemoryView":1396 + * bint dtype_is_object) noexcept nogil: + * refcount_copying(dst, dtype_is_object, ndim, inc=False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) # <<<<<<<<<<<<<< + * refcount_copying(dst, dtype_is_object, ndim, inc=True) + * +*/ + __pyx_memoryview__slice_assign_scalar(__pyx_v_dst->data, __pyx_v_dst->shape, __pyx_v_dst->strides, __pyx_v_ndim, __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1397 + * refcount_copying(dst, dtype_is_object, ndim, inc=False) + * _slice_assign_scalar(dst.data, dst.shape, dst.strides, ndim, itemsize, item) + * refcount_copying(dst, dtype_is_object, ndim, inc=True) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_memoryview_refcount_copying(__pyx_v_dst, __pyx_v_dtype_is_object, __pyx_v_ndim, 1); + + /* "View.MemoryView":1391 + * + * + * @cname('__pyx_memoryview_slice_assign_scalar') # <<<<<<<<<<<<<< + * cdef void slice_assign_scalar(__Pyx_memviewslice *dst, int ndim, + * size_t itemsize, void *item, +*/ + + /* function exit code */ +} + +/* "View.MemoryView":1400 + * + * + * @cname('__pyx_memoryview__slice_assign_scalar') # <<<<<<<<<<<<<< + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, + * Py_ssize_t *strides, int ndim, +*/ + +static void __pyx_memoryview__slice_assign_scalar(char *__pyx_v_data, Py_ssize_t *__pyx_v_shape, Py_ssize_t *__pyx_v_strides, int __pyx_v_ndim, size_t __pyx_v_itemsize, void *__pyx_v_item) { + CYTHON_UNUSED Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_stride; + Py_ssize_t __pyx_v_extent; + int __pyx_t_1; + Py_ssize_t __pyx_t_2; + Py_ssize_t __pyx_t_3; + Py_ssize_t __pyx_t_4; + + /* "View.MemoryView":1405 + * size_t itemsize, void *item) noexcept nogil: + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] # <<<<<<<<<<<<<< + * cdef Py_ssize_t extent = shape[0] + * +*/ + __pyx_v_stride = (__pyx_v_strides[0]); + + /* "View.MemoryView":1406 + * cdef Py_ssize_t i + * cdef Py_ssize_t stride = strides[0] + * cdef Py_ssize_t extent = shape[0] # <<<<<<<<<<<<<< + * + * if ndim == 1: +*/ + __pyx_v_extent = (__pyx_v_shape[0]); + + /* "View.MemoryView":1408 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) +*/ + __pyx_t_1 = (__pyx_v_ndim == 1); + if (__pyx_t_1) { + + /* "View.MemoryView":1409 + * + * if ndim == 1: + * for i in range(extent): # <<<<<<<<<<<<<< + * memcpy(data, item, itemsize) + * data += stride +*/ + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1410 + * if ndim == 1: + * for i in range(extent): + * memcpy(data, item, itemsize) # <<<<<<<<<<<<<< + * data += stride + * else: +*/ + (void)(memcpy(__pyx_v_data, __pyx_v_item, __pyx_v_itemsize)); + + /* "View.MemoryView":1411 + * for i in range(extent): + * memcpy(data, item, itemsize) + * data += stride # <<<<<<<<<<<<<< + * else: + * for i in range(extent): +*/ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + + /* "View.MemoryView":1408 + * cdef Py_ssize_t extent = shape[0] + * + * if ndim == 1: # <<<<<<<<<<<<<< + * for i in range(extent): + * memcpy(data, item, itemsize) +*/ + goto __pyx_L3; + } + + /* "View.MemoryView":1413 + * data += stride + * else: + * for i in range(extent): # <<<<<<<<<<<<<< + * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) + * data += stride +*/ + /*else*/ { + __pyx_t_2 = __pyx_v_extent; + __pyx_t_3 = __pyx_t_2; + for (__pyx_t_4 = 0; __pyx_t_4 < __pyx_t_3; __pyx_t_4+=1) { + __pyx_v_i = __pyx_t_4; + + /* "View.MemoryView":1414 + * else: + * for i in range(extent): + * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) # <<<<<<<<<<<<<< + * data += stride + * +*/ + __pyx_memoryview__slice_assign_scalar(__pyx_v_data, (__pyx_v_shape + 1), (__pyx_v_strides + 1), (__pyx_v_ndim - 1), __pyx_v_itemsize, __pyx_v_item); + + /* "View.MemoryView":1415 + * for i in range(extent): + * _slice_assign_scalar(data, shape + 1, strides + 1, ndim - 1, itemsize, item) + * data += stride # <<<<<<<<<<<<<< + * +*/ + __pyx_v_data = (__pyx_v_data + __pyx_v_stride); + } + } + __pyx_L3:; + + /* "View.MemoryView":1400 + * + * + * @cname('__pyx_memoryview__slice_assign_scalar') # <<<<<<<<<<<<<< + * cdef void _slice_assign_scalar(char *data, Py_ssize_t *shape, + * Py_ssize_t *strides, int ndim, +*/ + + /* function exit code */ +} + +/* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum = {"__pyx_unpickle_Enum", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_15View_dot_MemoryView_1__pyx_unpickle_Enum(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyObject *__pyx_v___pyx_type = 0; + long __pyx_v___pyx_checksum; + PyObject *__pyx_v___pyx_state = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[3] = {0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_pyx_type,&__pyx_mstate_global->__pyx_n_u_pyx_checksum,&__pyx_mstate_global->__pyx_n_u_pyx_state,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(1, 4, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values, kwd_pos_args, __pyx_kwds_len, "__pyx_unpickle_Enum", 0) < (0)) __PYX_ERR(1, 4, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 3; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, i); __PYX_ERR(1, 4, __pyx_L3_error) } + } + } else if (unlikely(__pyx_nargs != 3)) { + goto __pyx_L5_argtuple_error; + } else { + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(1, 4, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(1, 4, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(1, 4, __pyx_L3_error) + } + __pyx_v___pyx_type = values[0]; + __pyx_v___pyx_checksum = __Pyx_PyLong_As_long(values[1]); if (unlikely((__pyx_v___pyx_checksum == (long)-1) && PyErr_Occurred())) __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_v___pyx_state = ((PyObject*)values[2]); + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("__pyx_unpickle_Enum", 1, 3, 3, __pyx_nargs); __PYX_ERR(1, 4, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v___pyx_state), (&PyTuple_Type), 1, "__pyx_state", 1))) __PYX_ERR(1, 4, __pyx_L1_error) + __pyx_r = __pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(__pyx_self, __pyx_v___pyx_type, __pyx_v___pyx_checksum, __pyx_v___pyx_state); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_15View_dot_MemoryView___pyx_unpickle_Enum(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v___pyx_type, long __pyx_v___pyx_checksum, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_v___pyx_result = 0; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + size_t __pyx_t_4; + int __pyx_t_5; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum", 0); + + /* "(tree fragment)":6 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, tuple __pyx_state): + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') # <<<<<<<<<<<<<< + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: +*/ + __pyx_t_1 = __Pyx_CheckUnpickleChecksum(__pyx_v___pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, ((char const *)"name")); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(1, 6, __pyx_L1_error) + + /* "(tree fragment)":7 + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') + * __pyx_result = Enum.__new__(__pyx_type) # <<<<<<<<<<<<<< + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) +*/ + __pyx_t_3 = ((PyObject *)__pyx_mstate_global->__pyx_MemviewEnum_type); + __Pyx_INCREF(__pyx_t_3); + __pyx_t_4 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v___pyx_type}; + __pyx_t_2 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_new, __pyx_callargs+__pyx_t_4, (2-__pyx_t_4) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 7, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_v___pyx_result = __pyx_t_2; + __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + __pyx_t_5 = (__pyx_v___pyx_state != ((PyObject*)Py_None)); + if (__pyx_t_5) { + + /* "(tree fragment)":9 + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) # <<<<<<<<<<<<<< + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, __pyx_state: tuple): +*/ + if (unlikely(__pyx_v___pyx_state == Py_None)) { + PyErr_SetString(PyExc_TypeError, "cannot pass None into a C function argument that is declared 'not None'"); + __PYX_ERR(1, 9, __pyx_L1_error) + } + __pyx_t_2 = __pyx_unpickle_Enum__set_state(((struct __pyx_MemviewEnum_obj *)__pyx_v___pyx_result), __pyx_v___pyx_state); if (unlikely(!__pyx_t_2)) __PYX_ERR(1, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "(tree fragment)":8 + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') + * __pyx_result = Enum.__new__(__pyx_type) + * if __pyx_state is not None: # <<<<<<<<<<<<<< + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result +*/ + } + + /* "(tree fragment)":10 + * if __pyx_state is not None: + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result # <<<<<<<<<<<<<< + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, __pyx_state: tuple): + * __pyx_result.name = __pyx_state[0] +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_v___pyx_result); + __pyx_r = __pyx_v___pyx_result; + goto __pyx_L0; + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XDECREF(__pyx_v___pyx_result); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 1) +*/ + +static PyObject *__pyx_unpickle_Enum__set_state(struct __pyx_MemviewEnum_obj *__pyx_v___pyx_result, PyObject *__pyx_v___pyx_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__pyx_unpickle_Enum__set_state", 0); + + /* "(tree fragment)":12 + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, __pyx_state: tuple): + * __pyx_result.name = __pyx_state[0] # <<<<<<<<<<<<<< + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 1) +*/ + __pyx_t_1 = __Pyx_GetItemInt_Tuple(__pyx_v___pyx_state, 0, long, 1, __Pyx_PyLong_From_long, 0, 0, 1, 1, __Pyx_ReferenceSharing_FunctionArgument); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 12, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_1); + __Pyx_GOTREF(__pyx_v___pyx_result->name); + __Pyx_DECREF(__pyx_v___pyx_result->name); + __pyx_v___pyx_result->name = __pyx_t_1; + __pyx_t_1 = 0; + + /* "(tree fragment)":13 + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, __pyx_state: tuple): + * __pyx_result.name = __pyx_state[0] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 1) # <<<<<<<<<<<<<< +*/ + __pyx_t_2 = __Pyx_UpdateUnpickledDict(((PyObject *)__pyx_v___pyx_result), __pyx_v___pyx_state, 1); if (unlikely(__pyx_t_2 == ((int)-1))) __PYX_ERR(1, 13, __pyx_L1_error) + + /* "(tree fragment)":11 + * __pyx_unpickle_Enum__set_state( __pyx_result, __pyx_state) + * return __pyx_result + * cdef __pyx_unpickle_Enum__set_state(Enum __pyx_result, __pyx_state: tuple): # <<<<<<<<<<<<<< + * __pyx_result.name = __pyx_state[0] + * __Pyx_UpdateUnpickledDict(__pyx_result, __pyx_state, 1) +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("View.MemoryView.__pyx_unpickle_Enum__set_state", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":242 + * cdef int type_num + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp itemsize(self) noexcept nogil: + * return PyDataType_ELSIZE(self) +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_8itemsize_itemsize(PyArray_Descr *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":244 + * @property + * cdef inline npy_intp itemsize(self) noexcept nogil: + * return PyDataType_ELSIZE(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyDataType_ELSIZE(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":242 + * cdef int type_num + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp itemsize(self) noexcept nogil: + * return PyDataType_ELSIZE(self) +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":246 + * return PyDataType_ELSIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp alignment(self) noexcept nogil: + * return PyDataType_ALIGNMENT(self) +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_5dtype_9alignment_alignment(PyArray_Descr *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":248 + * @property + * cdef inline npy_intp alignment(self) noexcept nogil: + * return PyDataType_ALIGNMENT(self) # <<<<<<<<<<<<<< + * + * # Use fields/names with care as they may be NULL. You must check +*/ + __pyx_r = PyDataType_ALIGNMENT(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":246 + * return PyDataType_ELSIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp alignment(self) noexcept nogil: + * return PyDataType_ALIGNMENT(self) +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":252 + * # Use fields/names with care as they may be NULL. You must check + * # for this using PyDataType_HASFIELDS. + * @property # <<<<<<<<<<<<<< + * cdef inline object fields(self): + * return PyDataType_FIELDS(self) +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_6fields_fields(PyArray_Descr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1; + __Pyx_RefNannySetupContext("fields", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":254 + * @property + * cdef inline object fields(self): + * return PyDataType_FIELDS(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyDataType_FIELDS(__pyx_v_self); + __Pyx_INCREF(((PyObject *)__pyx_t_1)); + __pyx_r = ((PyObject *)__pyx_t_1); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":252 + * # Use fields/names with care as they may be NULL. You must check + * # for this using PyDataType_HASFIELDS. + * @property # <<<<<<<<<<<<<< + * cdef inline object fields(self): + * return PyDataType_FIELDS(self) +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":256 + * return PyDataType_FIELDS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline tuple names(self): + * return PyDataType_NAMES(self) +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_5dtype_5names_names(PyArray_Descr *__pyx_v_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1; + __Pyx_RefNannySetupContext("names", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":258 + * @property + * cdef inline tuple names(self): + * return PyDataType_NAMES(self) # <<<<<<<<<<<<<< + * + * # Use PyDataType_HASSUBARRAY to test whether this field is +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyDataType_NAMES(__pyx_v_self); + __Pyx_INCREF(((PyObject*)__pyx_t_1)); + __pyx_r = ((PyObject*)__pyx_t_1); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":256 + * return PyDataType_FIELDS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline tuple names(self): + * return PyDataType_NAMES(self) +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":263 + * # valid (the pointer can be NULL). Most users should access + * # this field via the inline helper method PyDataType_SHAPE. + * @property # <<<<<<<<<<<<<< + * cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: + * return PyDataType_SUBARRAY(self) +*/ + +static CYTHON_INLINE PyArray_ArrayDescr *__pyx_f_5numpy_5dtype_8subarray_subarray(PyArray_Descr *__pyx_v_self) { + PyArray_ArrayDescr *__pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":265 + * @property + * cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: + * return PyDataType_SUBARRAY(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyDataType_SUBARRAY(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":263 + * # valid (the pointer can be NULL). Most users should access + * # this field via the inline helper method PyDataType_SHAPE. + * @property # <<<<<<<<<<<<<< + * cdef inline PyArray_ArrayDescr* subarray(self) noexcept nogil: + * return PyDataType_SUBARRAY(self) +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":267 + * return PyDataType_SUBARRAY(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_uint64 flags(self) noexcept nogil: + * """The data types flags.""" +*/ + +static CYTHON_INLINE npy_uint64 __pyx_f_5numpy_5dtype_5flags_flags(PyArray_Descr *__pyx_v_self) { + npy_uint64 __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":270 + * cdef inline npy_uint64 flags(self) noexcept nogil: + * """The data types flags.""" + * return PyDataType_FLAGS(self) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyDataType_FLAGS(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":267 + * return PyDataType_SUBARRAY(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_uint64 flags(self) noexcept nogil: + * """The data types flags.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":279 + * ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: + * + * @property # <<<<<<<<<<<<<< + * cdef inline int numiter(self) noexcept nogil: + * """The number of arrays that need to be broadcast to the same shape.""" +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_7numiter_numiter(PyArrayMultiIterObject *__pyx_v_self) { + int __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":282 + * cdef inline int numiter(self) noexcept nogil: + * """The number of arrays that need to be broadcast to the same shape.""" + * return PyArray_MultiIter_NUMITER(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_NUMITER(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":279 + * ctypedef class numpy.broadcast [object PyArrayMultiIterObject, check_size ignore]: + * + * @property # <<<<<<<<<<<<<< + * cdef inline int numiter(self) noexcept nogil: + * """The number of arrays that need to be broadcast to the same shape.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":284 + * return PyArray_MultiIter_NUMITER(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp size(self) noexcept nogil: + * """The total broadcasted size.""" +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_4size_size(PyArrayMultiIterObject *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":287 + * cdef inline npy_intp size(self) noexcept nogil: + * """The total broadcasted size.""" + * return PyArray_MultiIter_SIZE(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_SIZE(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":284 + * return PyArray_MultiIter_NUMITER(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp size(self) noexcept nogil: + * """The total broadcasted size.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":289 + * return PyArray_MultiIter_SIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp index(self) noexcept nogil: + * """The current (1-d) index into the broadcasted result.""" +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_9broadcast_5index_index(PyArrayMultiIterObject *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":292 + * cdef inline npy_intp index(self) noexcept nogil: + * """The current (1-d) index into the broadcasted result.""" + * return PyArray_MultiIter_INDEX(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_INDEX(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":289 + * return PyArray_MultiIter_SIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp index(self) noexcept nogil: + * """The current (1-d) index into the broadcasted result.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":294 + * return PyArray_MultiIter_INDEX(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline int nd(self) noexcept nogil: + * """The number of dimensions in the broadcasted result.""" +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_9broadcast_2nd_nd(PyArrayMultiIterObject *__pyx_v_self) { + int __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":297 + * cdef inline int nd(self) noexcept nogil: + * """The number of dimensions in the broadcasted result.""" + * return PyArray_MultiIter_NDIM(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_NDIM(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":294 + * return PyArray_MultiIter_INDEX(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline int nd(self) noexcept nogil: + * """The number of dimensions in the broadcasted result.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":299 + * return PyArray_MultiIter_NDIM(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp* dimensions(self) noexcept nogil: + * """The shape of the broadcasted result.""" +*/ + +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_9broadcast_10dimensions_dimensions(PyArrayMultiIterObject *__pyx_v_self) { + npy_intp *__pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":302 + * cdef inline npy_intp* dimensions(self) noexcept nogil: + * """The shape of the broadcasted result.""" + * return PyArray_MultiIter_DIMS(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_MultiIter_DIMS(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":299 + * return PyArray_MultiIter_NDIM(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp* dimensions(self) noexcept nogil: + * """The shape of the broadcasted result.""" +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":304 + * return PyArray_MultiIter_DIMS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline void** iters(self) noexcept nogil: + * """An array of iterator objects that holds the iterators for the arrays to be broadcast together. +*/ + +static CYTHON_INLINE void **__pyx_f_5numpy_9broadcast_5iters_iters(PyArrayMultiIterObject *__pyx_v_self) { + void **__pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":308 + * """An array of iterator objects that holds the iterators for the arrays to be broadcast together. + * On return, the iterators are adjusted for broadcasting.""" + * return PyArray_MultiIter_ITERS(self) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyArray_MultiIter_ITERS(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":304 + * return PyArray_MultiIter_DIMS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline void** iters(self) noexcept nogil: + * """An array of iterator objects that holds the iterators for the arrays to be broadcast together. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":322 + * # Instead, we use properties that map to the corresponding C-API functions. + * + * @property # <<<<<<<<<<<<<< + * cdef inline PyObject* base(self) noexcept nogil: + * """Returns a borrowed reference to the object owning the data/memory. +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_7ndarray_4base_base(PyArrayObject *__pyx_v_self) { + PyObject *__pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":326 + * """Returns a borrowed reference to the object owning the data/memory. + * """ + * return PyArray_BASE(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_BASE(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":322 + * # Instead, we use properties that map to the corresponding C-API functions. + * + * @property # <<<<<<<<<<<<<< + * cdef inline PyObject* base(self) noexcept nogil: + * """Returns a borrowed reference to the object owning the data/memory. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":328 + * return PyArray_BASE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline dtype descr(self): + * """Returns an owned reference to the dtype of the array. +*/ + +static CYTHON_INLINE PyArray_Descr *__pyx_f_5numpy_7ndarray_5descr_descr(PyArrayObject *__pyx_v_self) { + PyArray_Descr *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyArray_Descr *__pyx_t_1; + __Pyx_RefNannySetupContext("descr", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":332 + * """Returns an owned reference to the dtype of the array. + * """ + * return PyArray_DESCR(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __Pyx_XDECREF((PyObject *)__pyx_r); + __pyx_t_1 = PyArray_DESCR(__pyx_v_self); + __Pyx_INCREF((PyObject *)((PyArray_Descr *)__pyx_t_1)); + __pyx_r = ((PyArray_Descr *)__pyx_t_1); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":328 + * return PyArray_BASE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline dtype descr(self): + * """Returns an owned reference to the dtype of the array. +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF((PyObject *)__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":334 + * return PyArray_DESCR(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline int ndim(self) noexcept nogil: + * """Returns the number of dimensions in the array. +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_7ndarray_4ndim_ndim(PyArrayObject *__pyx_v_self) { + int __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":338 + * """Returns the number of dimensions in the array. + * """ + * return PyArray_NDIM(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_NDIM(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":334 + * return PyArray_DESCR(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline int ndim(self) noexcept nogil: + * """Returns the number of dimensions in the array. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":340 + * return PyArray_NDIM(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp *shape(self) noexcept nogil: + * """Returns a pointer to the dimensions/shape of the array. +*/ + +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_5shape_shape(PyArrayObject *__pyx_v_self) { + npy_intp *__pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":346 + * Can return NULL for 0-dimensional arrays. + * """ + * return PyArray_DIMS(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_DIMS(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":340 + * return PyArray_NDIM(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp *shape(self) noexcept nogil: + * """Returns a pointer to the dimensions/shape of the array. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":348 + * return PyArray_DIMS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp *strides(self) noexcept nogil: + * """Returns a pointer to the strides of the array. +*/ + +static CYTHON_INLINE npy_intp *__pyx_f_5numpy_7ndarray_7strides_strides(PyArrayObject *__pyx_v_self) { + npy_intp *__pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":353 + * The number of elements matches the number of dimensions of the array (ndim). + * """ + * return PyArray_STRIDES(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_STRIDES(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":348 + * return PyArray_DIMS(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp *strides(self) noexcept nogil: + * """Returns a pointer to the strides of the array. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":355 + * return PyArray_STRIDES(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp size(self) noexcept nogil: + * """Returns the total size (in number of elements) of the array. +*/ + +static CYTHON_INLINE npy_intp __pyx_f_5numpy_7ndarray_4size_size(PyArrayObject *__pyx_v_self) { + npy_intp __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":359 + * """Returns the total size (in number of elements) of the array. + * """ + * return PyArray_SIZE(self) # <<<<<<<<<<<<<< + * + * @property +*/ + __pyx_r = PyArray_SIZE(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":355 + * return PyArray_STRIDES(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline npy_intp size(self) noexcept nogil: + * """Returns the total size (in number of elements) of the array. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":361 + * return PyArray_SIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline char* data(self) noexcept nogil: + * """The pointer to the data buffer as a char*. +*/ + +static CYTHON_INLINE char *__pyx_f_5numpy_7ndarray_4data_data(PyArrayObject *__pyx_v_self) { + char *__pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":368 + * of `PyArray_DATA()` instead, which returns a 'void*'. + * """ + * return PyArray_BYTES(self) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyArray_BYTES(__pyx_v_self); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":361 + * return PyArray_SIZE(self) + * + * @property # <<<<<<<<<<<<<< + * cdef inline char* data(self) noexcept nogil: + * """The pointer to the data buffer as a char*. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":776 + * ctypedef long double complex clongdouble_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew1(PyObject *__pyx_v_a) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew1", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":777 + * + * cdef inline object PyArray_MultiIterNew1(a): + * return PyArray_MultiIterNew(1, a) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew2(a, b): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(1, ((void *)__pyx_v_a)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 777, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":776 + * ctypedef long double complex clongdouble_t + * + * cdef inline object PyArray_MultiIterNew1(a): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(1, a) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":779 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew2(PyObject *__pyx_v_a, PyObject *__pyx_v_b) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew2", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":780 + * + * cdef inline object PyArray_MultiIterNew2(a, b): + * return PyArray_MultiIterNew(2, a, b) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(2, ((void *)__pyx_v_a), ((void *)__pyx_v_b)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":779 + * return PyArray_MultiIterNew(1, a) + * + * cdef inline object PyArray_MultiIterNew2(a, b): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(2, a, b) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":782 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew3(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew3", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":783 + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): + * return PyArray_MultiIterNew(3, a, b, c) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(3, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 783, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":782 + * return PyArray_MultiIterNew(2, a, b) + * + * cdef inline object PyArray_MultiIterNew3(a, b, c): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(3, a, b, c) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew3", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":785 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew4(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew4", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":786 + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): + * return PyArray_MultiIterNew(4, a, b, c, d) # <<<<<<<<<<<<<< + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(4, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 786, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":785 + * return PyArray_MultiIterNew(3, a, b, c) + * + * cdef inline object PyArray_MultiIterNew4(a, b, c, d): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(4, a, b, c, d) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew4", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":788 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyArray_MultiIterNew5(PyObject *__pyx_v_a, PyObject *__pyx_v_b, PyObject *__pyx_v_c, PyObject *__pyx_v_d, PyObject *__pyx_v_e) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("PyArray_MultiIterNew5", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":789 + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): + * return PyArray_MultiIterNew(5, a, b, c, d, e) # <<<<<<<<<<<<<< + * + * cdef inline tuple PyDataType_SHAPE(dtype d): +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = PyArray_MultiIterNew(5, ((void *)__pyx_v_a), ((void *)__pyx_v_b), ((void *)__pyx_v_c), ((void *)__pyx_v_d), ((void *)__pyx_v_e)); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":788 + * return PyArray_MultiIterNew(4, a, b, c, d) + * + * cdef inline object PyArray_MultiIterNew5(a, b, c, d, e): # <<<<<<<<<<<<<< + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_AddTraceback("numpy.PyArray_MultiIterNew5", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":791 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_PyDataType_SHAPE(PyArray_Descr *__pyx_v_d) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2; + __Pyx_RefNannySetupContext("PyDataType_SHAPE", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":792 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: +*/ + __pyx_t_1 = PyDataType_HASSUBARRAY(__pyx_v_d); + if (__pyx_t_1) { + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":793 + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape # <<<<<<<<<<<<<< + * else: + * return () +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __pyx_f_5numpy_5dtype_8subarray_subarray(__pyx_v_d)->shape; + __Pyx_INCREF(((PyObject*)__pyx_t_2)); + __pyx_r = ((PyObject*)__pyx_t_2); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":792 + * + * cdef inline tuple PyDataType_SHAPE(dtype d): + * if PyDataType_HASSUBARRAY(d): # <<<<<<<<<<<<<< + * return d.subarray.shape + * else: +*/ + } + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":795 + * return d.subarray.shape + * else: + * return () # <<<<<<<<<<<<<< + * + * +*/ + /*else*/ { + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(__pyx_mstate_global->__pyx_empty_tuple); + __pyx_r = __pyx_mstate_global->__pyx_empty_tuple; + goto __pyx_L0; + } + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":791 + * return PyArray_MultiIterNew(5, a, b, c, d, e) + * + * cdef inline tuple PyDataType_SHAPE(dtype d): # <<<<<<<<<<<<<< + * if PyDataType_HASSUBARRAY(d): + * return d.subarray.shape +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":994 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base) except *: # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) +*/ + +static CYTHON_INLINE void __pyx_f_5numpy_set_array_base(PyArrayObject *__pyx_v_arr, PyObject *__pyx_v_base) { + int __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":995 + * + * cdef inline void set_array_base(ndarray arr, object base) except *: + * Py_INCREF(base) # important to do this before stealing the reference below! # <<<<<<<<<<<<<< + * PyArray_SetBaseObject(arr, base) + * +*/ + Py_INCREF(__pyx_v_base); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":996 + * cdef inline void set_array_base(ndarray arr, object base) except *: + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) # <<<<<<<<<<<<<< + * + * cdef inline object get_array_base(ndarray arr): +*/ + __pyx_t_1 = PyArray_SetBaseObject(__pyx_v_arr, __pyx_v_base); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(2, 996, __pyx_L1_error) + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":994 + * int _import_umath() except -1 + * + * cdef inline void set_array_base(ndarray arr, object base) except *: # <<<<<<<<<<<<<< + * Py_INCREF(base) # important to do this before stealing the reference below! + * PyArray_SetBaseObject(arr, base) +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("numpy.set_array_base", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":998 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: +*/ + +static CYTHON_INLINE PyObject *__pyx_f_5numpy_get_array_base(PyArrayObject *__pyx_v_arr) { + PyObject *__pyx_v_base; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + __Pyx_RefNannySetupContext("get_array_base", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":999 + * + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) # <<<<<<<<<<<<<< + * if base is NULL: + * return None +*/ + __pyx_v_base = PyArray_BASE(__pyx_v_arr); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1000 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base +*/ + __pyx_t_1 = (__pyx_v_base == NULL); + if (__pyx_t_1) { + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1001 + * base = PyArray_BASE(arr) + * if base is NULL: + * return None # <<<<<<<<<<<<<< + * return base + * +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1000 + * cdef inline object get_array_base(ndarray arr): + * base = PyArray_BASE(arr) + * if base is NULL: # <<<<<<<<<<<<<< + * return None + * return base +*/ + } + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1002 + * if base is NULL: + * return None + * return base # <<<<<<<<<<<<<< + * + * # Versions of the import_* functions which are more suitable for +*/ + __Pyx_XDECREF(__pyx_r); + __Pyx_INCREF(((PyObject *)__pyx_v_base)); + __pyx_r = ((PyObject *)__pyx_v_base); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":998 + * PyArray_SetBaseObject(arr, base) + * + * cdef inline object get_array_base(ndarray arr): # <<<<<<<<<<<<<< + * base = PyArray_BASE(arr) + * if base is NULL: +*/ + + /* function exit code */ + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1006 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_import_array(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_array", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1007 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1008 + * cdef inline int import_array() except -1: + * try: + * __pyx_import_array() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy._core.multiarray failed to import") +*/ + __pyx_t_4 = _import_array(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 1008, __pyx_L3_error) + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1007 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1009 + * try: + * __pyx_import_array() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy._core.multiarray failed to import") + * +*/ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 1009, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1010 + * __pyx_import_array() + * except Exception: + * raise ImportError("numpy._core.multiarray failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_umath() except -1: +*/ + __pyx_t_9 = NULL; + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_multiarray_failed_to}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1010, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(2, 1010, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1007 + * # Cython code. + * cdef inline int import_array() except -1: + * try: # <<<<<<<<<<<<<< + * __pyx_import_array() + * except Exception: +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1006 + * # Versions of the import_* functions which are more suitable for + * # Cython code. + * cdef inline int import_array() except -1: # <<<<<<<<<<<<<< + * try: + * __pyx_import_array() +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("numpy.import_array", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1012 + * raise ImportError("numpy._core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_import_umath(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_umath", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1013 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1014 + * cdef inline int import_umath() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy._core.umath failed to import") +*/ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 1014, __pyx_L3_error) + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1013 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1015 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy._core.umath failed to import") + * +*/ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 1015, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1016 + * _import_umath() + * except Exception: + * raise ImportError("numpy._core.umath failed to import") # <<<<<<<<<<<<<< + * + * cdef inline int import_ufunc() except -1: +*/ + __pyx_t_9 = NULL; + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_umath_failed_to_impo}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1016, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(2, 1016, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1013 + * + * cdef inline int import_umath() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1012 + * raise ImportError("numpy._core.multiarray failed to import") + * + * cdef inline int import_umath() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("numpy.import_umath", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1018 + * raise ImportError("numpy._core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_import_ufunc(void) { + int __pyx_r; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + int __pyx_t_4; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + size_t __pyx_t_10; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("import_ufunc", 0); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1019 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1020 + * cdef inline int import_ufunc() except -1: + * try: + * _import_umath() # <<<<<<<<<<<<<< + * except Exception: + * raise ImportError("numpy._core.umath failed to import") +*/ + __pyx_t_4 = _import_umath(); if (unlikely(__pyx_t_4 == ((int)-1))) __PYX_ERR(2, 1020, __pyx_L3_error) + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1019 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L8_try_end; + __pyx_L3_error:; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1021 + * try: + * _import_umath() + * except Exception: # <<<<<<<<<<<<<< + * raise ImportError("numpy._core.umath failed to import") + * +*/ + __pyx_t_4 = __Pyx_PyErr_ExceptionMatches(((PyObject *)(((PyTypeObject*)PyExc_Exception)))); + if (__pyx_t_4) { + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + if (__Pyx_GetException(&__pyx_t_5, &__pyx_t_6, &__pyx_t_7) < 0) __PYX_ERR(2, 1021, __pyx_L5_except_error) + __Pyx_XGOTREF(__pyx_t_5); + __Pyx_XGOTREF(__pyx_t_6); + __Pyx_XGOTREF(__pyx_t_7); + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1022 + * _import_umath() + * except Exception: + * raise ImportError("numpy._core.umath failed to import") # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_9 = NULL; + __pyx_t_10 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_mstate_global->__pyx_kp_u_numpy__core_umath_failed_to_impo}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ImportError)), __pyx_callargs+__pyx_t_10, (2-__pyx_t_10) | (__pyx_t_10*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(2, 1022, __pyx_L5_except_error) + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(2, 1022, __pyx_L5_except_error) + } + goto __pyx_L5_except_error; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1019 + * + * cdef inline int import_ufunc() except -1: + * try: # <<<<<<<<<<<<<< + * _import_umath() + * except Exception: +*/ + __pyx_L5_except_error:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + goto __pyx_L1_error; + __pyx_L8_try_end:; + } + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1018 + * raise ImportError("numpy._core.umath failed to import") + * + * cdef inline int import_ufunc() except -1: # <<<<<<<<<<<<<< + * try: + * _import_umath() +*/ + + /* function exit code */ + __pyx_r = 0; + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_AddTraceback("numpy.import_ufunc", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1025 + * + * + * cdef inline bint is_timedelta64_object(object obj) noexcept: # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_is_timedelta64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1037 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyTimedeltaArrType_Type) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyTimedeltaArrType_Type)); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1025 + * + * + * cdef inline bint is_timedelta64_object(object obj) noexcept: # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.timedelta64)` +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1040 + * + * + * cdef inline bint is_datetime64_object(object obj) noexcept: # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` +*/ + +static CYTHON_INLINE int __pyx_f_5numpy_is_datetime64_object(PyObject *__pyx_v_obj) { + int __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1052 + * bool + * """ + * return PyObject_TypeCheck(obj, &PyDatetimeArrType_Type) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = PyObject_TypeCheck(__pyx_v_obj, (&PyDatetimeArrType_Type)); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1040 + * + * + * cdef inline bint is_datetime64_object(object obj) noexcept: # <<<<<<<<<<<<<< + * """ + * Cython equivalent of `isinstance(obj, np.datetime64)` +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1055 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object +*/ + +static CYTHON_INLINE npy_datetime __pyx_f_5numpy_get_datetime64_value(PyObject *__pyx_v_obj) { + npy_datetime __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1062 + * also needed. That can be found using `get_datetime64_unit`. + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = ((PyDatetimeScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1055 + * + * + * cdef inline npy_datetime get_datetime64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy datetime64 object +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1065 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object +*/ + +static CYTHON_INLINE npy_timedelta __pyx_f_5numpy_get_timedelta64_value(PyObject *__pyx_v_obj) { + npy_timedelta __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1069 + * returns the int64 value underlying scalar numpy timedelta64 object + * """ + * return (obj).obval # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = ((PyTimedeltaScalarObject *)__pyx_v_obj)->obval; + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1065 + * + * + * cdef inline npy_timedelta get_timedelta64_value(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the int64 value underlying scalar numpy timedelta64 object +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1072 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. +*/ + +static CYTHON_INLINE NPY_DATETIMEUNIT __pyx_f_5numpy_get_datetime64_unit(PyObject *__pyx_v_obj) { + NPY_DATETIMEUNIT __pyx_r; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1076 + * returns the unit part of the dtype for a numpy datetime64 object. + * """ + * return (obj).obmeta.base # <<<<<<<<<<<<<< + * + * +*/ + __pyx_r = ((NPY_DATETIMEUNIT)((PyDatetimeScalarObject *)__pyx_v_obj)->obmeta.base); + goto __pyx_L0; + + /* "../../../../users/azhan378/.cache/uv/builds-v0/.tmpj8WXau/lib/python3.11/site-packages/numpy/__init__.cython-30.pxd":1072 + * + * + * cdef inline NPY_DATETIMEUNIT get_datetime64_unit(object obj) noexcept nogil: # <<<<<<<<<<<<<< + * """ + * returns the unit part of the dtype for a numpy datetime64 object. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "cssm.pyx":19 + * DTYPE = np.float32 + * + * cdef set_seed(random_state): # <<<<<<<<<<<<<< + * """ + * Set the random seed for the simulation. +*/ + +static PyObject *__pyx_f_4cssm_set_seed(PyObject *__pyx_v_random_state) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + int __pyx_t_1; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + unsigned int __pyx_t_4; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("set_seed", 0); + + /* "cssm.pyx":28 + * This function sets a random state globally for the simulation. + * """ + * if random_state is None: # <<<<<<<<<<<<<< + * return srand(time(NULL)) + * if isinstance(random_state, numbers.Integral): +*/ + __pyx_t_1 = (__pyx_v_random_state == Py_None); + if (__pyx_t_1) { + + /* "cssm.pyx":29 + * """ + * if random_state is None: + * return srand(time(NULL)) # <<<<<<<<<<<<<< + * if isinstance(random_state, numbers.Integral): + * return srand(random_state) +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_void_to_None(srand(time(NULL))); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 29, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "cssm.pyx":28 + * This function sets a random state globally for the simulation. + * """ + * if random_state is None: # <<<<<<<<<<<<<< + * return srand(time(NULL)) + * if isinstance(random_state, numbers.Integral): +*/ + } + + /* "cssm.pyx":30 + * if random_state is None: + * return srand(time(NULL)) + * if isinstance(random_state, numbers.Integral): # <<<<<<<<<<<<<< + * return srand(random_state) + * +*/ + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_numbers); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_Integral); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_1 = PyObject_IsInstance(__pyx_v_random_state, __pyx_t_3); if (unlikely(__pyx_t_1 == ((int)-1))) __PYX_ERR(0, 30, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_1) { + + /* "cssm.pyx":31 + * return srand(time(NULL)) + * if isinstance(random_state, numbers.Integral): + * return srand(random_state) # <<<<<<<<<<<<<< + * + * # Method to draw random samples from a gaussian +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyLong_As_unsigned_int(__pyx_v_random_state); if (unlikely((__pyx_t_4 == (unsigned int)-1) && PyErr_Occurred())) __PYX_ERR(0, 31, __pyx_L1_error) + __pyx_t_3 = __Pyx_void_to_None(srand(__pyx_t_4)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 31, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "cssm.pyx":30 + * if random_state is None: + * return srand(time(NULL)) + * if isinstance(random_state, numbers.Integral): # <<<<<<<<<<<<<< + * return srand(random_state) + * +*/ + } + + /* "cssm.pyx":19 + * DTYPE = np.float32 + * + * cdef set_seed(random_state): # <<<<<<<<<<<<<< + * """ + * Set the random seed for the simulation. +*/ + + /* function exit code */ + __pyx_r = Py_None; __Pyx_INCREF(Py_None); + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_AddTraceback("cssm.set_seed", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = 0; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":34 + * + * # Method to draw random samples from a gaussian + * cdef float random_uniform(): # <<<<<<<<<<<<<< + * """ + * Generate a random float from a uniform distribution between 0 and 1. +*/ + +static float __pyx_f_4cssm_random_uniform(void) { + float __pyx_v_r; + float __pyx_r; + + /* "cssm.pyx":41 + * float: A random float between 0 and 1. + * """ + * cdef float r = rand() # <<<<<<<<<<<<<< + * return r / RAND_MAX + * +*/ + __pyx_v_r = rand(); + + /* "cssm.pyx":42 + * """ + * cdef float r = rand() + * return r / RAND_MAX # <<<<<<<<<<<<<< + * + * cdef float random_exponential(): +*/ + __pyx_r = (__pyx_v_r / ((float)RAND_MAX)); + goto __pyx_L0; + + /* "cssm.pyx":34 + * + * # Method to draw random samples from a gaussian + * cdef float random_uniform(): # <<<<<<<<<<<<<< + * """ + * Generate a random float from a uniform distribution between 0 and 1. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "cssm.pyx":44 + * return r / RAND_MAX + * + * cdef float random_exponential(): # <<<<<<<<<<<<<< + * """ + * Generate a random float from an exponential distribution with rate 1. +*/ + +static float __pyx_f_4cssm_random_exponential(void) { + float __pyx_r; + float __pyx_t_1; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "cssm.pyx":51 + * float: A random float from an exponential distribution. + * """ + * return - log(random_uniform()) # <<<<<<<<<<<<<< + * + * cdef float random_stable(float alpha): +*/ + __pyx_t_1 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_1 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 51, __pyx_L1_error) + __pyx_r = (-log(__pyx_t_1)); + goto __pyx_L0; + + /* "cssm.pyx":44 + * return r / RAND_MAX + * + * cdef float random_exponential(): # <<<<<<<<<<<<<< + * """ + * Generate a random float from an exponential distribution with rate 1. +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("cssm.random_exponential", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "cssm.pyx":53 + * return - log(random_uniform()) + * + * cdef float random_stable(float alpha): # <<<<<<<<<<<<<< + * """ + * Generate a random float from a stable distribution. +*/ + +static float __pyx_f_4cssm_random_stable(float __pyx_v_alpha) { + float __pyx_v_eta; + float __pyx_v_u; + float __pyx_v_w; + float __pyx_v_x; + float __pyx_r; + float __pyx_t_1; + int __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "cssm.pyx":65 + * cdef float eta, u, w, x + * + * u = M_PI * (random_uniform() - 0.5) # <<<<<<<<<<<<<< + * w = random_exponential() + * +*/ + __pyx_t_1 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_1 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 65, __pyx_L1_error) + __pyx_v_u = (M_PI * (__pyx_t_1 - 0.5)); + + /* "cssm.pyx":66 + * + * u = M_PI * (random_uniform() - 0.5) + * w = random_exponential() # <<<<<<<<<<<<<< + * + * if alpha == 1.0: +*/ + __pyx_t_1 = __pyx_f_4cssm_random_exponential(); if (unlikely(__pyx_t_1 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 66, __pyx_L1_error) + __pyx_v_w = __pyx_t_1; + + /* "cssm.pyx":68 + * w = random_exponential() + * + * if alpha == 1.0: # <<<<<<<<<<<<<< + * eta = M_PI_2 # useless but kept to remain faithful to wikipedia entry + * x = (1.0 / eta) * ((M_PI_2) * tan(u)) +*/ + __pyx_t_2 = (__pyx_v_alpha == 1.0); + if (__pyx_t_2) { + + /* "cssm.pyx":69 + * + * if alpha == 1.0: + * eta = M_PI_2 # useless but kept to remain faithful to wikipedia entry # <<<<<<<<<<<<<< + * x = (1.0 / eta) * ((M_PI_2) * tan(u)) + * else: +*/ + __pyx_v_eta = M_PI_2; + + /* "cssm.pyx":70 + * if alpha == 1.0: + * eta = M_PI_2 # useless but kept to remain faithful to wikipedia entry + * x = (1.0 / eta) * ((M_PI_2) * tan(u)) # <<<<<<<<<<<<<< + * else: + * x = (sin(alpha * u) / (pow(cos(u), 1 / alpha))) * pow(cos(u - (alpha * u)) / w, (1.0 - alpha) / alpha) +*/ + __pyx_v_x = ((1.0 / ((double)__pyx_v_eta)) * (M_PI_2 * tan(__pyx_v_u))); + + /* "cssm.pyx":68 + * w = random_exponential() + * + * if alpha == 1.0: # <<<<<<<<<<<<<< + * eta = M_PI_2 # useless but kept to remain faithful to wikipedia entry + * x = (1.0 / eta) * ((M_PI_2) * tan(u)) +*/ + goto __pyx_L3; + } + + /* "cssm.pyx":72 + * x = (1.0 / eta) * ((M_PI_2) * tan(u)) + * else: + * x = (sin(alpha * u) / (pow(cos(u), 1 / alpha))) * pow(cos(u - (alpha * u)) / w, (1.0 - alpha) / alpha) # <<<<<<<<<<<<<< + * return x + * +*/ + /*else*/ { + __pyx_v_x = ((sin((__pyx_v_alpha * __pyx_v_u)) / pow(cos(__pyx_v_u), (1.0 / __pyx_v_alpha))) * pow((cos((__pyx_v_u - (__pyx_v_alpha * __pyx_v_u))) / ((double)__pyx_v_w)), ((1.0 - __pyx_v_alpha) / ((double)__pyx_v_alpha)))); + } + __pyx_L3:; + + /* "cssm.pyx":73 + * else: + * x = (sin(alpha * u) / (pow(cos(u), 1 / alpha))) * pow(cos(u - (alpha * u)) / w, (1.0 - alpha) / alpha) + * return x # <<<<<<<<<<<<<< + * + * cdef float[:] draw_random_stable(int n, float alpha): +*/ + __pyx_r = __pyx_v_x; + goto __pyx_L0; + + /* "cssm.pyx":53 + * return - log(random_uniform()) + * + * cdef float random_stable(float alpha): # <<<<<<<<<<<<<< + * """ + * Generate a random float from a stable distribution. +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("cssm.random_stable", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "cssm.pyx":75 + * return x + * + * cdef float[:] draw_random_stable(int n, float alpha): # <<<<<<<<<<<<<< + * """ + * Generate an array of random floats from a stable distribution. +*/ + +static __Pyx_memviewslice __pyx_f_4cssm_draw_random_stable(int __pyx_v_n, float __pyx_v_alpha) { + int __pyx_v_i; + __Pyx_memviewslice __pyx_v_result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_r = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_memviewslice __pyx_t_8 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_9; + int __pyx_t_10; + int __pyx_t_11; + float __pyx_t_12; + Py_ssize_t __pyx_t_13; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("draw_random_stable", 0); + + /* "cssm.pyx":87 + * """ + * cdef int i + * cdef float[:] result = np.zeros(n, dtype = DTYPE) # <<<<<<<<<<<<<< + * + * for i in range(n): +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 87, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 87, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_result = __pyx_t_8; + __pyx_t_8.memview = NULL; + __pyx_t_8.data = NULL; + + /* "cssm.pyx":89 + * cdef float[:] result = np.zeros(n, dtype = DTYPE) + * + * for i in range(n): # <<<<<<<<<<<<<< + * result[i] = random_stable(alpha) + * return result +*/ + __pyx_t_9 = __pyx_v_n; + __pyx_t_10 = __pyx_t_9; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "cssm.pyx":90 + * + * for i in range(n): + * result[i] = random_stable(alpha) # <<<<<<<<<<<<<< + * return result + * +*/ + __pyx_t_12 = __pyx_f_4cssm_random_stable(__pyx_v_alpha); if (unlikely(__pyx_t_12 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 90, __pyx_L1_error) + __pyx_t_13 = __pyx_v_i; + *((float *) ( /* dim=0 */ (__pyx_v_result.data + __pyx_t_13 * __pyx_v_result.strides[0]) )) = __pyx_t_12; + } + + /* "cssm.pyx":91 + * for i in range(n): + * result[i] = random_stable(alpha) + * return result # <<<<<<<<<<<<<< + * + * cdef float random_gaussian(): +*/ + __PYX_INC_MEMVIEW(&__pyx_v_result, 1); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "cssm.pyx":75 + * return x + * + * cdef float[:] draw_random_stable(int n, float alpha): # <<<<<<<<<<<<<< + * """ + * Generate an array of random floats from a stable distribution. +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_8, 1); + __pyx_r.data = NULL; + __pyx_r.memview = NULL; + __Pyx_AddTraceback("cssm.draw_random_stable", __pyx_clineno, __pyx_lineno, __pyx_filename); + goto __pyx_L2; + __pyx_L0:; + if (unlikely(!__pyx_r.memview)) { + PyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized"); + } + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_result, 1); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":93 + * return result + * + * cdef float random_gaussian(): # <<<<<<<<<<<<<< + * """ + * Generate a random float from a standard normal distribution. +*/ + +static float __pyx_f_4cssm_random_gaussian(void) { + float __pyx_v_x1; + float __pyx_v_x2; + float __pyx_v_w; + float __pyx_r; + int __pyx_t_1; + float __pyx_t_2; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "cssm.pyx":101 + * """ + * cdef float x1, x2, w + * w = 2.0 # <<<<<<<<<<<<<< + * + * while(w >= 1.0): +*/ + __pyx_v_w = 2.0; + + /* "cssm.pyx":103 + * w = 2.0 + * + * while(w >= 1.0): # <<<<<<<<<<<<<< + * x1 = 2.0 * random_uniform() - 1.0 + * x2 = 2.0 * random_uniform() - 1.0 +*/ + while (1) { + __pyx_t_1 = (__pyx_v_w >= 1.0); + if (!__pyx_t_1) break; + + /* "cssm.pyx":104 + * + * while(w >= 1.0): + * x1 = 2.0 * random_uniform() - 1.0 # <<<<<<<<<<<<<< + * x2 = 2.0 * random_uniform() - 1.0 + * w = x1 * x1 + x2 * x2 +*/ + __pyx_t_2 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_2 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 104, __pyx_L1_error) + __pyx_v_x1 = ((2.0 * __pyx_t_2) - 1.0); + + /* "cssm.pyx":105 + * while(w >= 1.0): + * x1 = 2.0 * random_uniform() - 1.0 + * x2 = 2.0 * random_uniform() - 1.0 # <<<<<<<<<<<<<< + * w = x1 * x1 + x2 * x2 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_2 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 105, __pyx_L1_error) + __pyx_v_x2 = ((2.0 * __pyx_t_2) - 1.0); + + /* "cssm.pyx":106 + * x1 = 2.0 * random_uniform() - 1.0 + * x2 = 2.0 * random_uniform() - 1.0 + * w = x1 * x1 + x2 * x2 # <<<<<<<<<<<<<< + * + * w = ((-2.0 * log(w)) / w) ** 0.5 +*/ + __pyx_v_w = ((__pyx_v_x1 * __pyx_v_x1) + (__pyx_v_x2 * __pyx_v_x2)); + } + + /* "cssm.pyx":108 + * w = x1 * x1 + x2 * x2 + * + * w = ((-2.0 * log(w)) / w) ** 0.5 # <<<<<<<<<<<<<< + * return x1 * w + * +*/ + __pyx_v_w = pow(((-2.0 * log(__pyx_v_w)) / ((double)__pyx_v_w)), 0.5); + + /* "cssm.pyx":109 + * + * w = ((-2.0 * log(w)) / w) ** 0.5 + * return x1 * w # <<<<<<<<<<<<<< + * + * cdef int sign(float x): +*/ + __pyx_r = (__pyx_v_x1 * __pyx_v_w); + goto __pyx_L0; + + /* "cssm.pyx":93 + * return result + * + * cdef float random_gaussian(): # <<<<<<<<<<<<<< + * """ + * Generate a random float from a standard normal distribution. +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_AddTraceback("cssm.random_gaussian", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = -1; + __pyx_L0:; + return __pyx_r; +} + +/* "cssm.pyx":111 + * return x1 * w + * + * cdef int sign(float x): # <<<<<<<<<<<<<< + * """ + * Determine the sign of a float. +*/ + +static int __pyx_f_4cssm_sign(float __pyx_v_x) { + int __pyx_r; + + /* "cssm.pyx":121 + * int: 1 if x is positive, -1 if x is negative, 0 if x is zero. + * """ + * return (x > 0) - (x < 0) # <<<<<<<<<<<<<< + * + * cdef float csum(float[:] x): +*/ + __pyx_r = ((__pyx_v_x > 0.0) - (__pyx_v_x < 0.0)); + goto __pyx_L0; + + /* "cssm.pyx":111 + * return x1 * w + * + * cdef int sign(float x): # <<<<<<<<<<<<<< + * """ + * Determine the sign of a float. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "cssm.pyx":123 + * return (x > 0) - (x < 0) + * + * cdef float csum(float[:] x): # <<<<<<<<<<<<<< + * """ + * Calculate the sum of elements in an array. +*/ + +static float __pyx_f_4cssm_csum(__Pyx_memviewslice __pyx_v_x) { + int __pyx_v_i; + int __pyx_v_n; + float __pyx_v_total; + float __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + + /* "cssm.pyx":134 + * """ + * cdef int i + * cdef int n = x.shape[0] # <<<<<<<<<<<<<< + * cdef float total = 0 + * +*/ + __pyx_v_n = (__pyx_v_x.shape[0]); + + /* "cssm.pyx":135 + * cdef int i + * cdef int n = x.shape[0] + * cdef float total = 0 # <<<<<<<<<<<<<< + * + * for i in range(n): +*/ + __pyx_v_total = 0.0; + + /* "cssm.pyx":137 + * cdef float total = 0 + * + * for i in range(n): # <<<<<<<<<<<<<< + * total += x[i] + * +*/ + __pyx_t_1 = __pyx_v_n; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "cssm.pyx":138 + * + * for i in range(n): + * total += x[i] # <<<<<<<<<<<<<< + * + * return total +*/ + __pyx_t_4 = __pyx_v_i; + __pyx_v_total = (__pyx_v_total + (*((float *) ( /* dim=0 */ (__pyx_v_x.data + __pyx_t_4 * __pyx_v_x.strides[0]) )))); + } + + /* "cssm.pyx":140 + * total += x[i] + * + * return total # <<<<<<<<<<<<<< + * + * ## @cythonboundscheck(False) +*/ + __pyx_r = __pyx_v_total; + goto __pyx_L0; + + /* "cssm.pyx":123 + * return (x > 0) - (x < 0) + * + * cdef float csum(float[:] x): # <<<<<<<<<<<<<< + * """ + * Calculate the sum of elements in an array. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "cssm.pyx":143 + * + * ## @cythonboundscheck(False) + * cdef void assign_random_gaussian_pair(float[:] out, int assign_ix): # <<<<<<<<<<<<<< + * """ + * Generate a pair of random floats from a standard normal distribution and assign them to an array. +*/ + +static void __pyx_f_4cssm_assign_random_gaussian_pair(__Pyx_memviewslice __pyx_v_out, int __pyx_v_assign_ix) { + float __pyx_v_x1; + float __pyx_v_x2; + float __pyx_v_w; + int __pyx_t_1; + float __pyx_t_2; + Py_ssize_t __pyx_t_3; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + + /* "cssm.pyx":152 + * """ + * cdef float x1, x2, w + * w = 2.0 # <<<<<<<<<<<<<< + * + * while(w >= 1.0): +*/ + __pyx_v_w = 2.0; + + /* "cssm.pyx":154 + * w = 2.0 + * + * while(w >= 1.0): # <<<<<<<<<<<<<< + * x1 = (2.0 * random_uniform()) - 1.0 + * x2 = (2.0 * random_uniform()) - 1.0 +*/ + while (1) { + __pyx_t_1 = (__pyx_v_w >= 1.0); + if (!__pyx_t_1) break; + + /* "cssm.pyx":155 + * + * while(w >= 1.0): + * x1 = (2.0 * random_uniform()) - 1.0 # <<<<<<<<<<<<<< + * x2 = (2.0 * random_uniform()) - 1.0 + * w = (x1 * x1) + (x2 * x2) +*/ + __pyx_t_2 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_2 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 155, __pyx_L1_error) + __pyx_v_x1 = ((2.0 * __pyx_t_2) - 1.0); + + /* "cssm.pyx":156 + * while(w >= 1.0): + * x1 = (2.0 * random_uniform()) - 1.0 + * x2 = (2.0 * random_uniform()) - 1.0 # <<<<<<<<<<<<<< + * w = (x1 * x1) + (x2 * x2) + * +*/ + __pyx_t_2 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_2 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 156, __pyx_L1_error) + __pyx_v_x2 = ((2.0 * __pyx_t_2) - 1.0); + + /* "cssm.pyx":157 + * x1 = (2.0 * random_uniform()) - 1.0 + * x2 = (2.0 * random_uniform()) - 1.0 + * w = (x1 * x1) + (x2 * x2) # <<<<<<<<<<<<<< + * + * w = ((-2.0 * log(w)) / w) ** 0.5 +*/ + __pyx_v_w = ((__pyx_v_x1 * __pyx_v_x1) + (__pyx_v_x2 * __pyx_v_x2)); + } + + /* "cssm.pyx":159 + * w = (x1 * x1) + (x2 * x2) + * + * w = ((-2.0 * log(w)) / w) ** 0.5 # <<<<<<<<<<<<<< + * out[assign_ix] = x1 * w + * out[assign_ix + 1] = x2 * w # this was x2 * 2 ..... :0 +*/ + __pyx_v_w = pow(((-2.0 * log(__pyx_v_w)) / ((double)__pyx_v_w)), 0.5); + + /* "cssm.pyx":160 + * + * w = ((-2.0 * log(w)) / w) ** 0.5 + * out[assign_ix] = x1 * w # <<<<<<<<<<<<<< + * out[assign_ix + 1] = x2 * w # this was x2 * 2 ..... :0 + * +*/ + __pyx_t_3 = __pyx_v_assign_ix; + *((float *) ( /* dim=0 */ (__pyx_v_out.data + __pyx_t_3 * __pyx_v_out.strides[0]) )) = (__pyx_v_x1 * __pyx_v_w); + + /* "cssm.pyx":161 + * w = ((-2.0 * log(w)) / w) ** 0.5 + * out[assign_ix] = x1 * w + * out[assign_ix + 1] = x2 * w # this was x2 * 2 ..... :0 # <<<<<<<<<<<<<< + * + * # @cythonboundscheck(False) +*/ + __pyx_t_3 = (__pyx_v_assign_ix + 1); + *((float *) ( /* dim=0 */ (__pyx_v_out.data + __pyx_t_3 * __pyx_v_out.strides[0]) )) = (__pyx_v_x2 * __pyx_v_w); + + /* "cssm.pyx":143 + * + * ## @cythonboundscheck(False) + * cdef void assign_random_gaussian_pair(float[:] out, int assign_ix): # <<<<<<<<<<<<<< + * """ + * Generate a pair of random floats from a standard normal distribution and assign them to an array. +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_AddTraceback("cssm.assign_random_gaussian_pair", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_L0:; +} + +/* "cssm.pyx":164 + * + * # @cythonboundscheck(False) + * cdef float[:] draw_gaussian(int n): # <<<<<<<<<<<<<< + * """ + * Generate an array of random floats from a standard normal distribution. +*/ + +static __Pyx_memviewslice __pyx_f_4cssm_draw_gaussian(int __pyx_v_n) { + int __pyx_v_i; + __Pyx_memviewslice __pyx_v_result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_r = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_memviewslice __pyx_t_8 = { 0, 0, { 0 }, { 0 }, { 0 } }; + long __pyx_t_9; + long __pyx_t_10; + int __pyx_t_11; + int __pyx_t_12; + float __pyx_t_13; + Py_ssize_t __pyx_t_14; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("draw_gaussian", 0); + + /* "cssm.pyx":176 + * # Draws standard normal variables - need to have the variance rescaled + * cdef int i + * cdef float[:] result = np.zeros(n, dtype=DTYPE) # <<<<<<<<<<<<<< + * for i in range(n // 2): + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 176, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_t_1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 176, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_result = __pyx_t_8; + __pyx_t_8.memview = NULL; + __pyx_t_8.data = NULL; + + /* "cssm.pyx":177 + * cdef int i + * cdef float[:] result = np.zeros(n, dtype=DTYPE) + * for i in range(n // 2): # <<<<<<<<<<<<<< + * + * assign_random_gaussian_pair(result, i * 2) +*/ + __pyx_t_9 = (__pyx_v_n / 2); + __pyx_t_10 = __pyx_t_9; + for (__pyx_t_11 = 0; __pyx_t_11 < __pyx_t_10; __pyx_t_11+=1) { + __pyx_v_i = __pyx_t_11; + + /* "cssm.pyx":179 + * for i in range(n // 2): + * + * assign_random_gaussian_pair(result, i * 2) # <<<<<<<<<<<<<< + * if n % 2 == 1: + * result[n - 1] = random_gaussian() +*/ + __pyx_f_4cssm_assign_random_gaussian_pair(__pyx_v_result, (__pyx_v_i * 2)); if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 179, __pyx_L1_error) + } + + /* "cssm.pyx":180 + * + * assign_random_gaussian_pair(result, i * 2) + * if n % 2 == 1: # <<<<<<<<<<<<<< + * result[n - 1] = random_gaussian() + * return result +*/ + __pyx_t_12 = ((__pyx_v_n % 2) == 1); + if (__pyx_t_12) { + + /* "cssm.pyx":181 + * assign_random_gaussian_pair(result, i * 2) + * if n % 2 == 1: + * result[n - 1] = random_gaussian() # <<<<<<<<<<<<<< + * return result + * +*/ + __pyx_t_13 = __pyx_f_4cssm_random_gaussian(); if (unlikely(__pyx_t_13 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 181, __pyx_L1_error) + __pyx_t_14 = (__pyx_v_n - 1); + *((float *) ( /* dim=0 */ (__pyx_v_result.data + __pyx_t_14 * __pyx_v_result.strides[0]) )) = __pyx_t_13; + + /* "cssm.pyx":180 + * + * assign_random_gaussian_pair(result, i * 2) + * if n % 2 == 1: # <<<<<<<<<<<<<< + * result[n - 1] = random_gaussian() + * return result +*/ + } + + /* "cssm.pyx":182 + * if n % 2 == 1: + * result[n - 1] = random_gaussian() + * return result # <<<<<<<<<<<<<< + * + * # Simulate (rt, choice) tuples from: Full DDM with flexible bounds -------------------------------- +*/ + __PYX_INC_MEMVIEW(&__pyx_v_result, 1); + __pyx_r = __pyx_v_result; + goto __pyx_L0; + + /* "cssm.pyx":164 + * + * # @cythonboundscheck(False) + * cdef float[:] draw_gaussian(int n): # <<<<<<<<<<<<<< + * """ + * Generate an array of random floats from a standard normal distribution. +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_8, 1); + __pyx_r.data = NULL; + __pyx_r.memview = NULL; + __Pyx_AddTraceback("cssm.draw_gaussian", __pyx_clineno, __pyx_lineno, __pyx_filename); + goto __pyx_L2; + __pyx_L0:; + if (unlikely(!__pyx_r.memview)) { + PyErr_SetString(PyExc_TypeError, "Memoryview return value is not initialized"); + } + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_result, 1); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":187 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm_hddm_base(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_1full_ddm_hddm_base(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_full_ddm_hddm_base, "\n Simulate reaction times and choices from a full drift diffusion model with flexible bounds.\n\n Args:\n v (np.ndarray): Drift rate for each trial.\n a (np.ndarray): Boundary separation for each trial.\n z (np.ndarray): Starting point bias for each trial (between 0 and 1).\n t (np.ndarray): Non-decision time for each trial.\n sz (np.ndarray): Variability in starting point for each trial.\n sv (np.ndarray): Variability in drift rate for each trial.\n st (np.ndarray): Variability in non-decision time for each trial.\n deadline (np.ndarray): Maximum allowed reaction time for each trial.\n s (np.ndarray): Diffusion coefficient (noise) for each trial.\n delta_t (float): Time step for simulation.\n max_t (float): Maximum time for simulation.\n n_samples (int): Number of samples to simulate per trial.\n n_trials (int): Number of trials to simulate.\n random_state (int or None): Seed for random number generator.\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times.\n return_option (str): 'full' for complete output, 'minimal' for basic output.\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n "); +static PyMethodDef __pyx_mdef_4cssm_1full_ddm_hddm_base = {"full_ddm_hddm_base", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_1full_ddm_hddm_base, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_full_ddm_hddm_base}; +static PyObject *__pyx_pw_4cssm_1full_ddm_hddm_base(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_sz = 0; + PyArrayObject *__pyx_v_sv = 0; + PyArrayObject *__pyx_v_st = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_smooth_unif = 0; + PyObject *__pyx_v_return_option = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("full_ddm_hddm_base (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_sz,&__pyx_mstate_global->__pyx_n_u_sv,&__pyx_mstate_global->__pyx_n_u_st,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_smooth_unif,&__pyx_mstate_global->__pyx_n_u_return_option,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 187, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "full_ddm_hddm_base", 1) < (0)) __PYX_ERR(0, 187, __pyx_L3_error) + + /* "cssm.pyx":200 + * int n_samples = 20000, + * int n_trials = 1, + * random_state = None, # <<<<<<<<<<<<<< + * smooth_unif = False, + * return_option = 'full', # 'full' or 'minimal' +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + + /* "cssm.pyx":201 + * int n_trials = 1, + * random_state = None, + * smooth_unif = False, # <<<<<<<<<<<<<< + * return_option = 'full', # 'full' or 'minimal' + * **kwargs, +*/ + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + for (Py_ssize_t i = __pyx_nargs; i < 9; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("full_ddm_hddm_base", 0, 9, 16, i); __PYX_ERR(0, 187, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 187, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 187, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 187, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 187, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 187, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 187, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 187, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 187, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 187, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 187, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":200 + * int n_samples = 20000, + * int n_trials = 1, + * random_state = None, # <<<<<<<<<<<<<< + * smooth_unif = False, + * return_option = 'full', # 'full' or 'minimal' +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_t = ((PyArrayObject *)values[3]); + __pyx_v_sz = ((PyArrayObject *)values[4]); + __pyx_v_sv = ((PyArrayObject *)values[5]); + __pyx_v_st = ((PyArrayObject *)values[6]); + __pyx_v_deadline = ((PyArrayObject *)values[7]); + __pyx_v_s = ((PyArrayObject *)values[8]); + if (values[9]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[9]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 196, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[10]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[10]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 197, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[11]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[11]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 198, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[12]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[12]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 199, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_random_state = values[13]; + __pyx_v_smooth_unif = values[14]; + __pyx_v_return_option = values[15]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("full_ddm_hddm_base", 0, 9, 16, __pyx_nargs); __PYX_ERR(0, 187, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.full_ddm_hddm_base", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 187, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 188, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 189, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 190, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sz), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sz", 0))) __PYX_ERR(0, 191, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sv), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sv", 0))) __PYX_ERR(0, 192, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_st), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "st", 0))) __PYX_ERR(0, 193, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 194, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 195, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_full_ddm_hddm_base(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_t, __pyx_v_sz, __pyx_v_sv, __pyx_v_st, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_random_state, __pyx_v_smooth_unif, __pyx_v_return_option, __pyx_v_kwargs); + + /* "cssm.pyx":187 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm_hddm_base(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_full_ddm_hddm_base(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_sz, PyArrayObject *__pyx_v_sv, PyArrayObject *__pyx_v_st, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_random_state, PyObject *__pyx_v_smooth_unif, PyObject *__pyx_v_return_option, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sz_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sv_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_st_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + CYTHON_UNUSED PyObject *__pyx_v_t_s = NULL; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_t_tmp; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + float __pyx_v_drift_increment; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_st; + __Pyx_Buffer __pyx_pybuffer_st; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sv; + __Pyx_Buffer __pyx_pybuffer_sv; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sz; + __Pyx_Buffer __pyx_pybuffer_sz; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + float __pyx_t_18; + float __pyx_t_19; + float __pyx_t_20; + int __pyx_t_21; + int __pyx_t_22; + int __pyx_t_23; + Py_ssize_t __pyx_t_24; + Py_ssize_t __pyx_t_25; + int __pyx_t_26; + Py_ssize_t __pyx_t_27; + Py_ssize_t __pyx_t_28; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("full_ddm_hddm_base", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_sz.pybuffer.buf = NULL; + __pyx_pybuffer_sz.refcount = 0; + __pyx_pybuffernd_sz.data = NULL; + __pyx_pybuffernd_sz.rcbuffer = &__pyx_pybuffer_sz; + __pyx_pybuffer_sv.pybuffer.buf = NULL; + __pyx_pybuffer_sv.refcount = 0; + __pyx_pybuffernd_sv.data = NULL; + __pyx_pybuffernd_sv.rcbuffer = &__pyx_pybuffer_sv; + __pyx_pybuffer_st.pybuffer.buf = NULL; + __pyx_pybuffer_st.refcount = 0; + __pyx_pybuffernd_st.data = NULL; + __pyx_pybuffernd_st.rcbuffer = &__pyx_pybuffer_st; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 187, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 187, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 187, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 187, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sz.rcbuffer->pybuffer, (PyObject*)__pyx_v_sz, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 187, __pyx_L1_error) + } + __pyx_pybuffernd_sz.diminfo[0].strides = __pyx_pybuffernd_sz.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sz.diminfo[0].shape = __pyx_pybuffernd_sz.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sv.rcbuffer->pybuffer, (PyObject*)__pyx_v_sv, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 187, __pyx_L1_error) + } + __pyx_pybuffernd_sv.diminfo[0].strides = __pyx_pybuffernd_sv.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sv.diminfo[0].shape = __pyx_pybuffernd_sv.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_st.rcbuffer->pybuffer, (PyObject*)__pyx_v_st, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 187, __pyx_L1_error) + } + __pyx_pybuffernd_st.diminfo[0].strides = __pyx_pybuffernd_st.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_st.diminfo[0].shape = __pyx_pybuffernd_st.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 187, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 187, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":231 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # cdef int cov_length = np.max([v.size, a.size, w.size, t.size]).astype(int) + * +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":235 + * + * # Param views + * cdef float[:] v_view = v # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] z_view = z +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 235, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":236 + * # Param views + * cdef float[:] v_view = v + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] z_view = z + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 236, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":237 + * cdef float[:] v_view = v + * cdef float[:] a_view = a + * cdef float[:] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] sz_view = sz +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 237, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":238 + * cdef float[:] a_view = a + * cdef float[:] z_view = z + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] sz_view = sz + * cdef float[:] sv_view = sv +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 238, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":239 + * cdef float[:] z_view = z + * cdef float[:] t_view = t + * cdef float[:] sz_view = sz # <<<<<<<<<<<<<< + * cdef float[:] sv_view = sv + * cdef float[:] st_view = st +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_sz), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 239, __pyx_L1_error) + __pyx_v_sz_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":240 + * cdef float[:] t_view = t + * cdef float[:] sz_view = sz + * cdef float[:] sv_view = sv # <<<<<<<<<<<<<< + * cdef float[:] st_view = st + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_sv), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 240, __pyx_L1_error) + __pyx_v_sv_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":241 + * cdef float[:] sz_view = sz + * cdef float[:] sv_view = sv + * cdef float[:] st_view = st # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_st), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 241, __pyx_L1_error) + __pyx_v_st_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":242 + * cdef float[:] sv_view = sv + * cdef float[:] st_view = st + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * # Data-structs for trajectory storage +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 242, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":243 + * cdef float[:] st_view = st + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 243, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":245 + * cdef float[:] s_view = s + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 245, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 245, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 245, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":246 + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 246, __pyx_L1_error) + + /* "cssm.pyx":247 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 247, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":249 + * cdef float[:, :] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 249, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 249, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 249, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 249, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":250 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 250, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 250, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 250, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 250, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 250, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":252 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 252, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":253 + * + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 253, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":255 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * + * # Boundary storage for the upper bound +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":258 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":259 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * + * cdef float y, t_particle, t_tmp, smooth_u, deadline_tmp, sqrt_st +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_mstate_global->__pyx_int_0, __pyx_t_5, __pyx_t_12}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_4 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 259, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":263 + * cdef float y, t_particle, t_tmp, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float drift_increment = 0.0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":264 + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 + * cdef float drift_increment = 0.0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_drift_increment = 0.0; + + /* "cssm.pyx":265 + * cdef Py_ssize_t m = 0 + * cdef float drift_increment = 0.0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * # Loop over trials +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 265, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":268 + * + * # Loop over trials + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Loop over samples + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":270 + * for k in range(n_trials): + * # Loop over samples + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): +*/ + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = __pyx_v_k; + __pyx_t_18 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_16 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_17 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_19 = __pyx_v_max_t; + __pyx_t_21 = (__pyx_t_18 < __pyx_t_19); + if (__pyx_t_21) { + __pyx_t_20 = __pyx_t_18; + } else { + __pyx_t_20 = __pyx_t_19; + } + __pyx_v_deadline_tmp = __pyx_t_20; + + /* "cssm.pyx":271 + * # Loop over samples + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * for n in range(n_samples): + * # initialize starting point +*/ + __pyx_t_17 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_17 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":272 + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): # <<<<<<<<<<<<<< + * # initialize starting point + * y = (z_view[k] * (a_view[k])) # reset starting position +*/ + __pyx_t_22 = __pyx_v_n_samples; + __pyx_t_23 = __pyx_t_22; + for (__pyx_t_24 = 0; __pyx_t_24 < __pyx_t_23; __pyx_t_24+=1) { + __pyx_v_n = __pyx_t_24; + + /* "cssm.pyx":274 + * for n in range(n_samples): + * # initialize starting point + * y = (z_view[k] * (a_view[k])) # reset starting position # <<<<<<<<<<<<<< + * + * # get drift by random displacement of v +*/ + __pyx_t_17 = __pyx_v_k; + __pyx_t_16 = __pyx_v_k; + __pyx_v_y = ((*((float *) ( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_17 * __pyx_v_z_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_16 * __pyx_v_a_view.strides[0]) )))); + + /* "cssm.pyx":277 + * + * # get drift by random displacement of v + * drift_increment = (v_view[k] + sv_view[k] * gaussian_values[m]) * delta_t # <<<<<<<<<<<<<< + * t_tmp = t_view[k] + (2 * (random_uniform() - 0.5) * st_view[k]) + * +*/ + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = __pyx_v_k; + __pyx_t_25 = __pyx_v_m; + __pyx_v_drift_increment = (((*((float *) ( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_16 * __pyx_v_v_view.strides[0]) ))) + ((*((float *) ( /* dim=0 */ (__pyx_v_sv_view.data + __pyx_t_17 * __pyx_v_sv_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_25 * __pyx_v_gaussian_values.strides[0]) ))))) * __pyx_v_delta_t); + + /* "cssm.pyx":278 + * # get drift by random displacement of v + * drift_increment = (v_view[k] + sv_view[k] * gaussian_values[m]) * delta_t + * t_tmp = t_view[k] + (2 * (random_uniform() - 0.5) * st_view[k]) # <<<<<<<<<<<<<< + * + * # apply uniform displacement on y +*/ + __pyx_t_25 = __pyx_v_k; + __pyx_t_20 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_20 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 278, __pyx_L1_error) + __pyx_t_17 = __pyx_v_k; + __pyx_v_t_tmp = ((*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_25 * __pyx_v_t_view.strides[0]) ))) + ((2.0 * (__pyx_t_20 - 0.5)) * (*((float *) ( /* dim=0 */ (__pyx_v_st_view.data + __pyx_t_17 * __pyx_v_st_view.strides[0]) ))))); + + /* "cssm.pyx":281 + * + * # apply uniform displacement on y + * y += 2 * (random_uniform() - 0.5) * sz_view[k] # <<<<<<<<<<<<<< + * + * # increment m appropriately +*/ + __pyx_t_20 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_20 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 281, __pyx_L1_error) + __pyx_t_17 = __pyx_v_k; + __pyx_v_y = (__pyx_v_y + ((2.0 * (__pyx_t_20 - 0.5)) * (*((float *) ( /* dim=0 */ (__pyx_v_sz_view.data + __pyx_t_17 * __pyx_v_sz_view.strides[0]) ))))); + + /* "cssm.pyx":284 + * + * # increment m appropriately + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":285 + * # increment m appropriately + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_21 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_21) { + + /* "cssm.pyx":286 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 286, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":287 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * t_particle = 0.0 # reset time +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":285 + * # increment m appropriately + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":289 + * m = 0 + * + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":290 + * + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":292 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_21 = (__pyx_v_n == 0); + if (__pyx_t_21) { + + /* "cssm.pyx":293 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_21 = (__pyx_v_k == 0); + if (__pyx_t_21) { + + /* "cssm.pyx":294 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_17 = 0; + __pyx_t_25 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_17 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_25 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":293 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":292 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":297 + * + * # Random walker + * while y >= 0 and y <= a_view[k] and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_26 = (__pyx_v_y >= 0.0); + if (__pyx_t_26) { + } else { + __pyx_t_21 = __pyx_t_26; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_25 = __pyx_v_k; + __pyx_t_26 = (__pyx_v_y <= (*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_25 * __pyx_v_a_view.strides[0]) )))); + if (__pyx_t_26) { + } else { + __pyx_t_21 = __pyx_t_26; + goto __pyx_L12_bool_binop_done; + } + __pyx_t_26 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_21 = __pyx_t_26; + __pyx_L12_bool_binop_done:; + if (!__pyx_t_21) break; + + /* "cssm.pyx":298 + * # Random walker + * while y >= 0 and y <= a_view[k] and t_particle <= deadline_tmp: + * y += drift_increment + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_25 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (__pyx_v_drift_increment + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_25 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":299 + * while y >= 0 and y <= a_view[k] and t_particle <= deadline_tmp: + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":300 + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":301 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":303 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_21 = (__pyx_v_n == 0); + if (__pyx_t_21) { + + /* "cssm.pyx":304 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * if m == num_draws: +*/ + __pyx_t_21 = (__pyx_v_k == 0); + if (__pyx_t_21) { + + /* "cssm.pyx":305 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_t_25 = __pyx_v_ix; + __pyx_t_17 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_25 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_17 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":304 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * if m == num_draws: +*/ + } + + /* "cssm.pyx":303 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":306 + * if k == 0: + * traj_view[ix, 0] = y + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_21 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_21) { + + /* "cssm.pyx":307 + * traj_view[ix, 0] = y + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 307, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":308 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * # Apply smoothing with uniform if desired +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":306 + * if k == 0: + * traj_view[ix, 0] = y + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":311 + * + * # Apply smoothing with uniform if desired + * if smooth_unif : # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_21 < 0))) __PYX_ERR(0, 311, __pyx_L1_error) + if (__pyx_t_21) { + + /* "cssm.pyx":312 + * # Apply smoothing with uniform if desired + * if smooth_unif : + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_21 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_21) { + + /* "cssm.pyx":313 + * if smooth_unif : + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_20 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_20 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 313, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_20 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":312 + * # Apply smoothing with uniform if desired + * if smooth_unif : + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L19; + } + + /* "cssm.pyx":314 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_21 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_21) { + + /* "cssm.pyx":315 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_20 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_20 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 315, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_20) * __pyx_v_delta_t); + + /* "cssm.pyx":314 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L19; + } + + /* "cssm.pyx":317 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L19:; + + /* "cssm.pyx":311 + * + * # Apply smoothing with uniform if desired + * if smooth_unif : # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L18; + } + + /* "cssm.pyx":319 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L18:; + + /* "cssm.pyx":321 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt # <<<<<<<<<<<<<< + * + * if y < 0: +*/ + __pyx_t_17 = __pyx_v_n; + __pyx_t_25 = __pyx_v_k; + __pyx_t_16 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_17 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_25 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_16 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + __pyx_v_t_tmp) + __pyx_v_smooth_u); + + /* "cssm.pyx":323 + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt + * + * if y < 0: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 0 # Store choice + * else: +*/ + __pyx_t_21 = (__pyx_v_y < 0.0); + if (__pyx_t_21) { + + /* "cssm.pyx":324 + * + * if y < 0: + * choices_view[n, k, 0] = 0 # Store choice # <<<<<<<<<<<<<< + * else: + * choices_view[n, k, 0] = 1 +*/ + __pyx_t_16 = __pyx_v_n; + __pyx_t_25 = __pyx_v_k; + __pyx_t_17 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_16 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_25 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_17 * __pyx_v_choices_view.strides[2]) )) = 0; + + /* "cssm.pyx":323 + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt + * + * if y < 0: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 0 # Store choice + * else: +*/ + goto __pyx_L20; + } + + /* "cssm.pyx":326 + * choices_view[n, k, 0] = 0 # Store choice + * else: + * choices_view[n, k, 0] = 1 # <<<<<<<<<<<<<< + * + * # If the rt exceeds the deadline, set rt to -999 and choice to -1 +*/ + /*else*/ { + __pyx_t_17 = __pyx_v_n; + __pyx_t_25 = __pyx_v_k; + __pyx_t_16 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_17 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_25 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_16 * __pyx_v_choices_view.strides[2]) )) = 1; + } + __pyx_L20:; + + /* "cssm.pyx":329 + * + * # If the rt exceeds the deadline, set rt to -999 and choice to -1 + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_16 = __pyx_v_n; + __pyx_t_25 = __pyx_v_k; + __pyx_t_17 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_28 = __pyx_v_k; + __pyx_t_21 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_16 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_25 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_17 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_27 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_28 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_21) { + + /* "cssm.pyx":330 + * # If the rt exceeds the deadline, set rt to -999 and choice to -1 + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_28 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_17 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_28 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_17 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":329 + * + * # If the rt exceeds the deadline, set rt to -999 and choice to -1 + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":332 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + __pyx_t_21 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_21 < 0))) __PYX_ERR(0, 332, __pyx_L1_error) + if (__pyx_t_21) { + + /* "cssm.pyx":333 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(17); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":334 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":335 + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't': t, + * 'sz': sz, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":336 + * 'a': a, + * 'z': z, + * 't': t, # <<<<<<<<<<<<<< + * 'sz': sz, + * 'sv': sv, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":337 + * 'z': z, + * 't': t, + * 'sz': sz, # <<<<<<<<<<<<<< + * 'sv': sv, + * 'st': st, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sz, ((PyObject *)__pyx_v_sz)) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":338 + * 't': t, + * 'sz': sz, + * 'sv': sv, # <<<<<<<<<<<<<< + * 'st': st, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sv, ((PyObject *)__pyx_v_sv)) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":339 + * 'sz': sz, + * 'sv': sv, + * 'st': st, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_st, ((PyObject *)__pyx_v_st)) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":340 + * 'sv': sv, + * 'st': st, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":341 + * 'st': st, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":342 + * 'deadline': deadline, + * 's': s, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 342, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_6) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":343 + * 's': s, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 343, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_6) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":344 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'full_ddm_hddm_base', +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 344, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":345 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'full_ddm_hddm_base', + * 'possible_choices': [0, 1], +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 345, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_full_ddm_hddm_base) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":347 + * 'n_trials': n_trials, + * 'simulator': 'full_ddm_hddm_base', + * 'possible_choices': [0, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': 'constant', + * 'trajectory': traj}} +*/ + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 347, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 347, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_mstate_global->__pyx_n_u_constant) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + + /* "cssm.pyx":349 + * 'possible_choices': [0, 1], + * 'boundary_fun_type': 'constant', + * 'trajectory': traj}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_hddm_base', +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_3) < (0)) __PYX_ERR(0, 333, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":332 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + } + + /* "cssm.pyx":350 + * 'boundary_fun_type': 'constant', + * 'trajectory': traj}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_hddm_base', + * 'possible_choices': [0, 1], +*/ + __pyx_t_21 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_21 < 0))) __PYX_ERR(0, 350, __pyx_L1_error) + if (likely(__pyx_t_21)) { + + /* "cssm.pyx":351 + * 'trajectory': traj}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_hddm_base', # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1], + * 'n_samples': n_samples, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_full_ddm_hddm_base) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + + /* "cssm.pyx":352 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_hddm_base', + * 'possible_choices': [0, 1], # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 352, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 352, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 352, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":353 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_hddm_base', + * 'possible_choices': [0, 1], + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'boundary_fun_type': 'constant'}} +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 353, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":354 + * 'possible_choices': [0, 1], + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'boundary_fun_type': 'constant'}} + * else: +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 354, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_mstate_global->__pyx_n_u_constant) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_3) < (0)) __PYX_ERR(0, 351, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":350 + * 'boundary_fun_type': 'constant', + * 'trajectory': traj}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_hddm_base', + * 'possible_choices': [0, 1], +*/ + } + + /* "cssm.pyx":357 + * 'boundary_fun_type': 'constant'}} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # ------------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_3 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 357, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 357, __pyx_L1_error) + } + + /* "cssm.pyx":187 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm_hddm_base(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_st.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sv.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sz.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.full_ddm_hddm_base", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_st.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sv.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sz.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sz_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sv_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_st_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":368 + * #@cython.wraparound(False) + * + * def ddm(np.ndarray[float, ndim = 1] v, # drift by timestep 'delta_t' # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # boundary separation + * np.ndarray[float, ndim = 1] z, # between 0 and 1 +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_3ddm(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_2ddm, "\n Simulate reaction times and choices from a simple drift diffusion model (DDM).\n\n Args:\n v (np.ndarray): Drift rate for each trial.\n a (np.ndarray): Boundary separation for each trial.\n z (np.ndarray): Starting point (between 0 and 1) for each trial.\n t (np.ndarray): Non-decision time for each trial.\n deadline (np.ndarray): Maximum reaction time allowed for each trial.\n s (np.ndarray): Noise standard deviation for each trial.\n max_t (float): Maximum simulation time (default: 20).\n delta_t (float): Time step size (default: 0.001).\n n_samples (int): Number of samples per trial (default: 20000).\n n_trials (int): Number of trials to simulate (default: 10).\n random_state (int or None): Seed for random number generator (default: None).\n return_option (str): 'full' or 'minimal' return format (default: 'full').\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times (default: False).\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the return_option.\n\n Raises:\n ValueError: If return_option is neither 'full' nor 'minimal'.\n "); +static PyMethodDef __pyx_mdef_4cssm_3ddm = {"ddm", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_3ddm, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_2ddm}; +static PyObject *__pyx_pw_4cssm_3ddm(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + PyObject *__pyx_v_max_t = 0; + float __pyx_v_delta_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[13] = {0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 368, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm", 1) < (0)) __PYX_ERR(0, 368, __pyx_L3_error) + if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_20))); + + /* "cssm.pyx":378 + * int n_samples = 20000, # number of samples considered + * int n_trials = 10, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', # 'full' or 'minimal' + * smooth_unif = False, +*/ + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + + /* "cssm.pyx":380 + * random_state = None, + * return_option = 'full', # 'full' or 'minimal' + * smooth_unif = False, # <<<<<<<<<<<<<< + * **kwargs): + * """ +*/ + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 6; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm", 0, 6, 13, i); __PYX_ERR(0, 368, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 368, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 368, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 368, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 368, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 368, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 368, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 368, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[6]) values[6] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_int_20))); + + /* "cssm.pyx":378 + * int n_samples = 20000, # number of samples considered + * int n_trials = 10, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', # 'full' or 'minimal' + * smooth_unif = False, +*/ + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_t = ((PyArrayObject *)values[3]); + __pyx_v_deadline = ((PyArrayObject *)values[4]); + __pyx_v_s = ((PyArrayObject *)values[5]); + __pyx_v_max_t = values[6]; + if (values[7]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[7]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 375, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[8]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[8]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 376, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[9]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 377, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)10)); + } + __pyx_v_random_state = values[10]; + __pyx_v_return_option = values[11]; + __pyx_v_smooth_unif = values[12]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm", 0, 6, 13, __pyx_nargs); __PYX_ERR(0, 368, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 368, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 369, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 370, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 371, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 372, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 373, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_2ddm(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_max_t, __pyx_v_delta_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":368 + * #@cython.wraparound(False) + * + * def ddm(np.ndarray[float, ndim = 1] v, # drift by timestep 'delta_t' # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # boundary separation + * np.ndarray[float, ndim = 1] z, # between 0 and 1 +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_2ddm(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, PyObject *__pyx_v_max_t, float __pyx_v_delta_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_k; + int __pyx_v_m; + int __pyx_v_num_draws; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_12; + int __pyx_t_13; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + float __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + int __pyx_t_22; + Py_ssize_t __pyx_t_23; + Py_ssize_t __pyx_t_24; + int __pyx_t_25; + Py_ssize_t __pyx_t_26; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 368, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 368, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 368, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 368, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 368, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 368, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":409 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:] v_view = v +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":411 + * set_seed(random_state) + * # Param views + * cdef float[:] v_view = v # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] z_view = z +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 411, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":412 + * # Param views + * cdef float[:] v_view = v + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] z_view = z + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 412, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":413 + * cdef float[:] v_view = v + * cdef float[:] a_view = a + * cdef float[:] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 413, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":414 + * cdef float[:] a_view = a + * cdef float[:] z_view = z + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 414, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":415 + * cdef float[:] z_view = z + * cdef float[:] t_view = t + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 415, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":416 + * cdef float[:] t_view = t + * cdef float[:] s_view = s + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * + * # Data-structs for trajectory storage +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 416, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":419 + * + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyNumber_Divide(__pyx_v_max_t, __pyx_t_4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_6); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 419, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 419, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 419, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":420 + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 420, __pyx_L1_error) + + /* "cssm.pyx":421 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 421, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":423 + * cdef float[:, :] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 423, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 423, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 423, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 423, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":424 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 424, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 424, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 424, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 424, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 424, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":425 + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 425, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":426 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 426, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":428 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":435 + * #cdef int n + * cdef Py_ssize_t n, ix, k + * cdef int m = 0 # <<<<<<<<<<<<<< + * cdef int num_draws = int(max_t / delta_t + 1) + * cdef float[:] gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":436 + * cdef Py_ssize_t n, ix, k + * cdef int m = 0 + * cdef int num_draws = int(max_t / delta_t + 1) # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyNumber_Divide(__pyx_v_max_t, __pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyNumber_Int(__pyx_t_1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_12 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 436, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_v_num_draws = __pyx_t_12; + + /* "cssm.pyx":437 + * cdef int m = 0 + * cdef int num_draws = int(max_t / delta_t + 1) + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 437, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":439 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Loop over samples + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + __pyx_t_12 = __pyx_v_n_trials; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_k = __pyx_t_14; + + /* "cssm.pyx":441 + * for k in range(n_trials): + * # Loop over samples + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): +*/ + __pyx_t_15 = __pyx_v_k; + __pyx_t_16 = __pyx_v_k; + __pyx_t_17 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_15 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_16 * __pyx_v_t_view.strides[0]) )))); + __Pyx_INCREF(__pyx_v_max_t); + __pyx_t_4 = __pyx_v_max_t; + __pyx_t_3 = PyFloat_FromDouble(__pyx_t_17); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyObject_RichCompare(__pyx_t_3, __pyx_t_4, Py_LT); __Pyx_XGOTREF(__pyx_t_8); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_t_8); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (__pyx_t_18) { + __pyx_t_8 = PyFloat_FromDouble(__pyx_t_17); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = __pyx_t_8; + __pyx_t_8 = 0; + } else { + __Pyx_INCREF(__pyx_t_4); + __pyx_t_1 = __pyx_t_4; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_17 = __Pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_17 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 441, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_deadline_tmp = __pyx_t_17; + + /* "cssm.pyx":442 + * # Loop over samples + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * for n in range(n_samples): + * y = z_view[k] * a_view[k] # reset starting point +*/ + __pyx_t_16 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_16 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":443 + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): # <<<<<<<<<<<<<< + * y = z_view[k] * a_view[k] # reset starting point + * t_particle = 0.0 # reset time +*/ + __pyx_t_19 = __pyx_v_n_samples; + __pyx_t_20 = __pyx_t_19; + for (__pyx_t_21 = 0; __pyx_t_21 < __pyx_t_20; __pyx_t_21+=1) { + __pyx_v_n = __pyx_t_21; + + /* "cssm.pyx":444 + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): + * y = z_view[k] * a_view[k] # reset starting point # <<<<<<<<<<<<<< + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index +*/ + __pyx_t_16 = __pyx_v_k; + __pyx_t_15 = __pyx_v_k; + __pyx_v_y = ((*((float *) ( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_16 * __pyx_v_z_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_15 * __pyx_v_a_view.strides[0]) )))); + + /* "cssm.pyx":445 + * for n in range(n_samples): + * y = z_view[k] * a_view[k] # reset starting point + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":446 + * y = z_view[k] * a_view[k] # reset starting point + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":448 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_18 = (__pyx_v_n == 0); + if (__pyx_t_18) { + + /* "cssm.pyx":449 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_18 = (__pyx_v_k == 0); + if (__pyx_t_18) { + + /* "cssm.pyx":450 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_15 = 0; + __pyx_t_16 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_15 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_16 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":449 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":448 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":453 + * + * # Random walker + * while y <= a_view[k] and y >= 0 and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * y += v_view[k] * delta_t + sqrt_st * gaussian_values[m] # update particle position + * t_particle += delta_t +*/ + while (1) { + __pyx_t_16 = __pyx_v_k; + __pyx_t_22 = (__pyx_v_y <= (*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_16 * __pyx_v_a_view.strides[0]) )))); + if (__pyx_t_22) { + } else { + __pyx_t_18 = __pyx_t_22; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_22 = (__pyx_v_y >= 0.0); + if (__pyx_t_22) { + } else { + __pyx_t_18 = __pyx_t_22; + goto __pyx_L11_bool_binop_done; + } + __pyx_t_22 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_18 = __pyx_t_22; + __pyx_L11_bool_binop_done:; + if (!__pyx_t_18) break; + + /* "cssm.pyx":454 + * # Random walker + * while y <= a_view[k] and y >= 0 and t_particle <= deadline_tmp: + * y += v_view[k] * delta_t + sqrt_st * gaussian_values[m] # update particle position # <<<<<<<<<<<<<< + * t_particle += delta_t + * m += 1 +*/ + __pyx_t_16 = __pyx_v_k; + __pyx_t_15 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (((*((float *) ( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_16 * __pyx_v_v_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_15 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":455 + * while y <= a_view[k] and y >= 0 and t_particle <= deadline_tmp: + * y += v_view[k] * delta_t + sqrt_st * gaussian_values[m] # update particle position + * t_particle += delta_t # <<<<<<<<<<<<<< + * m += 1 + * ix += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":456 + * y += v_view[k] * delta_t + sqrt_st * gaussian_values[m] # update particle position + * t_particle += delta_t + * m += 1 # <<<<<<<<<<<<<< + * ix += 1 + * +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":457 + * t_particle += delta_t + * m += 1 + * ix += 1 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":459 + * ix += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_18 = (__pyx_v_n == 0); + if (__pyx_t_18) { + + /* "cssm.pyx":460 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + __pyx_t_18 = (__pyx_v_k == 0); + if (__pyx_t_18) { + + /* "cssm.pyx":461 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * + * if m == num_draws: +*/ + __pyx_t_15 = __pyx_v_ix; + __pyx_t_16 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_15 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_16 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":460 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + } + + /* "cssm.pyx":459 + * ix += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":463 + * traj_view[ix, 0] = y + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_18 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_18) { + + /* "cssm.pyx":464 + * + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 464, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":465 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * # Note that for purposes of consistency with Navarro and Fuss, +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":463 + * traj_view[ix, 0] = y + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":471 + * + * # Apply smoothing with uniform if desired + * if smooth_unif : # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_18 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 471, __pyx_L1_error) + if (__pyx_t_18) { + + /* "cssm.pyx":472 + * # Apply smoothing with uniform if desired + * if smooth_unif : + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_18 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_18) { + + /* "cssm.pyx":473 + * if smooth_unif : + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_17 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_17 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 473, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_17 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":472 + * # Apply smoothing with uniform if desired + * if smooth_unif : + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L18; + } + + /* "cssm.pyx":474 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_18 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_18) { + + /* "cssm.pyx":475 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_17 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_17 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 475, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_17) * __pyx_v_delta_t); + + /* "cssm.pyx":474 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L18; + } + + /* "cssm.pyx":477 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L18:; + + /* "cssm.pyx":471 + * + * # Apply smoothing with uniform if desired + * if smooth_unif : # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L17; + } + + /* "cssm.pyx":479 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # store rt +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L17:; + + /* "cssm.pyx":481 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # store rt # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = sign(y) # store choice + * +*/ + __pyx_t_16 = __pyx_v_k; + __pyx_t_15 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_15 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_24 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_16 * __pyx_v_t_view.strides[0]) )))) + __pyx_v_smooth_u); + + /* "cssm.pyx":482 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # store rt + * choices_view[n, k, 0] = sign(y) # store choice # <<<<<<<<<<<<<< + * + * # If the rt exceeds the deadline, set rt to -999 and choice to -1 +*/ + __pyx_t_25 = __pyx_f_4cssm_sign(__pyx_v_y); if (unlikely(__pyx_t_25 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 482, __pyx_L1_error) + __pyx_t_16 = __pyx_v_n; + __pyx_t_24 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_16 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_24 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_25; + + /* "cssm.pyx":485 + * + * # If the rt exceeds the deadline, set rt to -999 and choice to -1 + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_24 = __pyx_v_k; + __pyx_t_16 = 0; + __pyx_t_15 = __pyx_v_k; + __pyx_t_26 = __pyx_v_k; + __pyx_t_18 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_23 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_24 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_16 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_15 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_26 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_18) { + + /* "cssm.pyx":486 + * # If the rt exceeds the deadline, set rt to -999 and choice to -1 + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_26 = __pyx_v_n; + __pyx_t_15 = __pyx_v_k; + __pyx_t_16 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_26 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_15 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_16 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":485 + * + * # If the rt exceeds the deadline, set rt to -999 and choice to -1 + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":488 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + __pyx_t_18 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 488, __pyx_L1_error) + if (__pyx_t_18) { + + /* "cssm.pyx":489 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(14); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + + /* "cssm.pyx":490 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + + /* "cssm.pyx":491 + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + + /* "cssm.pyx":492 + * 'a': a, + * 'z': z, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + + /* "cssm.pyx":493 + * 'z': z, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + + /* "cssm.pyx":494 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + + /* "cssm.pyx":495 + * 'deadline': deadline, + * 's': s, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_8 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_8) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "cssm.pyx":496 + * 's': s, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_v_max_t) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + + /* "cssm.pyx":497 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm', +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 497, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_8) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "cssm.pyx":498 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm', + * 'boundary_fun_type': 'constant', +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 498, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_8) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_mstate_global->__pyx_n_u_constant) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + + /* "cssm.pyx":501 + * 'simulator': 'ddm', + * 'boundary_fun_type': 'constant', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'trajectory': traj}} + * elif return_option == 'minimal': +*/ + __pyx_t_8 = PyList_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 501, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 501, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_8) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "cssm.pyx":502 + * 'boundary_fun_type': 'constant', + * 'possible_choices': [-1, 1], + * 'trajectory': traj}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm', +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_4) < (0)) __PYX_ERR(0, 489, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":488 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + } + + /* "cssm.pyx":503 + * 'possible_choices': [-1, 1], + * 'trajectory': traj}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_18 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_18 < 0))) __PYX_ERR(0, 503, __pyx_L1_error) + if (likely(__pyx_t_18)) { + + /* "cssm.pyx":504 + * 'trajectory': traj}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': 'constant', +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 504, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 504, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm) < (0)) __PYX_ERR(0, 504, __pyx_L1_error) + + /* "cssm.pyx":505 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': 'constant', + * 'n_samples': n_samples, +*/ + __pyx_t_8 = PyList_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 505, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_8, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 505, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_8) < (0)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_mstate_global->__pyx_n_u_constant) < (0)) __PYX_ERR(0, 504, __pyx_L1_error) + + /* "cssm.pyx":507 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': 'constant', + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials,}} + * else: +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 507, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_8) < (0)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "cssm.pyx":508 + * 'boundary_fun_type': 'constant', + * 'n_samples': n_samples, + * 'n_trials': n_trials,}} # <<<<<<<<<<<<<< + * else: + * raise ValueError('return_option must be either "full" or "minimal"') +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_8) < (0)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_4) < (0)) __PYX_ERR(0, 504, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":503 + * 'possible_choices': [-1, 1], + * 'trajectory': traj}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":510 + * 'n_trials': n_trials,}} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * + * # Simulate (rt, choice) tuples from: DDM WITH FLEXIBLE BOUNDARIES ------------------------------------ +*/ + /*else*/ { + __pyx_t_4 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 510, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 510, __pyx_L1_error) + } + + /* "cssm.pyx":368 + * #@cython.wraparound(False) + * + * def ddm(np.ndarray[float, ndim = 1] v, # drift by timestep 'delta_t' # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # boundary separation + * np.ndarray[float, ndim = 1] z, # between 0 and 1 +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":515 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + +static PyObject *__pyx_pf_4cssm_48__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":521 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float max_t = 20, # <<<<<<<<<<<<<< + * float delta_t = 0.001, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 521, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":522 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float max_t = 20, + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":523 + * float max_t = 20, + * float delta_t = 0.001, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":524 + * float delta_t = 0.001, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 524, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":515 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + __pyx_t_5 = PyTuple_New(10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, Py_None) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 515, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_5ddm_flexbound(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_4ddm_flexbound, "\n Simulate reaction times and choices from a drift diffusion model with flexible boundaries.\n\n Args:\n v (np.ndarray): Drift rate for each trial.\n a (np.ndarray): Boundary separation for each trial.\n z (np.ndarray): Starting point bias for each trial (between 0 and 1).\n t (np.ndarray): Non-decision time for each trial.\n deadline (np.ndarray): Maximum allowed reaction time for each trial.\n s (np.ndarray): Noise (sigma) for each trial.\n max_t (float): Maximum time for simulation.\n delta_t (float): Time step for simulation.\n n_samples (int): Number of samples to simulate per trial.\n n_trials (int): Number of trials to simulate.\n boundary_fun (callable): Function defining the shape of the boundary.\n boundary_multiplicative (bool): If True, boundary function is multiplied by 'a', else added to 'a'.\n boundary_params (dict): Parameters for the boundary function.\n random_state (int or None): Seed for random number generator.\n return_option (str): 'full' for complete output, 'minimal' for basic output.\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times.\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n "); +static PyMethodDef __pyx_mdef_4cssm_5ddm_flexbound = {"ddm_flexbound", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_5ddm_flexbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_4ddm_flexbound}; +static PyObject *__pyx_pw_4cssm_5ddm_flexbound(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_max_t; + float __pyx_v_delta_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_flexbound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 515, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_flexbound", 1) < (0)) __PYX_ERR(0, 515, __pyx_L3_error) + + /* "cssm.pyx":525 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[12]) values[12] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":528 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 6; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_flexbound", 0, 6, 16, i); __PYX_ERR(0, 515, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 515, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 515, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 515, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 515, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 515, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 515, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 515, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":525 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[12]) values[12] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":528 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_t = ((PyArrayObject *)values[3]); + __pyx_v_deadline = ((PyArrayObject *)values[4]); + __pyx_v_s = ((PyArrayObject *)values[5]); + if (values[6]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 521, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[7]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[7]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 522, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[8]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[8]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 523, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[9]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 524, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_boundary_fun = values[10]; + __pyx_v_boundary_multiplicative = values[11]; + __pyx_v_boundary_params = values[12]; + __pyx_v_random_state = values[13]; + __pyx_v_return_option = values[14]; + __pyx_v_smooth_unif = values[15]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_flexbound", 0, 6, 16, __pyx_nargs); __PYX_ERR(0, 515, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_flexbound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 515, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 516, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 517, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 518, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 519, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 520, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_4ddm_flexbound(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_max_t, __pyx_v_delta_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":515 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_4ddm_flexbound(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_max_t, float __pyx_v_delta_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_m; + Py_ssize_t __pyx_v_k; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_7genexpr__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + int __pyx_t_30; + Py_ssize_t __pyx_t_31; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_flexbound", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 515, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 515, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 515, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 515, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 515, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 515, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":559 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * #cdef int cov_length = np.max([v.size, a.size, w.size, t.size]).astype(int) + * # Param views: +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 559, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":562 + * #cdef int cov_length = np.max([v.size, a.size, w.size, t.size]).astype(int) + * # Param views: + * cdef float[:] v_view = v # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] z_view = z +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 562, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":563 + * # Param views: + * cdef float[:] v_view = v + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] z_view = z + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 563, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":564 + * cdef float[:] v_view = v + * cdef float[:] a_view = a + * cdef float[:] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 564, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":565 + * cdef float[:] a_view = a + * cdef float[:] z_view = z + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 565, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":566 + * cdef float[:] z_view = z + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 566, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":567 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 567, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":568 + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 568, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 568, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 568, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":569 + * cdef float[:] s_view = s + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:,:] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 569, __pyx_L1_error) + + /* "cssm.pyx":570 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 570, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":572 + * cdef float[:,:] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 572, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 572, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 572, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 572, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 572, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":573 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 573, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 573, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 573, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 573, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":575 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 575, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":576 + * + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 576, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":578 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":582 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":583 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_mstate_global->__pyx_int_0, __pyx_t_5, __pyx_t_12}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_4 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":584 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * + * cdef float y, t_particle, smooth_u, deadline_tmp, sqrt_st +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_6}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 584, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":589 + * cdef Py_ssize_t n + * cdef Py_ssize_t ix + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t k + * cdef float[:] gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":591 + * cdef Py_ssize_t m = 0 + * cdef Py_ssize_t k + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 591, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":592 + * cdef Py_ssize_t k + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * # Loop over samples +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 592, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":595 + * + * # Loop over samples + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":597 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 597, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 597, __pyx_L7_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 597, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); + __pyx_t_4 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_4, __pyx_t_17, &__pyx_t_16, &__pyx_t_5, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 597, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_7genexpr__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_7genexpr__pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 597, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 597, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_7genexpr__pyx_v_key, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 597, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_key); __pyx_7genexpr__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_key); __pyx_7genexpr__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":598 + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 598, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":599 + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_6 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 599, __pyx_L1_error) + __pyx_t_8 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_8, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 599, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_8); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_22}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_4 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 599, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":598 + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":601 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 601, __pyx_L1_error) + __pyx_t_5 = __pyx_t_8; + __pyx_t_8 = 0; + if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 601, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_22, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_12 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 601, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":603 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_20) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":604 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":605 + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): # <<<<<<<<<<<<<< + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position + * t_particle = 0.0 # reset time +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":606 + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position # <<<<<<<<<<<<<< + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index +*/ + __pyx_t_23 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_v_y = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_21 * __pyx_v_z_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":607 + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * # if deadline >> max_t, then deadline_tmp = max_t, regardless of t-value, otherwise deadline applies +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":608 + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * # if deadline >> max_t, then deadline_tmp = max_t, regardless of t-value, otherwise deadline applies + * # Can improve with less checks +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":611 + * # if deadline >> max_t, then deadline_tmp = max_t, regardless of t-value, otherwise deadline applies + * # Can improve with less checks + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":612 + * # Can improve with less checks + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":613 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_27 = 0; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":612 + * # Can improve with less checks + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":611 + * # if deadline >> max_t, then deadline_tmp = max_t, regardless of t-value, otherwise deadline applies + * # Can improve with less checks + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":616 + * + * # Random walker + * while (y >= (-1) * boundary_view[ix]) and (y <= boundary_view[ix]) and (t_particle <= deadline_tmp): # <<<<<<<<<<<<<< + * y += (v_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_21 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L18_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":617 + * # Random walker + * while (y >= (-1) * boundary_view[ix]) and (y <= boundary_view[ix]) and (t_particle <= deadline_tmp): + * y += (v_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (((*((float *) ( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_21 * __pyx_v_v_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_27 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":618 + * while (y >= (-1) * boundary_view[ix]) and (y <= boundary_view[ix]) and (t_particle <= deadline_tmp): + * y += (v_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":619 + * y += (v_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":620 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * + * # Can improve with less checks +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":623 + * + * # Can improve with less checks + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":624 + * # Can improve with less checks + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":625 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * + * # Can improve with less checks +*/ + __pyx_t_27 = __pyx_v_ix; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":624 + * # Can improve with less checks + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + } + + /* "cssm.pyx":623 + * + * # Can improve with less checks + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":628 + * + * # Can improve with less checks + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":629 + * # Can improve with less checks + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 629, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":630 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if smooth_unif : +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":628 + * + * # Can improve with less checks + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":632 + * m = 0 + * + * if smooth_unif : # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 632, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":633 + * + * if smooth_unif : + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":634 + * if smooth_unif : + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 634, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":633 + * + * if smooth_unif : + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":635 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":636 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 636, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":635 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":638 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L25:; + + /* "cssm.pyx":632 + * m = 0 + * + * if smooth_unif : # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L24; + } + + /* "cssm.pyx":640 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L24:; + + /* "cssm.pyx":642 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt # <<<<<<<<<<<<<< + * + * #rts_view[n, k, 0] = t_particle + t_view[k] # Store rt +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_27 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_21 * __pyx_v_t_view.strides[0]) )))) + __pyx_v_smooth_u); + + /* "cssm.pyx":645 + * + * #rts_view[n, k, 0] = t_particle + t_view[k] # Store rt + * choices_view[n, k, 0] = sign(y) # Store choice # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_30 = __pyx_f_4cssm_sign(__pyx_v_y); if (unlikely(__pyx_t_30 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 645, __pyx_L1_error) + __pyx_t_21 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_30; + + /* "cssm.pyx":647 + * choices_view[n, k, 0] = sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_31 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_23 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_27 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_31 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":648 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_31 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_31 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":647 + * choices_view[n, k, 0] = sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":650 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 650, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":651 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 651, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 651, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 651, __pyx_L1_error) + + /* "cssm.pyx":652 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 651, __pyx_L1_error) + + /* "cssm.pyx":653 + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't': t, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 651, __pyx_L1_error) + + /* "cssm.pyx":654 + * 'a': a, + * 'z': z, + * 't': t, # <<<<<<<<<<<<<< + * 's': s, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 651, __pyx_L1_error) + + /* "cssm.pyx":655 + * 'z': z, + * 't': t, + * 's': s, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 651, __pyx_L1_error) + + /* "cssm.pyx":656 + * 't': t, + * 's': s, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 651, __pyx_L1_error) + __pyx_t_3 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "cssm.pyx":657 + * 's': s, + * 'deadline': deadline, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 657, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_3, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 657, __pyx_L1_error) + } + + /* "cssm.pyx":658 + * 'deadline': deadline, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 658, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_6) < (0)) __PYX_ERR(0, 658, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":659 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_6) < (0)) __PYX_ERR(0, 659, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":660 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound', +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 660, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":661 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 661, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 661, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound) < (0)) __PYX_ERR(0, 662, __pyx_L1_error) + + /* "cssm.pyx":663 + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'trajectory': traj, +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 663, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_6) < (0)) __PYX_ERR(0, 663, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":664 + * 'simulator': 'ddm_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary, +*/ + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 664, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 664, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 664, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 664, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":665 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary, + * }} +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 665, __pyx_L1_error) + + /* "cssm.pyx":666 + * 'possible_choices': [-1, 1], + * 'trajectory': traj, + * 'boundary': boundary, # <<<<<<<<<<<<<< + * }} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 666, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_3) < (0)) __PYX_ERR(0, 651, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":650 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + } + + /* "cssm.pyx":668 + * 'boundary': boundary, + * }} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 668, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":669 + * }} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 669, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 669, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 669, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound) < (0)) __PYX_ERR(0, 669, __pyx_L1_error) + + /* "cssm.pyx":670 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 670, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 670, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 670, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 669, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":671 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 671, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_6) < (0)) __PYX_ERR(0, 669, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":672 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 672, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 669, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":673 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 673, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 669, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_3) < (0)) __PYX_ERR(0, 669, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":668 + * 'boundary': boundary, + * }} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":676 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * ## ---------------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_3 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 676, __pyx_L1_error) + } + + /* "cssm.pyx":515 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_flexbound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_7genexpr__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":682 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flex(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + +static PyObject *__pyx_pf_4cssm_50__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":688 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":689 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 689, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":690 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 690, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":691 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * drift_fun = None, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":682 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flex(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + __pyx_t_5 = PyTuple_New(12); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, Py_None) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg1); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self)->arg1) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, Py_None) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 10, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 11, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 682, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_7ddm_flex(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_6ddm_flex, "\n Simulate reaction times and choices from a drift diffusion model with flexible boundaries and flexible drift.\n\n Args:\n v (np.ndarray): Drift rate for each trial.\n a (np.ndarray): Boundary separation for each trial.\n z (np.ndarray): Starting point (between 0 and 1) for each trial.\n t (np.ndarray): Non-decision time for each trial.\n deadline (np.ndarray): Maximum reaction time allowed for each trial.\n s (np.ndarray): Noise standard deviation for each trial.\n delta_t (float): Time step size (default: 0.001).\n max_t (float): Maximum simulation time (default: 20).\n n_samples (int): Number of samples per trial (default: 20000).\n n_trials (int): Number of trials to simulate (default: 1).\n boundary_fun (callable): Function defining the decision boundary over time.\n drift_fun (callable): Function defining the drift rate over time.\n boundary_multiplicative (bool): If True, boundary function is multiplicative; if False, additive.\n boundary_params (dict): Parameters for the boundary function.\n drift_params (dict): Parameters for the drift function.\n random_state (int or None): Seed for random number generator (default: None).\n return_option (str): 'full' or 'minimal' return format (default: 'full').\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times (default: False).\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the return_option.\n\n Raises:\n ValueError: If return_option is neither 'full' nor 'minimal'.\n "); +static PyMethodDef __pyx_mdef_4cssm_7ddm_flex = {"ddm_flex", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_7ddm_flex, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_6ddm_flex}; +static PyObject *__pyx_pw_4cssm_7ddm_flex(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_drift_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_drift_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[18] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_flex (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_drift_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_drift_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults1 *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 682, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_flex", 1) < (0)) __PYX_ERR(0, 682, __pyx_L3_error) + + /* "cssm.pyx":692 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * drift_fun = None, + * boundary_multiplicative = True, +*/ + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)Py_None)); + + /* "cssm.pyx":693 + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * drift_fun = None, # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[13]) values[13] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + if (!values[14]) values[14] = __Pyx_NewRef(__pyx_dynamic_args->arg1); + + /* "cssm.pyx":697 + * boundary_params = {}, + * drift_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 6; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_flex", 0, 6, 18, i); __PYX_ERR(0, 682, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 682, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 682, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 682, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 682, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 682, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 682, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 682, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":692 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * drift_fun = None, + * boundary_multiplicative = True, +*/ + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)Py_None)); + + /* "cssm.pyx":693 + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * drift_fun = None, # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[13]) values[13] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + if (!values[14]) values[14] = __Pyx_NewRef(__pyx_dynamic_args->arg1); + + /* "cssm.pyx":697 + * boundary_params = {}, + * drift_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_t = ((PyArrayObject *)values[3]); + __pyx_v_deadline = ((PyArrayObject *)values[4]); + __pyx_v_s = ((PyArrayObject *)values[5]); + if (values[6]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 688, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[7]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[7]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 689, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[8]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[8]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 690, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[9]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 691, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_boundary_fun = values[10]; + __pyx_v_drift_fun = values[11]; + __pyx_v_boundary_multiplicative = values[12]; + __pyx_v_boundary_params = values[13]; + __pyx_v_drift_params = values[14]; + __pyx_v_random_state = values[15]; + __pyx_v_return_option = values[16]; + __pyx_v_smooth_unif = values[17]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_flex", 0, 6, 18, __pyx_nargs); __PYX_ERR(0, 682, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_flex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 682, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 683, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 684, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 685, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 686, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 687, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_6ddm_flex(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_boundary_fun, __pyx_v_drift_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_drift_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":682 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flex(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_6ddm_flex(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_drift_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_drift_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + PyObject *__pyx_v_drift = NULL; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_m; + Py_ssize_t __pyx_v_k; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_drift_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_drift_params_tmp = NULL; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_8genexpr1__pyx_v_key = NULL; + PyObject *__pyx_8genexpr2__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + Py_ssize_t __pyx_t_20; + PyObject *__pyx_t_21 = NULL; + int __pyx_t_22; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + int __pyx_t_30; + Py_ssize_t __pyx_t_31; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_flex", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 682, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 682, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 682, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 682, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 682, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 682, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":733 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views: + * cdef float[:] v_view = v +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 733, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":735 + * set_seed(random_state) + * # Param views: + * cdef float[:] v_view = v # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] z_view = z +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 735, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":736 + * # Param views: + * cdef float[:] v_view = v + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] z_view = z + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 736, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":737 + * cdef float[:] v_view = v + * cdef float[:] a_view = a + * cdef float[:] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 737, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":738 + * cdef float[:] a_view = a + * cdef float[:] z_view = z + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 738, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":739 + * cdef float[:] z_view = z + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 739, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":740 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 740, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":742 + * cdef float[:] s_view = s + * + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 742, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 742, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 742, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 742, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":743 + * + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:,:] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 743, __pyx_L1_error) + + /* "cssm.pyx":744 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 744, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":746 + * cdef float[:,:] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 746, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 746, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 746, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 746, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 746, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":747 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 747, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 747, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 747, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 747, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 747, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":749 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 749, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":750 + * + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 750, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":752 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":756 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":757 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * drift = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 757, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 757, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 757, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 757, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_mstate_global->__pyx_int_0, __pyx_t_5, __pyx_t_12}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 757, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_4 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 757, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 757, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":758 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * drift = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float y, t_particle, smooth_u, deadline_tmp, sqrt_st +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_6}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 758, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":759 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * drift = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float y, t_particle, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 759, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_drift = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":763 + * cdef Py_ssize_t n + * cdef Py_ssize_t ix + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef Py_ssize_t k + * cdef float[:] gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":765 + * cdef Py_ssize_t m = 0 + * cdef Py_ssize_t k + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * cdef float[:] drift_view = drift +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 765, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":766 + * cdef Py_ssize_t k + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * cdef float[:] drift_view = drift + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 766, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":767 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * cdef float[:] boundary_view = boundary + * cdef float[:] drift_view = drift # <<<<<<<<<<<<<< + * + * # Loop over samples +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_drift, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 767, __pyx_L1_error) + __pyx_v_drift_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":770 + * + * # Loop over samples + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations and drift evaluations + * +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":774 + * + * # Drift + * drift_params_tmp = {key: drift_params[key][k] for key in drift_params.keys()} # <<<<<<<<<<<<<< + * drift[:] = np.add(v_view[k], drift_fun(t = t_s, **drift_params_tmp)).astype(DTYPE) + * +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 774, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_drift_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 774, __pyx_L7_error) + } + __pyx_t_3 = __Pyx_dict_iterator(__pyx_v_drift_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 774, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_12); + __pyx_t_12 = __pyx_t_3; + __pyx_t_3 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_12, __pyx_t_17, &__pyx_t_16, &__pyx_t_3, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 774, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_8genexpr1__pyx_v_key, __pyx_t_3); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(__pyx_v_drift_params, __pyx_8genexpr1__pyx_v_key); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 774, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_GetItemInt(__pyx_t_3, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 774, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr1__pyx_v_key, (PyObject*)__pyx_t_6))) __PYX_ERR(0, 774, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_key); __pyx_8genexpr1__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_key); __pyx_8genexpr1__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_drift_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":775 + * # Drift + * drift_params_tmp = {key: drift_params[key][k] for key in drift_params.keys()} + * drift[:] = np.add(v_view[k], drift_fun(t = t_s, **drift_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * # Boundary +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_5 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_20 * __pyx_v_v_view.strides[0]) )))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_21 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 775, __pyx_L1_error) + __pyx_t_8 = __pyx_t_21; + __pyx_t_21 = 0; + if (__Pyx_MergeKeywords(__pyx_t_8, __pyx_v_drift_params_tmp) < (0)) __PYX_ERR(0, 775, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyObject_Call(__pyx_v_drift_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_8); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_5, __pyx_t_21}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_12 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_drift, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 775, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":778 + * + * # Boundary + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 778, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_17 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 778, __pyx_L13_error) + } + __pyx_t_4 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_16), (&__pyx_t_18)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 778, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __pyx_t_6 = __pyx_t_4; + __pyx_t_4 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_16, &__pyx_t_17, &__pyx_t_4, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 778, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_8genexpr2__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_8genexpr2__pyx_v_key); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 778, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 778, __pyx_L13_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr2__pyx_v_key, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 778, __pyx_L13_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_key); __pyx_8genexpr2__pyx_v_key = 0; + goto __pyx_L16_exit_scope; + __pyx_L13_error:; + __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_key); __pyx_8genexpr2__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L16_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":779 + * # Boundary + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_22 < 0))) __PYX_ERR(0, 779, __pyx_L1_error) + if (__pyx_t_22) { + + /* "cssm.pyx":780 + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_21 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_20 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 780, __pyx_L1_error) + __pyx_t_3 = __pyx_t_8; + __pyx_t_8 = 0; + if (__Pyx_MergeKeywords(__pyx_t_3, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 780, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_21, __pyx_t_8}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_6 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 780, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":779 + * # Boundary + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L17; + } + + /* "cssm.pyx":782 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_8 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_20 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 782, __pyx_L1_error) + __pyx_t_4 = __pyx_t_3; + __pyx_t_3 = 0; + if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 782, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_21))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_21); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_21); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_21, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_6, __pyx_t_8, __pyx_t_3}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_21, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_12 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_21}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 782, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L17:; + + /* "cssm.pyx":784 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): +*/ + __pyx_t_20 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_20 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_22 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_22) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":785 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":786 + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): # <<<<<<<<<<<<<< + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position + * t_particle = 0.0 # reset time +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_19; __pyx_t_16+=1) { + __pyx_v_n = __pyx_t_16; + + /* "cssm.pyx":787 + * sqrt_st = delta_t_sqrt * s_view[k] + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position # <<<<<<<<<<<<<< + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index +*/ + __pyx_t_23 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_v_y = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_20 * __pyx_v_z_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":788 + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":789 + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * # Can improve with less checks +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":792 + * + * # Can improve with less checks + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_22 = (__pyx_v_n == 0); + if (__pyx_t_22) { + + /* "cssm.pyx":793 + * # Can improve with less checks + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_22 = (__pyx_v_k == 0); + if (__pyx_t_22) { + + /* "cssm.pyx":794 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_27 = 0; + __pyx_t_20 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_20 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":793 + * # Can improve with less checks + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":792 + * + * # Can improve with less checks + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":797 + * + * # Random walker + * while (y >= (-1) * boundary_view[ix]) and (y <= boundary_view[ix]) and (t_particle <= deadline_tmp): # <<<<<<<<<<<<<< + * y += (drift_view[ix] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_20 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_20 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_22 = __pyx_t_28; + goto __pyx_L24_bool_binop_done; + } + __pyx_t_20 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_20 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_22 = __pyx_t_28; + goto __pyx_L24_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_22 = __pyx_t_28; + __pyx_L24_bool_binop_done:; + if (!__pyx_t_22) break; + + /* "cssm.pyx":798 + * # Random walker + * while (y >= (-1) * boundary_view[ix]) and (y <= boundary_view[ix]) and (t_particle <= deadline_tmp): + * y += (drift_view[ix] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_20 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (((*((float *) ( /* dim=0 */ (__pyx_v_drift_view.data + __pyx_t_20 * __pyx_v_drift_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_27 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":799 + * while (y >= (-1) * boundary_view[ix]) and (y <= boundary_view[ix]) and (t_particle <= deadline_tmp): + * y += (drift_view[ix] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":800 + * y += (drift_view[ix] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":801 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * + * # Can improve with less checks +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":804 + * + * # Can improve with less checks + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_22 = (__pyx_v_n == 0); + if (__pyx_t_22) { + + /* "cssm.pyx":805 + * # Can improve with less checks + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + __pyx_t_22 = (__pyx_v_k == 0); + if (__pyx_t_22) { + + /* "cssm.pyx":806 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * + * # Can improve with less checks +*/ + __pyx_t_27 = __pyx_v_ix; + __pyx_t_20 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_20 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":805 + * # Can improve with less checks + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + } + + /* "cssm.pyx":804 + * + * # Can improve with less checks + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":809 + * + * # Can improve with less checks + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_22 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_22) { + + /* "cssm.pyx":810 + * # Can improve with less checks + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 810, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":811 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if smooth_unif : +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":809 + * + * # Can improve with less checks + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":813 + * m = 0 + * + * if smooth_unif : # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_22 < 0))) __PYX_ERR(0, 813, __pyx_L1_error) + if (__pyx_t_22) { + + /* "cssm.pyx":814 + * + * if smooth_unif : + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_22 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_22) { + + /* "cssm.pyx":815 + * if smooth_unif : + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 815, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":814 + * + * if smooth_unif : + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L31; + } + + /* "cssm.pyx":816 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_22 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_22) { + + /* "cssm.pyx":817 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 817, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":816 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L31; + } + + /* "cssm.pyx":819 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L31:; + + /* "cssm.pyx":813 + * m = 0 + * + * if smooth_unif : # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L30; + } + + /* "cssm.pyx":821 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L30:; + + /* "cssm.pyx":823 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = sign(y) # Store choice + * +*/ + __pyx_t_20 = __pyx_v_k; + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_27 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_20 * __pyx_v_t_view.strides[0]) )))) + __pyx_v_smooth_u); + + /* "cssm.pyx":824 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt + * choices_view[n, k, 0] = sign(y) # Store choice # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_30 = __pyx_f_4cssm_sign(__pyx_v_y); if (unlikely(__pyx_t_30 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 824, __pyx_L1_error) + __pyx_t_20 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_20 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_30; + + /* "cssm.pyx":826 + * choices_view[n, k, 0] = sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_20 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_31 = __pyx_v_k; + __pyx_t_22 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_23 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_20 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_27 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_31 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_22) { + + /* "cssm.pyx":827 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_31 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_20 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_31 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_20 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":826 + * choices_view[n, k, 0] = sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":829 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + __pyx_t_22 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_22 < 0))) __PYX_ERR(0, 829, __pyx_L1_error) + if (__pyx_t_22) { + + /* "cssm.pyx":830 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 830, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 830, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 830, __pyx_L1_error) + + /* "cssm.pyx":831 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 830, __pyx_L1_error) + + /* "cssm.pyx":832 + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 830, __pyx_L1_error) + + /* "cssm.pyx":833 + * 'a': a, + * 'z': z, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 830, __pyx_L1_error) + + /* "cssm.pyx":834 + * 'z': z, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 830, __pyx_L1_error) + + /* "cssm.pyx":835 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * **drift_params, +*/ + if (PyDict_SetItem(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 830, __pyx_L1_error) + __pyx_t_5 = __pyx_t_21; + __pyx_t_21 = 0; + + /* "cssm.pyx":836 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * **drift_params, + * 'delta_t': delta_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 836, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_5, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 836, __pyx_L1_error) + } + + /* "cssm.pyx":837 + * 's': s, + * **boundary_params, + * **drift_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_drift_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 837, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_5, __pyx_v_drift_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_drift_params); + __PYX_ERR(0, 837, __pyx_L1_error) + } + + /* "cssm.pyx":838 + * **boundary_params, + * **drift_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_21 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 838, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_21) < (0)) __PYX_ERR(0, 838, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":839 + * **drift_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_21 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_21) < (0)) __PYX_ERR(0, 839, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":840 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_flex', +*/ + __pyx_t_21 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 840, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_21) < (0)) __PYX_ERR(0, 840, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":841 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_flex', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_21 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 841, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_21) < (0)) __PYX_ERR(0, 841, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flex) < (0)) __PYX_ERR(0, 842, __pyx_L1_error) + + /* "cssm.pyx":843 + * 'n_trials': n_trials, + * 'simulator': 'ddm_flex', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'drift_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], +*/ + __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 843, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_21) < (0)) __PYX_ERR(0, 843, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":844 + * 'simulator': 'ddm_flex', + * 'boundary_fun_type': boundary_fun.__name__, + * 'drift_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'trajectory': traj, +*/ + __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 844, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_drift_fun_type, __pyx_t_21) < (0)) __PYX_ERR(0, 844, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":845 + * 'boundary_fun_type': boundary_fun.__name__, + * 'drift_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'drift': drift, +*/ + __pyx_t_21 = PyList_New(2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 845, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_21, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 845, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_21, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 845, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_21) < (0)) __PYX_ERR(0, 845, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":846 + * 'drift_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'drift': drift, + * 'boundary': boundary}} +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 846, __pyx_L1_error) + + /* "cssm.pyx":847 + * 'possible_choices': [-1, 1], + * 'trajectory': traj, + * 'drift': drift, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_drift, __pyx_v_drift) < (0)) __PYX_ERR(0, 847, __pyx_L1_error) + + /* "cssm.pyx":848 + * 'trajectory': traj, + * 'drift': drift, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flex', +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 848, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_5) < (0)) __PYX_ERR(0, 830, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":829 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + } + + /* "cssm.pyx":849 + * 'drift': drift, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flex', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_22 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_22 < 0))) __PYX_ERR(0, 849, __pyx_L1_error) + if (likely(__pyx_t_22)) { + + /* "cssm.pyx":850 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flex', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 850, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 850, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flex) < (0)) __PYX_ERR(0, 850, __pyx_L1_error) + + /* "cssm.pyx":851 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flex', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'drift_fun_type': boundary_fun.__name__, +*/ + __pyx_t_21 = PyList_New(2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 851, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_21, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 851, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_21, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 851, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_21) < (0)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":852 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flex', + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'drift_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_21) < (0)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":853 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, + * 'drift_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_21 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 853, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_drift_fun_type, __pyx_t_21) < (0)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":854 + * 'boundary_fun_type': boundary_fun.__name__, + * 'drift_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_21 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 854, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_21) < (0)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + + /* "cssm.pyx":855 + * 'drift_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_21 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_21) < (0)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_5) < (0)) __PYX_ERR(0, 850, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":849 + * 'drift': drift, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flex', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":858 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * + * # Simulate (rt, choice) tuples from: Levy Flight with Flex Bound ------------------------------------- +*/ + /*else*/ { + __pyx_t_5 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 858, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 858, __pyx_L1_error) + } + + /* "cssm.pyx":682 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flex(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_21); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_flex", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __Pyx_XDECREF(__pyx_v_drift); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_drift_view, 1); + __Pyx_XDECREF(__pyx_v_drift_params_tmp); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_8genexpr1__pyx_v_key); + __Pyx_XDECREF(__pyx_8genexpr2__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":864 + * # @cythonwraparound(False) + * + * def levy_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + +static PyObject *__pyx_pf_4cssm_52__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":871 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 871, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":872 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 872, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":873 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 873, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":874 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 874, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":864 + * # @cythonwraparound(False) + * + * def levy_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + __pyx_t_5 = PyTuple_New(10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 864, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, Py_None) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 864, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 864, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_9levy_flexbound(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_8levy_flexbound, "\n Simulate reaction times and choices from a Levy Flight model with flexible boundaries.\n\n Args:\n v (np.ndarray): Drift rate for each trial.\n a (np.ndarray): Boundary separation for each trial.\n z (np.ndarray): Starting point (between 0 and 1) for each trial.\n alpha (np.ndarray): Stability parameter for each trial (0 < alpha <= 2).\n t (np.ndarray): Non-decision time for each trial.\n deadline (np.ndarray): Maximum reaction time allowed for each trial.\n s (np.ndarray): Noise scale parameter for each trial.\n delta_t (float): Time step size for simulation (default: 0.001).\n max_t (float): Maximum time for simulation (default: 20).\n n_samples (int): Number of samples to simulate per trial (default: 20000).\n n_trials (int): Number of trials to simulate (default: 1).\n boundary_fun (callable): Function defining the shape of the boundary over time.\n boundary_multiplicative (bool): If True, boundary function is multiplicative; if False, additive.\n boundary_params (dict): Parameters for the boundary function.\n random_state (int or None): Seed for random number generator (default: None).\n return_option (str): 'full' for complete output, 'minimal' for basic output (default: 'full').\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times (default: False).\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the return_option.\n\n Raises:\n ValueError: If return_option is neither 'full' nor 'minimal'.\n "); +static PyMethodDef __pyx_mdef_4cssm_9levy_flexbound = {"levy_flexbound", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_9levy_flexbound, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_8levy_flexbound}; +static PyObject *__pyx_pw_4cssm_9levy_flexbound(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_alpha = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[17] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("levy_flexbound (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_alpha,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 864, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "levy_flexbound", 1) < (0)) __PYX_ERR(0, 864, __pyx_L3_error) + + /* "cssm.pyx":875 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[13]) values[13] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":878 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 7; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("levy_flexbound", 0, 7, 17, i); __PYX_ERR(0, 864, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 864, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 864, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 864, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 864, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 864, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 864, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 864, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 864, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":875 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[13]) values[13] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":878 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_alpha = ((PyArrayObject *)values[3]); + __pyx_v_t = ((PyArrayObject *)values[4]); + __pyx_v_deadline = ((PyArrayObject *)values[5]); + __pyx_v_s = ((PyArrayObject *)values[6]); + if (values[7]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[7]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 871, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[8]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[8]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 872, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[9]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 873, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[10]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[10]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 874, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_boundary_fun = values[11]; + __pyx_v_boundary_multiplicative = values[12]; + __pyx_v_boundary_params = values[13]; + __pyx_v_random_state = values[14]; + __pyx_v_return_option = values[15]; + __pyx_v_smooth_unif = values[16]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("levy_flexbound", 0, 7, 17, __pyx_nargs); __PYX_ERR(0, 864, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.levy_flexbound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 864, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 865, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 866, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_alpha), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "alpha", 0))) __PYX_ERR(0, 867, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 868, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 869, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 870, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_8levy_flexbound(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_alpha, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":864 + * # @cythonwraparound(False) + * + * def levy_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_8levy_flexbound(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_alpha, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_alpha_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_alpha; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + __Pyx_memviewslice __pyx_v_alpha_stable_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_8genexpr3__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_alpha; + __Pyx_Buffer __pyx_pybuffer_alpha; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + Py_ssize_t __pyx_t_13; + int __pyx_t_14; + int __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + Py_ssize_t __pyx_t_18; + Py_ssize_t __pyx_t_19; + int __pyx_t_20; + int __pyx_t_21; + int __pyx_t_22; + PyObject *__pyx_t_23 = NULL; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + int __pyx_t_30; + Py_ssize_t __pyx_t_31; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("levy_flexbound", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_alpha.pybuffer.buf = NULL; + __pyx_pybuffer_alpha.refcount = 0; + __pyx_pybuffernd_alpha.data = NULL; + __pyx_pybuffernd_alpha.rcbuffer = &__pyx_pybuffer_alpha; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 864, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 864, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 864, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_alpha.rcbuffer->pybuffer, (PyObject*)__pyx_v_alpha, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 864, __pyx_L1_error) + } + __pyx_pybuffernd_alpha.diminfo[0].strides = __pyx_pybuffernd_alpha.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_alpha.diminfo[0].shape = __pyx_pybuffernd_alpha.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 864, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 864, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 864, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":913 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * #cdef int cov_length = np.max([v.size, a.size, w.size, t.size]).astype(int) + * # Param views: +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":916 + * #cdef int cov_length = np.max([v.size, a.size, w.size, t.size]).astype(int) + * # Param views: + * cdef float[:] v_view = v # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] z_view = z +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 916, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":917 + * # Param views: + * cdef float[:] v_view = v + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] z_view = z + * cdef float[:] alpha_view = alpha +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 917, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":918 + * cdef float[:] v_view = v + * cdef float[:] a_view = a + * cdef float[:] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] alpha_view = alpha + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 918, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":919 + * cdef float[:] a_view = a + * cdef float[:] z_view = z + * cdef float[:] alpha_view = alpha # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_alpha), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 919, __pyx_L1_error) + __pyx_v_alpha_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":920 + * cdef float[:] z_view = z + * cdef float[:] alpha_view = alpha + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 920, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":921 + * cdef float[:] alpha_view = alpha + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * # Data-struct for trajectory storage +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 921, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":922 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * # Data-struct for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 922, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":924 + * cdef float[:] s_view = s + * # Data-struct for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 924, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 924, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 924, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 924, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":925 + * # Data-struct for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:,:] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 925, __pyx_L1_error) + + /* "cssm.pyx":926 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 926, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":928 + * cdef float[:,:] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 928, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 928, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 928, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 928, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 928, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":929 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:,:, :] rts_view = rts +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 929, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 929, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 929, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 929, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":931 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:,:, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:,:, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 931, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":932 + * + * cdef float[:,:, :] rts_view = rts + * cdef int[:,:, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_alpha # = pow(delta_t, 1.0 / alpha) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 932, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":937 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":938 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_mstate_global->__pyx_int_0, __pyx_t_5, __pyx_t_12}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_4 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":939 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_6}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 939, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":940 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * cdef float y, t_particle, smooth_u, deadline_tmp, sqrt_st +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 940, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":944 + * cdef float y, t_particle, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float[:] alpha_stable_values = draw_random_stable(num_draws, alpha_view[0]) + * +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":945 + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 + * cdef float[:] alpha_stable_values = draw_random_stable(num_draws, alpha_view[0]) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_13 = 0; + __pyx_t_2 = __pyx_f_4cssm_draw_random_stable(__pyx_v_num_draws, (*((float *) ( /* dim=0 */ (__pyx_v_alpha_view.data + __pyx_t_13 * __pyx_v_alpha_view.strides[0]) )))); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 945, __pyx_L1_error) + __pyx_v_alpha_stable_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":947 + * cdef float[:] alpha_stable_values = draw_random_stable(num_draws, alpha_view[0]) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # AF-TODO: check if this is correct + * delta_t_alpha = s_view[k] * pow(delta_t, 1.0 / alpha_view[k]) +*/ + __pyx_t_14 = __pyx_v_n_trials; + __pyx_t_15 = __pyx_t_14; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { + __pyx_v_k = __pyx_t_16; + + /* "cssm.pyx":949 + * for k in range(n_trials): + * # AF-TODO: check if this is correct + * delta_t_alpha = s_view[k] * pow(delta_t, 1.0 / alpha_view[k]) # <<<<<<<<<<<<<< + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * +*/ + __pyx_t_13 = __pyx_v_k; + __pyx_t_17 = __pyx_v_k; + __pyx_v_delta_t_alpha = ((*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_13 * __pyx_v_s_view.strides[0]) ))) * pow(__pyx_v_delta_t, (1.0 / ((double)(*((float *) ( /* dim=0 */ (__pyx_v_alpha_view.data + __pyx_t_17 * __pyx_v_alpha_view.strides[0]) ))))))); + + /* "cssm.pyx":950 + * # AF-TODO: check if this is correct + * delta_t_alpha = s_view[k] * pow(delta_t, 1.0 / alpha_view[k]) + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 950, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_18 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 950, __pyx_L7_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_19), (&__pyx_t_20)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 950, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); + __pyx_t_4 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_21 = __Pyx_dict_iter_next(__pyx_t_4, __pyx_t_19, &__pyx_t_18, &__pyx_t_5, NULL, NULL, __pyx_t_20); + if (unlikely(__pyx_t_21 == 0)) break; + if (unlikely(__pyx_t_21 == -1)) __PYX_ERR(0, 950, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_8genexpr3__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_8genexpr3__pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 950, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 950, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr3__pyx_v_key, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 950, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_key); __pyx_8genexpr3__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_key); __pyx_8genexpr3__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":953 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_22 < 0))) __PYX_ERR(0, 953, __pyx_L1_error) + if (__pyx_t_22) { + + /* "cssm.pyx":954 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_17 = __pyx_v_k; + __pyx_t_6 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_17 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_23 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 954, __pyx_L1_error) + __pyx_t_8 = __pyx_t_23; + __pyx_t_23 = 0; + if (__Pyx_MergeKeywords(__pyx_t_8, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 954, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_8); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_23}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_4 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 954, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":953 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":956 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __pyx_t_17 = __pyx_v_k; + __pyx_t_23 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_17 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 956, __pyx_L1_error) + __pyx_t_5 = __pyx_t_8; + __pyx_t_8 = 0; + if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 956, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_23, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_12 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 956, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":958 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_17 = __pyx_v_k; + __pyx_t_13 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_17 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_13 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_22 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_22) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":960 + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position + * t_particle = 0.0 # reset time +*/ + __pyx_t_20 = __pyx_v_n_samples; + __pyx_t_21 = __pyx_t_20; + for (__pyx_t_19 = 0; __pyx_t_19 < __pyx_t_21; __pyx_t_19+=1) { + __pyx_v_n = __pyx_t_19; + + /* "cssm.pyx":961 + * # Loop over samples + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position # <<<<<<<<<<<<<< + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index +*/ + __pyx_t_13 = 0; + __pyx_t_17 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_v_y = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_13 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_17 * __pyx_v_z_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":962 + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * if n == 0: +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":963 + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * (boundary_view[0])) # reset starting position + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * if n == 0: + * if k == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":964 + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_22 = (__pyx_v_n == 0); + if (__pyx_t_22) { + + /* "cssm.pyx":965 + * ix = 0 # reset boundary index + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_22 = (__pyx_v_k == 0); + if (__pyx_t_22) { + + /* "cssm.pyx":966 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_27 = 0; + __pyx_t_17 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_17 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":965 + * ix = 0 # reset boundary index + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":964 + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":969 + * + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * y += (v_view[k] * delta_t) + (delta_t_alpha * alpha_stable_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_17 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_17 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_22 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_17 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_17 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_22 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_22 = __pyx_t_28; + __pyx_L18_bool_binop_done:; + if (!__pyx_t_22) break; + + /* "cssm.pyx":970 + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += (v_view[k] * delta_t) + (delta_t_alpha * alpha_stable_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_17 = __pyx_v_k; + __pyx_t_27 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (((*((float *) ( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_17 * __pyx_v_v_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_delta_t_alpha * (*((float *) ( /* dim=0 */ (__pyx_v_alpha_stable_values.data + __pyx_t_27 * __pyx_v_alpha_stable_values.strides[0]) )))))); + + /* "cssm.pyx":971 + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += (v_view[k] * delta_t) + (delta_t_alpha * alpha_stable_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":972 + * y += (v_view[k] * delta_t) + (delta_t_alpha * alpha_stable_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * if n == 0: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":973 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * if n == 0: + * if k == 0: +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":974 + * ix += 1 + * m += 1 + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_22 = (__pyx_v_n == 0); + if (__pyx_t_22) { + + /* "cssm.pyx":975 + * m += 1 + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * if m == num_draws: +*/ + __pyx_t_22 = (__pyx_v_k == 0); + if (__pyx_t_22) { + + /* "cssm.pyx":976 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * if m == num_draws: + * alpha_stable_values = draw_random_stable(num_draws, alpha_view[k]) +*/ + __pyx_t_27 = __pyx_v_ix; + __pyx_t_17 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_17 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":975 + * m += 1 + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * if m == num_draws: +*/ + } + + /* "cssm.pyx":974 + * ix += 1 + * m += 1 + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":977 + * if k == 0: + * traj_view[ix, 0] = y + * if m == num_draws: # <<<<<<<<<<<<<< + * alpha_stable_values = draw_random_stable(num_draws, alpha_view[k]) + * m = 0 +*/ + __pyx_t_22 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_22) { + + /* "cssm.pyx":978 + * traj_view[ix, 0] = y + * if m == num_draws: + * alpha_stable_values = draw_random_stable(num_draws, alpha_view[k]) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_17 = __pyx_v_k; + __pyx_t_2 = __pyx_f_4cssm_draw_random_stable(__pyx_v_num_draws, (*((float *) ( /* dim=0 */ (__pyx_v_alpha_view.data + __pyx_t_17 * __pyx_v_alpha_view.strides[0]) )))); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 978, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_alpha_stable_values, 1); + __pyx_v_alpha_stable_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":979 + * if m == num_draws: + * alpha_stable_values = draw_random_stable(num_draws, alpha_view[k]) + * m = 0 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":977 + * if k == 0: + * traj_view[ix, 0] = y + * if m == num_draws: # <<<<<<<<<<<<<< + * alpha_stable_values = draw_random_stable(num_draws, alpha_view[k]) + * m = 0 +*/ + } + } + + /* "cssm.pyx":981 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_22 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_22 < 0))) __PYX_ERR(0, 981, __pyx_L1_error) + if (__pyx_t_22) { + + /* "cssm.pyx":982 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_22 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_22) { + + /* "cssm.pyx":983 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 983, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":982 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":984 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_22 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_22) { + + /* "cssm.pyx":985 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 985, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":984 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":987 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L25:; + + /* "cssm.pyx":981 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L24; + } + + /* "cssm.pyx":989 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L24:; + + /* "cssm.pyx":991 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = sign(y) # Store choice + * +*/ + __pyx_t_17 = __pyx_v_k; + __pyx_t_27 = __pyx_v_n; + __pyx_t_13 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_27 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_13 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_17 * __pyx_v_t_view.strides[0]) )))) + __pyx_v_smooth_u); + + /* "cssm.pyx":992 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt + * choices_view[n, k, 0] = sign(y) # Store choice # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_30 = __pyx_f_4cssm_sign(__pyx_v_y); if (unlikely(__pyx_t_30 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 992, __pyx_L1_error) + __pyx_t_17 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_13 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_17 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_13 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_30; + + /* "cssm.pyx":994 + * choices_view[n, k, 0] = sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_13 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_17 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_31 = __pyx_v_k; + __pyx_t_22 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_13 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_17 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_27 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_31 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_22) { + + /* "cssm.pyx":995 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_31 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_17 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_31 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_17 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":994 + * choices_view[n, k, 0] = sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":997 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + __pyx_t_22 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_22 < 0))) __PYX_ERR(0, 997, __pyx_L1_error) + if (__pyx_t_22) { + + /* "cssm.pyx":998 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 998, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 998, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 998, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(6); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 998, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 998, __pyx_L1_error) + + /* "cssm.pyx":999 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 998, __pyx_L1_error) + + /* "cssm.pyx":1000 + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't': t, + * 'alpha': alpha, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 998, __pyx_L1_error) + + /* "cssm.pyx":1001 + * 'a': a, + * 'z': z, + * 't': t, # <<<<<<<<<<<<<< + * 'alpha': alpha, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 998, __pyx_L1_error) + + /* "cssm.pyx":1002 + * 'z': z, + * 't': t, + * 'alpha': alpha, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_alpha, ((PyObject *)__pyx_v_alpha)) < (0)) __PYX_ERR(0, 998, __pyx_L1_error) + + /* "cssm.pyx":1003 + * 't': t, + * 'alpha': alpha, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 998, __pyx_L1_error) + __pyx_t_3 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "cssm.pyx":1004 + * 'alpha': alpha, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 1004, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_3, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 1004, __pyx_L1_error) + } + + /* "cssm.pyx":1005 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1005, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_6) < (0)) __PYX_ERR(0, 1005, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1006 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1006, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_6) < (0)) __PYX_ERR(0, 1006, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1007 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'levy_flexbound', +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1007, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 1007, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1008 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'levy_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 1008, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_levy_flexbound) < (0)) __PYX_ERR(0, 1009, __pyx_L1_error) + + /* "cssm.pyx":1010 + * 'n_trials': n_trials, + * 'simulator': 'levy_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'trajectory': traj, +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_6) < (0)) __PYX_ERR(0, 1010, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1011 + * 'simulator': 'levy_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1011, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1011, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 1011, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1012 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 1012, __pyx_L1_error) + + /* "cssm.pyx":1013 + * 'possible_choices': [-1, 1], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'levy_flexbound', +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 1013, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_3) < (0)) __PYX_ERR(0, 998, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":997 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + } + + /* "cssm.pyx":1014 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'levy_flexbound', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_22 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_22 < 0))) __PYX_ERR(0, 1014, __pyx_L1_error) + if (likely(__pyx_t_22)) { + + /* "cssm.pyx":1015 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'levy_flexbound', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1015, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1015, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1015, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_levy_flexbound) < (0)) __PYX_ERR(0, 1015, __pyx_L1_error) + + /* "cssm.pyx":1016 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'levy_flexbound', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1016, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1016, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 1015, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1017 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'levy_flexbound', + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1017, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_6) < (0)) __PYX_ERR(0, 1015, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1018 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 1015, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1019 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1019, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 1015, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_3) < (0)) __PYX_ERR(0, 1015, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1014 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'levy_flexbound', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":1022 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * + * # Simulate (rt, choice) tuples from: Full DDM with flexible bounds -------------------------------- +*/ + /*else*/ { + __pyx_t_3 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1022, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1022, __pyx_L1_error) + } + + /* "cssm.pyx":864 + * # @cythonwraparound(False) + * + * def levy_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_23); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alpha.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.levy_flexbound", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_alpha.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_alpha_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_alpha_stable_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_8genexpr3__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":1027 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm_rv(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + +static PyObject *__pyx_pf_4cssm_54__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":1036 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1036, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":1037 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1037, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":1038 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1038, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":1039 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1039, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":1027 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm_rv(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + __pyx_t_5 = PyTuple_New(10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1027, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, Py_None) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1027, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 1027, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_11full_ddm_rv(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_10full_ddm_rv, "\n Simulate reaction times and choices from a full drift diffusion model with flexible boundaries and random variability.\n\n Args:\n v (np.ndarray): Drift rate for each trial.\n a (np.ndarray): Boundary separation for each trial.\n z (np.ndarray): Starting point (between 0 and 1) for each trial.\n t (np.ndarray): Non-decision time for each trial.\n z_dist: Distribution function for starting point variability.\n v_dist: Distribution function for drift rate variability.\n t_dist: Distribution function for non-decision time variability.\n deadline (np.ndarray): Maximum reaction time allowed for each trial.\n s (np.ndarray): Noise standard deviation for each trial.\n delta_t (float): Time step size for simulation (default: 0.001).\n max_t (float): Maximum simulation time (default: 20).\n n_samples (int): Number of samples per trial (default: 20000).\n n_trials (int): Number of trials to simulate (default: 1).\n boundary_fun (callable): Function defining the decision boundary over time.\n boundary_multiplicative (bool): If True, boundary function is multiplicative; if False, additive.\n boundary_params (dict): Parameters for the boundary function.\n random_state (int or None): Seed for random number generator (default: None).\n return_option (str): 'full' or 'minimal' return format (default: 'full').\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times (default: False).\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the return_option.\n\n Raises:\n ValueError: If return_option is neither 'full' nor 'minimal'.\n "); +static PyMethodDef __pyx_mdef_4cssm_11full_ddm_rv = {"full_ddm_rv", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_11full_ddm_rv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_10full_ddm_rv}; +static PyObject *__pyx_pw_4cssm_11full_ddm_rv(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_t = 0; + PyObject *__pyx_v_z_dist = 0; + PyObject *__pyx_v_v_dist = 0; + PyObject *__pyx_v_t_dist = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[19] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("full_ddm_rv (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_z_dist,&__pyx_mstate_global->__pyx_n_u_v_dist,&__pyx_mstate_global->__pyx_n_u_t_dist,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1027, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "full_ddm_rv", 1) < (0)) __PYX_ERR(0, 1027, __pyx_L3_error) + + /* "cssm.pyx":1040 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[15]) values[15] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1043 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 9; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("full_ddm_rv", 0, 9, 19, i); __PYX_ERR(0, 1027, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1027, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1027, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1027, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1027, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1027, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1027, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1027, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1027, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1027, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1027, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":1040 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[15]) values[15] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1043 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_t = ((PyArrayObject *)values[3]); + __pyx_v_z_dist = values[4]; + __pyx_v_v_dist = values[5]; + __pyx_v_t_dist = values[6]; + __pyx_v_deadline = ((PyArrayObject *)values[7]); + __pyx_v_s = ((PyArrayObject *)values[8]); + if (values[9]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[9]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1036, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[10]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[10]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1037, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[11]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[11]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1038, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[12]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[12]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1039, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_boundary_fun = values[13]; + __pyx_v_boundary_multiplicative = values[14]; + __pyx_v_boundary_params = values[15]; + __pyx_v_random_state = values[16]; + __pyx_v_return_option = values[17]; + __pyx_v_smooth_unif = values[18]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("full_ddm_rv", 0, 9, 19, __pyx_nargs); __PYX_ERR(0, 1027, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.full_ddm_rv", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 1027, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 1028, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 1029, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 1030, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 1034, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 1035, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_10full_ddm_rv(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_t, __pyx_v_z_dist, __pyx_v_v_dist, __pyx_v_t_dist, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":1027 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm_rv(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_10full_ddm_rv(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyObject *__pyx_v_z_dist, PyObject *__pyx_v_v_dist, PyObject *__pyx_v_t_dist, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_sz_samplewise = NULL; + PyObject *__pyx_v_sv_samplewise = NULL; + PyObject *__pyx_v_st_samplewise = NULL; + __Pyx_memviewslice __pyx_v_sz_samplewise_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sv_samplewise_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_st_samplewise_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_t_tmp; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + float __pyx_v_drift_increment; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_8genexpr4__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + Py_ssize_t __pyx_t_24; + Py_ssize_t __pyx_t_25; + Py_ssize_t __pyx_t_26; + float __pyx_t_27; + float __pyx_t_28; + float __pyx_t_29; + int __pyx_t_30; + int __pyx_t_31; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("full_ddm_rv", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1027, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1027, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1027, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1027, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1027, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1027, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":1080 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # cdef int cov_length = np.max([v.size, a.size, w.size, t.size]).astype(int) + * # Param views +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1080, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":1084 + * # Param views + * #set_random_state(random_state) + * cdef float[:] v_view = v # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] z_view = z +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1084, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1085 + * #set_random_state(random_state) + * cdef float[:] v_view = v + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] z_view = z + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1085, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1086 + * cdef float[:] v_view = v + * cdef float[:] a_view = a + * cdef float[:] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1086, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1087 + * cdef float[:] a_view = a + * cdef float[:] z_view = z + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1087, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1088 + * cdef float[:] z_view = z + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * sz_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1088, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1089 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * sz_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) + * sv_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1089, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1090 + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s + * sz_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) # <<<<<<<<<<<<<< + * sv_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) + * st_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 1090, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 1090, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1090, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1090, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_sz_samplewise = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1091 + * cdef float[:] s_view = s + * sz_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) + * sv_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) # <<<<<<<<<<<<<< + * st_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1091, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1091, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1091, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1091, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1091, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 1091, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 1091, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1091, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1091, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1091, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1091, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_sv_samplewise = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1092 + * sz_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) + * sv_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) + * st_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) # <<<<<<<<<<<<<< + * + * cdef float[:, :] sz_samplewise_view = sz_samplewise +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 1092, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 1092, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1092, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1092, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_st_samplewise = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1094 + * st_samplewise = np.zeros((n_trials, n_samples), dtype = DTYPE) + * + * cdef float[:, :] sz_samplewise_view = sz_samplewise # <<<<<<<<<<<<<< + * cdef float[:, :] sv_samplewise_view = sv_samplewise + * cdef float[:, :] st_samplewise_view = st_samplewise +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_sz_samplewise, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1094, __pyx_L1_error) + __pyx_v_sz_samplewise_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1095 + * + * cdef float[:, :] sz_samplewise_view = sz_samplewise + * cdef float[:, :] sv_samplewise_view = sv_samplewise # <<<<<<<<<<<<<< + * cdef float[:, :] st_samplewise_view = st_samplewise + * +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_sv_samplewise, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1095, __pyx_L1_error) + __pyx_v_sv_samplewise_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1096 + * cdef float[:, :] sz_samplewise_view = sz_samplewise + * cdef float[:, :] sv_samplewise_view = sv_samplewise + * cdef float[:, :] st_samplewise_view = st_samplewise # <<<<<<<<<<<<<< + * + * # Data-structs for trajectory storage +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_st_samplewise, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1096, __pyx_L1_error) + __pyx_v_st_samplewise_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1099 + * + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1099, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1099, __pyx_L1_error); + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1099, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1100 + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 1100, __pyx_L1_error) + + /* "cssm.pyx":1101 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1101, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1103 + * cdef float[:, :] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 1103, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 1103, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1103, __pyx_L1_error); + __pyx_t_6 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1103, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1103, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1104 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 1104, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 1104, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1104, __pyx_L1_error); + __pyx_t_6 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1104, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1104, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1106 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 1106, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":1107 + * + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 1107, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":1109 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":1113 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":1114 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_0, __pyx_t_3, __pyx_t_12}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_4 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1114, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1115 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1115, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1115, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1116 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * cdef float y, t_particle, t_tmp, smooth_u, deadline_tmp, sqrt_st +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1116, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1120 + * cdef float y, t_particle, t_tmp, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float drift_increment = 0.0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1121 + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 + * cdef float drift_increment = 0.0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_drift_increment = 0.0; + + /* "cssm.pyx":1122 + * cdef Py_ssize_t m = 0 + * cdef float drift_increment = 0.0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * # Loop over trials +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1122, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1125 + * + * # Loop over trials + * sv_samplewise[:, :] = v_dist(size = (n_samples, n_trials)).T # <<<<<<<<<<<<<< + * sz_samplewise[:, :] = z_dist(size = (n_samples, n_trials)).T + * st_samplewise[:, :] = t_dist(size = (n_samples, n_trials)).T +*/ + __pyx_t_4 = NULL; + __Pyx_INCREF(__pyx_v_v_dist); + __pyx_t_3 = __pyx_v_v_dist; + __pyx_t_12 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_12); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_12) != (0)) __PYX_ERR(0, 1125, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 1125, __pyx_L1_error); + __pyx_t_12 = 0; + __pyx_t_5 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, NULL}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_7, __pyx_t_5, __pyx_callargs+1, 0) < (0)) __PYX_ERR(0, 1125, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_T); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_sv_samplewise, __pyx_mstate_global->__pyx_tuple[2], __pyx_t_3) < 0))) __PYX_ERR(0, 1125, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":1126 + * # Loop over trials + * sv_samplewise[:, :] = v_dist(size = (n_samples, n_trials)).T + * sz_samplewise[:, :] = z_dist(size = (n_samples, n_trials)).T # <<<<<<<<<<<<<< + * st_samplewise[:, :] = t_dist(size = (n_samples, n_trials)).T + * +*/ + __pyx_t_1 = NULL; + __Pyx_INCREF(__pyx_v_z_dist); + __pyx_t_5 = __pyx_v_z_dist; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 1126, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 1126, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_4 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_1, NULL}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_12, __pyx_t_4, __pyx_callargs+1, 0) < (0)) __PYX_ERR(0, 1126, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_T); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_sz_samplewise, __pyx_mstate_global->__pyx_tuple[2], __pyx_t_5) < 0))) __PYX_ERR(0, 1126, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1127 + * sv_samplewise[:, :] = v_dist(size = (n_samples, n_trials)).T + * sz_samplewise[:, :] = z_dist(size = (n_samples, n_trials)).T + * st_samplewise[:, :] = t_dist(size = (n_samples, n_trials)).T # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_3 = NULL; + __Pyx_INCREF(__pyx_v_t_dist); + __pyx_t_4 = __pyx_v_t_dist; + __pyx_t_12 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_12); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_12) != (0)) __PYX_ERR(0, 1127, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 1127, __pyx_L1_error); + __pyx_t_12 = 0; + __pyx_t_1 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_size, __pyx_t_7, __pyx_t_1, __pyx_callargs+1, 0) < (0)) __PYX_ERR(0, 1127, __pyx_L1_error) + __pyx_t_5 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (1-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_1); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_T); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1127, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_st_samplewise, __pyx_mstate_global->__pyx_tuple[2], __pyx_t_4) < 0))) __PYX_ERR(0, 1127, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":1129 + * st_samplewise[:, :] = t_dist(size = (n_samples, n_trials)).T + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":1130 + * + * for k in range(n_trials): + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1130, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 1130, __pyx_L7_error) + } + __pyx_t_1 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1130, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_5); + __pyx_t_5 = __pyx_t_1; + __pyx_t_1 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_5, __pyx_t_17, &__pyx_t_16, &__pyx_t_1, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 1130, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_8genexpr4__pyx_v_key, __pyx_t_1); + __pyx_t_1 = 0; + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_8genexpr4__pyx_v_key); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1130, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_1, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1130, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_4, (PyObject*)__pyx_8genexpr4__pyx_v_key, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 1130, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_key); __pyx_8genexpr4__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_key); __pyx_8genexpr4__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "cssm.pyx":1133 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * # print(a) + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1133, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1135 + * if boundary_multiplicative: + * # print(a) + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * # print(a) +*/ + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_3 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1135, __pyx_L1_error) + __pyx_t_6 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_6, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1135, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_3, __pyx_t_22}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_5 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_12}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_4, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1135, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":1133 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * # print(a) + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":1138 + * else: + * # print(a) + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * sqrt_st = delta_t_sqrt * s_view[k] +*/ + /*else*/ { + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1138, __pyx_L1_error) + __pyx_t_1 = __pyx_t_6; + __pyx_t_6 = 0; + if (__Pyx_MergeKeywords(__pyx_t_1, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1138, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_22, __pyx_t_6}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_7 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_4, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":1140 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * + * # Loop over samples +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_21 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":1143 + * + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * # displaced_starting_point + * y = (-1) * boundary_view[0] + ((z_view[k] + sz_samplewise_view[k, n]) * 2.0 * (boundary_view[0])) +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":1145 + * for n in range(n_samples): + * # displaced_starting_point + * y = (-1) * boundary_view[0] + ((z_view[k] + sz_samplewise_view[k, n]) * 2.0 * (boundary_view[0])) # <<<<<<<<<<<<<< + * + * # displaced drift +*/ + __pyx_t_21 = 0; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = __pyx_v_k; + __pyx_t_25 = __pyx_v_n; + __pyx_t_26 = 0; + __pyx_v_y = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) + ((((*((float *) ( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_23 * __pyx_v_z_view.strides[0]) ))) + (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sz_samplewise_view.data + __pyx_t_24 * __pyx_v_sz_samplewise_view.strides[0]) ) + __pyx_t_25 * __pyx_v_sz_samplewise_view.strides[1]) )))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_26 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":1148 + * + * # displaced drift + * drift_increment = (v_view[k] + sv_samplewise_view[k, n]) * delta_t # <<<<<<<<<<<<<< + * + * # displaced t +*/ + __pyx_t_26 = __pyx_v_k; + __pyx_t_25 = __pyx_v_k; + __pyx_t_24 = __pyx_v_n; + __pyx_v_drift_increment = (((*((float *) ( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_26 * __pyx_v_v_view.strides[0]) ))) + (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sv_samplewise_view.data + __pyx_t_25 * __pyx_v_sv_samplewise_view.strides[0]) ) + __pyx_t_24 * __pyx_v_sv_samplewise_view.strides[1]) )))) * __pyx_v_delta_t); + + /* "cssm.pyx":1151 + * + * # displaced t + * t_tmp = t_view[k] + st_samplewise_view[k, n] # <<<<<<<<<<<<<< + * deadline_tmp = min(max_t, deadline_view[k] - t_tmp) + * +*/ + __pyx_t_24 = __pyx_v_k; + __pyx_t_25 = __pyx_v_k; + __pyx_t_26 = __pyx_v_n; + __pyx_v_t_tmp = ((*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_24 * __pyx_v_t_view.strides[0]) ))) + (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_st_samplewise_view.data + __pyx_t_25 * __pyx_v_st_samplewise_view.strides[0]) ) + __pyx_t_26 * __pyx_v_st_samplewise_view.strides[1]) )))); + + /* "cssm.pyx":1152 + * # displaced t + * t_tmp = t_view[k] + st_samplewise_view[k, n] + * deadline_tmp = min(max_t, deadline_view[k] - t_tmp) # <<<<<<<<<<<<<< + * + * # increment m appropriately +*/ + __pyx_t_26 = __pyx_v_k; + __pyx_t_27 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_26 * __pyx_v_deadline_view.strides[0]) ))) - __pyx_v_t_tmp); + __pyx_t_28 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_27 < __pyx_t_28); + if (__pyx_t_20) { + __pyx_t_29 = __pyx_t_27; + } else { + __pyx_t_29 = __pyx_t_28; + } + __pyx_v_deadline_tmp = __pyx_t_29; + + /* "cssm.pyx":1155 + * + * # increment m appropriately + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":1156 + * # increment m appropriately + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":1157 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1157, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1158 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * t_particle = 0.0 # reset time +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1156 + * # increment m appropriately + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":1160 + * m = 0 + * + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":1161 + * + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":1163 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1164 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1165 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_26 = 0; + __pyx_t_25 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_26 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_25 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":1164 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":1163 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":1168 + * + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_25 = __pyx_v_ix; + __pyx_t_30 = (__pyx_v_y >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_25 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_30) { + } else { + __pyx_t_20 = __pyx_t_30; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_25 = __pyx_v_ix; + __pyx_t_30 = (__pyx_v_y <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_25 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_30) { + } else { + __pyx_t_20 = __pyx_t_30; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_30 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_30; + __pyx_L19_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":1169 + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += drift_increment + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_25 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (__pyx_v_drift_increment + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_25 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":1170 + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":1171 + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":1172 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":1174 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1175 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * if m == num_draws: +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1176 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_t_25 = __pyx_v_ix; + __pyx_t_26 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_25 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_26 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":1175 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * if m == num_draws: +*/ + } + + /* "cssm.pyx":1174 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":1177 + * if k == 0: + * traj_view[ix, 0] = y + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":1178 + * traj_view[ix, 0] = y + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1178, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1179 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1177 + * if k == 0: + * traj_view[ix, 0] = y + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":1181 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1181, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1182 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":1183 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_29 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_29 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1183, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_29 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":1182 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L26; + } + + /* "cssm.pyx":1184 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":1185 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_29 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_29 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1185, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_29) * __pyx_v_delta_t); + + /* "cssm.pyx":1184 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L26; + } + + /* "cssm.pyx":1187 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L26:; + + /* "cssm.pyx":1181 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":1189 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L25:; + + /* "cssm.pyx":1191 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = np.sign(y) # Store choice + * +*/ + __pyx_t_26 = __pyx_v_n; + __pyx_t_25 = __pyx_v_k; + __pyx_t_24 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_26 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_25 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_24 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + __pyx_v_t_tmp) + __pyx_v_smooth_u); + + /* "cssm.pyx":1192 + * + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt + * choices_view[n, k, 0] = np.sign(y) # Store choice # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_12 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_y); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_3}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1192, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_31 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_31 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1192, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_24 = __pyx_v_n; + __pyx_t_25 = __pyx_v_k; + __pyx_t_26 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_24 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_25 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_26 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_31; + + /* "cssm.pyx":1194 + * choices_view[n, k, 0] = np.sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_26 = __pyx_v_n; + __pyx_t_25 = __pyx_v_k; + __pyx_t_24 = 0; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_26 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_25 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_24 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_23 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":1195 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_21 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_24 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":1194 + * choices_view[n, k, 0] = np.sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":1197 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1197, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1198 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "cssm.pyx":1199 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "cssm.pyx":1200 + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't': t, + * 'z_dist': z_dist, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "cssm.pyx":1201 + * 'a': a, + * 'z': z, + * 't': t, # <<<<<<<<<<<<<< + * 'z_dist': z_dist, + * 'v_dist': v_dist, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "cssm.pyx":1202 + * 'z': z, + * 't': t, + * 'z_dist': z_dist, # <<<<<<<<<<<<<< + * 'v_dist': v_dist, + * 't_dist': t_dist, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_z_dist, __pyx_v_z_dist) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "cssm.pyx":1203 + * 't': t, + * 'z_dist': z_dist, + * 'v_dist': v_dist, # <<<<<<<<<<<<<< + * 't_dist': t_dist, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_v_dist, __pyx_v_v_dist) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "cssm.pyx":1204 + * 'z_dist': z_dist, + * 'v_dist': v_dist, + * 't_dist': t_dist, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t_dist, __pyx_v_t_dist) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "cssm.pyx":1205 + * 'v_dist': v_dist, + * 't_dist': t_dist, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + + /* "cssm.pyx":1206 + * 't_dist': t_dist, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + __pyx_t_7 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":1207 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 1207, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_7, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 1207, __pyx_L1_error) + } + + /* "cssm.pyx":1208 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_3) < (0)) __PYX_ERR(0, 1208, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":1209 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_3) < (0)) __PYX_ERR(0, 1209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":1210 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'full_ddm_rv', +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 1210, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":1211 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'full_ddm_rv', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 1211, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_full_ddm_rv) < (0)) __PYX_ERR(0, 1212, __pyx_L1_error) + + /* "cssm.pyx":1213 + * 'n_trials': n_trials, + * 'simulator': 'full_ddm_rv', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'trajectory': traj, +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_3) < (0)) __PYX_ERR(0, 1213, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":1214 + * 'simulator': 'full_ddm_rv', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1214, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1214, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 1214, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":1215 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 1215, __pyx_L1_error) + + /* "cssm.pyx":1216 + * 'possible_choices': [-1, 1], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_rv', +*/ + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 1216, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_7) < (0)) __PYX_ERR(0, 1198, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1197 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + } + + /* "cssm.pyx":1217 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_rv', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1217, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":1218 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_rv', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_4 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1218, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1218, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_full_ddm_rv) < (0)) __PYX_ERR(0, 1218, __pyx_L1_error) + + /* "cssm.pyx":1219 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_rv', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1219, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1219, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 1218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":1220 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_rv', + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_3) < (0)) __PYX_ERR(0, 1218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":1221 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 1218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":1222 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1222, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 1218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_7) < (0)) __PYX_ERR(0, 1218, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1217 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm_rv', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":1225 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * + * # ------------------------------------------------------------------------------------------------- +*/ + /*else*/ { + __pyx_t_7 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1225, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_Raise(__pyx_t_4, 0, 0, 0); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __PYX_ERR(0, 1225, __pyx_L1_error) + } + + /* "cssm.pyx":1027 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm_rv(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.full_ddm_rv", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_sz_samplewise); + __Pyx_XDECREF(__pyx_v_sv_samplewise); + __Pyx_XDECREF(__pyx_v_st_samplewise); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sz_samplewise_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sv_samplewise_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_st_samplewise_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_8genexpr4__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":1233 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + +static PyObject *__pyx_pf_4cssm_56__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":1242 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":1243 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":1244 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":1245 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1245, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":1233 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + __pyx_t_5 = PyTuple_New(10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, Py_None) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 1233, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_13full_ddm(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_12full_ddm, "\n Simulate reaction times and choices from a full drift diffusion model with flexible boundaries.\n\n Args:\n v (np.ndarray): Drift rate for each trial.\n a (np.ndarray): Boundary separation for each trial.\n z (np.ndarray): Starting point (between 0 and 1) for each trial.\n t (np.ndarray): Non-decision time for each trial.\n sz (np.ndarray): Variability in starting point for each trial.\n sv (np.ndarray): Variability in drift rate for each trial.\n st (np.ndarray): Variability in non-decision time for each trial.\n deadline (np.ndarray): Maximum reaction time allowed for each trial.\n s (np.ndarray): Noise standard deviation for each trial.\n delta_t (float): Time step size for simulation (default: 0.001).\n max_t (float): Maximum time for simulation (default: 20).\n n_samples (int): Number of samples to simulate per trial (default: 20000).\n n_trials (int): Number of trials to simulate (default: 1).\n boundary_fun (callable): Function defining the shape of the boundary over time.\n boundary_multiplicative (bool): If True, boundary function is multiplicative; if False, additive.\n boundary_params (dict): Parameters for the boundary function.\n random_state (int or None): Seed for random number generator (default: None).\n return_option (str): 'full' for complete output, 'minimal' for basic output (default: 'full').\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times (default: False).\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the return_option.\n\n Raises:\n ValueError: If return_option is neither 'full' nor 'minimal'.\n "); +static PyMethodDef __pyx_mdef_4cssm_13full_ddm = {"full_ddm", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_13full_ddm, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_12full_ddm}; +static PyObject *__pyx_pw_4cssm_13full_ddm(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_sz = 0; + PyArrayObject *__pyx_v_sv = 0; + PyArrayObject *__pyx_v_st = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[19] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("full_ddm (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_sz,&__pyx_mstate_global->__pyx_n_u_sv,&__pyx_mstate_global->__pyx_n_u_st,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1233, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "full_ddm", 1) < (0)) __PYX_ERR(0, 1233, __pyx_L3_error) + + /* "cssm.pyx":1246 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[15]) values[15] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1249 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 9; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("full_ddm", 0, 9, 19, i); __PYX_ERR(0, 1233, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1233, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1233, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1233, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1233, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1233, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1233, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1233, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1233, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1233, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1233, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":1246 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[15]) values[15] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1249 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_t = ((PyArrayObject *)values[3]); + __pyx_v_sz = ((PyArrayObject *)values[4]); + __pyx_v_sv = ((PyArrayObject *)values[5]); + __pyx_v_st = ((PyArrayObject *)values[6]); + __pyx_v_deadline = ((PyArrayObject *)values[7]); + __pyx_v_s = ((PyArrayObject *)values[8]); + if (values[9]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[9]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1242, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[10]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[10]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1243, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[11]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[11]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1244, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[12]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[12]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1245, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_boundary_fun = values[13]; + __pyx_v_boundary_multiplicative = values[14]; + __pyx_v_boundary_params = values[15]; + __pyx_v_random_state = values[16]; + __pyx_v_return_option = values[17]; + __pyx_v_smooth_unif = values[18]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("full_ddm", 0, 9, 19, __pyx_nargs); __PYX_ERR(0, 1233, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.full_ddm", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 1233, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 1234, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 1235, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 1236, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sz), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sz", 0))) __PYX_ERR(0, 1237, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sv), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sv", 0))) __PYX_ERR(0, 1238, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_st), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "st", 0))) __PYX_ERR(0, 1239, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 1240, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 1241, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_12full_ddm(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_t, __pyx_v_sz, __pyx_v_sv, __pyx_v_st, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":1233 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_12full_ddm(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_sz, PyArrayObject *__pyx_v_sv, PyArrayObject *__pyx_v_st, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sz_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sv_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_st_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_t_tmp; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + float __pyx_v_drift_increment; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + float __pyx_v_sqrt_st; + PyObject *__pyx_8genexpr5__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_st; + __Pyx_Buffer __pyx_pybuffer_st; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sv; + __Pyx_Buffer __pyx_pybuffer_sv; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sz; + __Pyx_Buffer __pyx_pybuffer_sz; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + int __pyx_t_29; + Py_ssize_t __pyx_t_30; + Py_ssize_t __pyx_t_31; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("full_ddm", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_sz.pybuffer.buf = NULL; + __pyx_pybuffer_sz.refcount = 0; + __pyx_pybuffernd_sz.data = NULL; + __pyx_pybuffernd_sz.rcbuffer = &__pyx_pybuffer_sz; + __pyx_pybuffer_sv.pybuffer.buf = NULL; + __pyx_pybuffer_sv.refcount = 0; + __pyx_pybuffernd_sv.data = NULL; + __pyx_pybuffernd_sv.rcbuffer = &__pyx_pybuffer_sv; + __pyx_pybuffer_st.pybuffer.buf = NULL; + __pyx_pybuffer_st.refcount = 0; + __pyx_pybuffernd_st.data = NULL; + __pyx_pybuffernd_st.rcbuffer = &__pyx_pybuffer_st; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1233, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1233, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1233, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1233, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sz.rcbuffer->pybuffer, (PyObject*)__pyx_v_sz, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1233, __pyx_L1_error) + } + __pyx_pybuffernd_sz.diminfo[0].strides = __pyx_pybuffernd_sz.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sz.diminfo[0].shape = __pyx_pybuffernd_sz.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sv.rcbuffer->pybuffer, (PyObject*)__pyx_v_sv, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1233, __pyx_L1_error) + } + __pyx_pybuffernd_sv.diminfo[0].strides = __pyx_pybuffernd_sv.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sv.diminfo[0].shape = __pyx_pybuffernd_sv.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_st.rcbuffer->pybuffer, (PyObject*)__pyx_v_st, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1233, __pyx_L1_error) + } + __pyx_pybuffernd_st.diminfo[0].strides = __pyx_pybuffernd_st.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_st.diminfo[0].shape = __pyx_pybuffernd_st.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1233, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1233, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":1286 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # cdef int cov_length = np.max([v.size, a.size, w.size, t.size]).astype(int) + * # Param views +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1286, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":1290 + * # Param views + * #set_random_state(random_state) + * cdef float[:] v_view = v # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] z_view = z +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1290, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1291 + * #set_random_state(random_state) + * cdef float[:] v_view = v + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] z_view = z + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1291, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1292 + * cdef float[:] v_view = v + * cdef float[:] a_view = a + * cdef float[:] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] sz_view = sz +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1292, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1293 + * cdef float[:] a_view = a + * cdef float[:] z_view = z + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] sz_view = sz + * cdef float[:] sv_view = sv +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1293, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1294 + * cdef float[:] z_view = z + * cdef float[:] t_view = t + * cdef float[:] sz_view = sz # <<<<<<<<<<<<<< + * cdef float[:] sv_view = sv + * cdef float[:] st_view = st +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_sz), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1294, __pyx_L1_error) + __pyx_v_sz_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1295 + * cdef float[:] t_view = t + * cdef float[:] sz_view = sz + * cdef float[:] sv_view = sv # <<<<<<<<<<<<<< + * cdef float[:] st_view = st + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_sv), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1295, __pyx_L1_error) + __pyx_v_sv_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1296 + * cdef float[:] sz_view = sz + * cdef float[:] sv_view = sv + * cdef float[:] st_view = st # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_st), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1296, __pyx_L1_error) + __pyx_v_st_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1297 + * cdef float[:] sv_view = sv + * cdef float[:] st_view = st + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1297, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1298 + * cdef float[:] st_view = st + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * + * # Data-structs for trajectory storage +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1298, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1301 + * + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 1301, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1301, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1301, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1301, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1302 + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 1302, __pyx_L1_error) + + /* "cssm.pyx":1303 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1303, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1305 + * cdef float[:, :] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 1305, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 1305, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1305, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1305, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1305, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1306 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 1306, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 1306, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1306, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1306, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1308 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 1308, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":1309 + * + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 1309, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":1311 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":1315 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":1316 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_mstate_global->__pyx_int_0, __pyx_t_5, __pyx_t_12}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_4 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1316, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1317 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_6}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1317, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1317, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1318 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * cdef float y, t_particle, t_tmp, smooth_u, deadline_tmp +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1318, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1322 + * cdef float y, t_particle, t_tmp, smooth_u, deadline_tmp + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float drift_increment = 0.0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1323 + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 + * cdef float drift_increment = 0.0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_drift_increment = 0.0; + + /* "cssm.pyx":1324 + * cdef Py_ssize_t m = 0 + * cdef float drift_increment = 0.0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * # Loop over trials +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1324, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1327 + * + * # Loop over trials + * for k in range(n_trials): # <<<<<<<<<<<<<< + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":1328 + * # Loop over trials + * for k in range(n_trials): + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1328, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 1328, __pyx_L7_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1328, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); + __pyx_t_4 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_4, __pyx_t_17, &__pyx_t_16, &__pyx_t_5, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 1328, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_8genexpr5__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_8genexpr5__pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1328, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1328, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr5__pyx_v_key, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 1328, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_key); __pyx_8genexpr5__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_key); __pyx_8genexpr5__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":1331 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * # print(a) + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1331, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1333 + * if boundary_multiplicative: + * # print(a) + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * # print(a) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_6 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1333, __pyx_L1_error) + __pyx_t_8 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_8, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1333, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_8); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_6, __pyx_t_22}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_4 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1333, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":1331 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * # print(a) + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":1336 + * else: + * # print(a) + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1336, __pyx_L1_error) + __pyx_t_5 = __pyx_t_8; + __pyx_t_8 = 0; + if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1336, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_22, __pyx_t_8}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_12 = __pyx_t_3; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1336, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1336, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":1338 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_20) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":1339 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":1341 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * # initialize starting point + * y = ((-1) * boundary_view[0]) + (z_view[k] * 2.0 * (boundary_view[0])) # reset starting position +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":1343 + * for n in range(n_samples): + * # initialize starting point + * y = ((-1) * boundary_view[0]) + (z_view[k] * 2.0 * (boundary_view[0])) # reset starting position # <<<<<<<<<<<<<< + * + * # get drift by random displacement of v +*/ + __pyx_t_23 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_v_y = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_21 * __pyx_v_z_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":1346 + * + * # get drift by random displacement of v + * drift_increment = (v_view[k] + sv_view[k] * gaussian_values[m]) * delta_t # <<<<<<<<<<<<<< + * t_tmp = t_view[k] + (2 * (random_uniform() - 0.5) * st_view[k]) + * +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_m; + __pyx_v_drift_increment = (((*((float *) ( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_27 * __pyx_v_v_view.strides[0]) ))) + ((*((float *) ( /* dim=0 */ (__pyx_v_sv_view.data + __pyx_t_21 * __pyx_v_sv_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) ))))) * __pyx_v_delta_t); + + /* "cssm.pyx":1347 + * # get drift by random displacement of v + * drift_increment = (v_view[k] + sv_view[k] * gaussian_values[m]) * delta_t + * t_tmp = t_view[k] + (2 * (random_uniform() - 0.5) * st_view[k]) # <<<<<<<<<<<<<< + * + * # apply uniform displacement on y +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1347, __pyx_L1_error) + __pyx_t_21 = __pyx_v_k; + __pyx_v_t_tmp = ((*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) ))) + ((2.0 * (__pyx_t_26 - 0.5)) * (*((float *) ( /* dim=0 */ (__pyx_v_st_view.data + __pyx_t_21 * __pyx_v_st_view.strides[0]) ))))); + + /* "cssm.pyx":1350 + * + * # apply uniform displacement on y + * y += 2 * (random_uniform() - 0.5) * sz_view[k] # <<<<<<<<<<<<<< + * + * # increment m appropriately +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1350, __pyx_L1_error) + __pyx_t_21 = __pyx_v_k; + __pyx_v_y = (__pyx_v_y + ((2.0 * (__pyx_t_26 - 0.5)) * (*((float *) ( /* dim=0 */ (__pyx_v_sz_view.data + __pyx_t_21 * __pyx_v_sz_view.strides[0]) ))))); + + /* "cssm.pyx":1353 + * + * # increment m appropriately + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":1354 + * # increment m appropriately + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":1355 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1355, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1356 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * t_particle = 0.0 # reset time +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1354 + * # increment m appropriately + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":1358 + * m = 0 + * + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":1359 + * + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":1361 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1362 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1363 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_21 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":1362 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":1361 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":1366 + * + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L19_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":1367 + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += drift_increment + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_23 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (__pyx_v_drift_increment + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":1368 + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":1369 + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":1370 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":1372 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1373 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * if m == num_draws: +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1374 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":1373 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * if m == num_draws: +*/ + } + + /* "cssm.pyx":1372 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":1375 + * if k == 0: + * traj_view[ix, 0] = y + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":1376 + * traj_view[ix, 0] = y + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1376, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1377 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1375 + * if k == 0: + * traj_view[ix, 0] = y + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":1379 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1379, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1380 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":1381 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1381, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":1380 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L26; + } + + /* "cssm.pyx":1382 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":1383 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1383, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":1382 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L26; + } + + /* "cssm.pyx":1385 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L26:; + + /* "cssm.pyx":1379 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":1387 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L25:; + + /* "cssm.pyx":1389 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = np.sign(y) # Store choice + * +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_21 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + __pyx_v_t_tmp) + __pyx_v_smooth_u); + + /* "cssm.pyx":1390 + * + * rts_view[n, k, 0] = t_particle + t_tmp + smooth_u # Store rt + * choices_view[n, k, 0] = np.sign(y) # Store choice # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_y); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1390, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_29 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_29 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1390, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_29; + + /* "cssm.pyx":1392 + * choices_view[n, k, 0] = np.sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_30 = __pyx_v_k; + __pyx_t_31 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_21 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_30 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_31 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":1393 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_31 = __pyx_v_n; + __pyx_t_30 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_31 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_30 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":1392 + * choices_view[n, k, 0] = np.sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":1395 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1395, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1396 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1396, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + + /* "cssm.pyx":1397 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + + /* "cssm.pyx":1398 + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't': t, + * 'sz': sz, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + + /* "cssm.pyx":1399 + * 'a': a, + * 'z': z, + * 't': t, # <<<<<<<<<<<<<< + * 'sz': sz, + * 'sv': sv, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + + /* "cssm.pyx":1400 + * 'z': z, + * 't': t, + * 'sz': sz, # <<<<<<<<<<<<<< + * 'sv': sv, + * 'st': st, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sz, ((PyObject *)__pyx_v_sz)) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + + /* "cssm.pyx":1401 + * 't': t, + * 'sz': sz, + * 'sv': sv, # <<<<<<<<<<<<<< + * 'st': st, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_sv, ((PyObject *)__pyx_v_sv)) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + + /* "cssm.pyx":1402 + * 'sz': sz, + * 'sv': sv, + * 'st': st, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_st, ((PyObject *)__pyx_v_st)) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + + /* "cssm.pyx":1403 + * 'sv': sv, + * 'st': st, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + + /* "cssm.pyx":1404 + * 'st': st, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + __pyx_t_12 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "cssm.pyx":1405 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 1405, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_12, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 1405, __pyx_L1_error) + } + + /* "cssm.pyx":1406 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1406, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_6) < (0)) __PYX_ERR(0, 1406, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1407 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_6) < (0)) __PYX_ERR(0, 1407, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1408 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'full_ddm', +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1408, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 1408, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1409 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'full_ddm', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1409, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 1409, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_full_ddm) < (0)) __PYX_ERR(0, 1410, __pyx_L1_error) + + /* "cssm.pyx":1411 + * 'n_trials': n_trials, + * 'simulator': 'full_ddm', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'trajectory': traj, +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1411, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_6) < (0)) __PYX_ERR(0, 1411, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1412 + * 'simulator': 'full_ddm', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1412, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1412, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1412, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 1412, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1413 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 1413, __pyx_L1_error) + + /* "cssm.pyx":1414 + * 'possible_choices': [-1, 1], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm', +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 1414, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 1396, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1395 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + } + + /* "cssm.pyx":1415 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1415, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":1416 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1416, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1416, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_full_ddm) < (0)) __PYX_ERR(0, 1416, __pyx_L1_error) + + /* "cssm.pyx":1417 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_6 = PyList_New(2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1417, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1417, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1417, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1418 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm', + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1418, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_6) < (0)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1419 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1419, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":1420 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1420, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 1416, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1415 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'full_ddm', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":1423 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * + * # ------------------------------------------------------------------------------------------------- +*/ + /*else*/ { + __pyx_t_12 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1423, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1423, __pyx_L1_error) + } + + /* "cssm.pyx":1233 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_st.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sv.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sz.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.full_ddm", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_st.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sv.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sz.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sz_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sv_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_st_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_8genexpr5__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":1430 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_sdv(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + +static PyObject *__pyx_pf_4cssm_58__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":1437 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1437, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":1438 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1438, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":1439 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1439, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":1440 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1440, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":1430 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_sdv(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + __pyx_t_5 = PyTuple_New(10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, Py_None) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 1430, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_15ddm_sdv(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_14ddm_sdv, "\n Simulate reaction times and choices from a drift diffusion model with flexible boundaries and inter-trial variability in drift rate.\n\n Args:\n v (np.ndarray): Drift rate for each trial.\n a (np.ndarray): Boundary separation for each trial.\n z (np.ndarray): Starting point (between 0 and 1) for each trial.\n t (np.ndarray): Non-decision time for each trial.\n sv (np.ndarray): Standard deviation of drift rate for each trial.\n deadline (np.ndarray): Maximum reaction time allowed for each trial.\n s (np.ndarray): Noise standard deviation for each trial.\n delta_t (float): Time step size for simulation (default: 0.001).\n max_t (float): Maximum time for simulation (default: 20).\n n_samples (int): Number of samples to simulate per trial (default: 20000).\n n_trials (int): Number of trials to simulate (default: 1).\n boundary_fun (callable): Function defining the shape of the boundary over time.\n boundary_multiplicative (bool): If True, boundary function is multiplicative; if False, additive.\n boundary_params (dict): Parameters for the boundary function.\n random_state (int or None): Seed for random number generator (default: None).\n return_option (str): 'full' for complete output, 'minimal' for basic output (default: 'full').\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times (default: False).\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the return_option.\n\n Raises:\n ValueError: If return_option is neither 'full' nor 'minimal'.\n "); +static PyMethodDef __pyx_mdef_4cssm_15ddm_sdv = {"ddm_sdv", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_15ddm_sdv, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_14ddm_sdv}; +static PyObject *__pyx_pw_4cssm_15ddm_sdv(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_sv = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[17] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_sdv (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_sv,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1430, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_sdv", 1) < (0)) __PYX_ERR(0, 1430, __pyx_L3_error) + + /* "cssm.pyx":1441 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[13]) values[13] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1444 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 7; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_sdv", 0, 7, 17, i); __PYX_ERR(0, 1430, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1430, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1430, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1430, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1430, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1430, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1430, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1430, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1430, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":1441 + * int n_samples = 20000, + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[13]) values[13] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1444 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_t = ((PyArrayObject *)values[3]); + __pyx_v_sv = ((PyArrayObject *)values[4]); + __pyx_v_deadline = ((PyArrayObject *)values[5]); + __pyx_v_s = ((PyArrayObject *)values[6]); + if (values[7]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[7]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1437, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[8]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[8]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1438, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[9]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1439, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[10]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[10]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1440, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_boundary_fun = values[11]; + __pyx_v_boundary_multiplicative = values[12]; + __pyx_v_boundary_params = values[13]; + __pyx_v_random_state = values[14]; + __pyx_v_return_option = values[15]; + __pyx_v_smooth_unif = values[16]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_sdv", 0, 7, 17, __pyx_nargs); __PYX_ERR(0, 1430, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_sdv", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 1430, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 1431, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 1432, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 1433, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sv), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sv", 0))) __PYX_ERR(0, 1434, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 1435, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 1436, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_14ddm_sdv(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_t, __pyx_v_sv, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":1430 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_sdv(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_14ddm_sdv(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_sv, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sv_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + float __pyx_v_drift_increment; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_8genexpr6__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sv; + __Pyx_Buffer __pyx_pybuffer_sv; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_memviewslice __pyx_t_8 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + int __pyx_t_30; + Py_ssize_t __pyx_t_31; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_sdv", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_sv.pybuffer.buf = NULL; + __pyx_pybuffer_sv.refcount = 0; + __pyx_pybuffernd_sv.data = NULL; + __pyx_pybuffernd_sv.rcbuffer = &__pyx_pybuffer_sv; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1430, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1430, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1430, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1430, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sv.rcbuffer->pybuffer, (PyObject*)__pyx_v_sv, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1430, __pyx_L1_error) + } + __pyx_pybuffernd_sv.diminfo[0].strides = __pyx_pybuffernd_sv.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sv.diminfo[0].shape = __pyx_pybuffernd_sv.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1430, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1430, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":1479 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1479, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":1481 + * set_seed(random_state) + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1481, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1481, __pyx_L1_error); + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1481, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1481, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1482 + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:,:] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 1482, __pyx_L1_error) + + /* "cssm.pyx":1483 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj # <<<<<<<<<<<<<< + * + * # Param views +*/ + __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 1483, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_8; + __pyx_t_8.memview = NULL; + __pyx_t_8.data = NULL; + + /* "cssm.pyx":1486 + * + * # Param views + * cdef float[:] v_view = v # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] z_view = z +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1486, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1487 + * # Param views + * cdef float[:] v_view = v + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] z_view = z + * cdef float[:] t_view = t +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1487, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1488 + * cdef float[:] v_view = v + * cdef float[:] a_view = a + * cdef float[:] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] sv_view = sv +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1488, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1489 + * cdef float[:] a_view = a + * cdef float[:] z_view = z + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] sv_view = sv + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1489, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1490 + * cdef float[:] z_view = z + * cdef float[:] t_view = t + * cdef float[:] sv_view = sv # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_sv), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1490, __pyx_L1_error) + __pyx_v_sv_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1491 + * cdef float[:] t_view = t + * cdef float[:] sv_view = sv + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1491, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1492 + * cdef float[:] sv_view = sv + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1492, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1494 + * cdef float[:] s_view = s + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 1494, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 1494, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1494, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1494, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1494, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1495 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 1495, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 1495, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1495, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_2, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1495, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1497 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 1497, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":1498 + * + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 1498, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":1500 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":1504 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":1505 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_t_12}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_3 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1506 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1506, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1506, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1507 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * cdef float y, t_particle, smooth_u, deadline_tmp, sqrt_st +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1507, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1511 + * cdef float y, t_particle, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float drift_increment = 0.0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1512 + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 + * cdef float drift_increment = 0.0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_drift_increment = 0.0; + + /* "cssm.pyx":1513 + * cdef Py_ssize_t m = 0 + * cdef float drift_increment = 0.0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_9 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1513, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1515 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":1517 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * if boundary_multiplicative: +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1517, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 1517, __pyx_L7_error) + } + __pyx_t_4 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1517, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_4; + __pyx_t_4 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_17, &__pyx_t_16, &__pyx_t_4, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 1517, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_8genexpr6__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_8genexpr6__pyx_v_key); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1517, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1517, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr6__pyx_v_key, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 1517, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_key); __pyx_8genexpr6__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_key); __pyx_8genexpr6__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":1519 + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1519, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1520 + * + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_5 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1520, __pyx_L1_error) + __pyx_t_7 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_7, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1520, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_t_22}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_3 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1520, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":1519 + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} + * + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":1522 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_7 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (PyDict_SetItem(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1522, __pyx_L1_error) + __pyx_t_4 = __pyx_t_7; + __pyx_t_7 = 0; + if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1522, __pyx_L1_error) + __pyx_t_7 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_22, __pyx_t_7}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_12 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1522, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":1524 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_20) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":1525 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":1527 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * # initialize starting point + * y = ((-1) * boundary_view[0]) + (z_view[k] * 2.0 * (boundary_view[0])) # reset starting position +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":1529 + * for n in range(n_samples): + * # initialize starting point + * y = ((-1) * boundary_view[0]) + (z_view[k] * 2.0 * (boundary_view[0])) # reset starting position # <<<<<<<<<<<<<< + * + * # get drift by random displacement of v +*/ + __pyx_t_23 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_v_y = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_21 * __pyx_v_z_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":1532 + * + * # get drift by random displacement of v + * drift_increment = (v_view[k] + sv_view[k] * gaussian_values[m]) * delta_t # <<<<<<<<<<<<<< + * + * # increment m appropriately +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_m; + __pyx_v_drift_increment = (((*((float *) ( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_27 * __pyx_v_v_view.strides[0]) ))) + ((*((float *) ( /* dim=0 */ (__pyx_v_sv_view.data + __pyx_t_21 * __pyx_v_sv_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) ))))) * __pyx_v_delta_t); + + /* "cssm.pyx":1535 + * + * # increment m appropriately + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":1536 + * # increment m appropriately + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":1537 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_9 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1537, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1538 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * t_particle = 0.0 # reset time +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1536 + * # increment m appropriately + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":1540 + * m = 0 + * + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":1541 + * + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":1543 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1544 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1545 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_23 = 0; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":1544 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":1543 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":1548 + * + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_21 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L19_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L19_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":1549 + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += drift_increment + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_21 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (__pyx_v_drift_increment + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_21 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":1550 + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":1551 + * y += drift_increment + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":1552 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":1554 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1555 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1556 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * + * if m == num_draws: +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":1555 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + } + + /* "cssm.pyx":1554 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":1558 + * traj_view[ix, 0] = y + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":1559 + * + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_9 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1559, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1560 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1558 + * traj_view[ix, 0] = y + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":1562 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1562, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1563 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":1564 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1564, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":1563 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L26; + } + + /* "cssm.pyx":1565 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":1566 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1566, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":1565 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L26; + } + + /* "cssm.pyx":1568 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L26:; + + /* "cssm.pyx":1562 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":1570 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L25:; + + /* "cssm.pyx":1572 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = np.sign(y) # Store choice + * +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_21 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))) + __pyx_v_smooth_u); + + /* "cssm.pyx":1573 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # Store rt + * choices_view[n, k, 0] = np.sign(y) # Store choice # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sign); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_y); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1573, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_30 = __Pyx_PyLong_As_int(__pyx_t_1); if (unlikely((__pyx_t_30 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1573, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_23 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_30; + + /* "cssm.pyx":1575 + * choices_view[n, k, 0] = np.sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_31 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_27 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_31 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":1576 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_31 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_31 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":1575 + * choices_view[n, k, 0] = np.sign(y) # Store choice + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":1578 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1578, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1579 + * + * if return_option == 'full': + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + + /* "cssm.pyx":1580 + * if return_option == 'full': + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + + /* "cssm.pyx":1581 + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't': t, + * 'sv': sv, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + + /* "cssm.pyx":1582 + * 'a': a, + * 'z': z, + * 't': t, # <<<<<<<<<<<<<< + * 'sv': sv, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + + /* "cssm.pyx":1583 + * 'z': z, + * 't': t, + * 'sv': sv, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_sv, ((PyObject *)__pyx_v_sv)) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + + /* "cssm.pyx":1584 + * 't': t, + * 'sv': sv, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + + /* "cssm.pyx":1585 + * 'sv': sv, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + __pyx_t_12 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "cssm.pyx":1586 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 1586, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_12, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 1586, __pyx_L1_error) + } + + /* "cssm.pyx":1587 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_5) < (0)) __PYX_ERR(0, 1587, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1588 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1588, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_5) < (0)) __PYX_ERR(0, 1588, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1589 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_sdv', +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1589, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_5) < (0)) __PYX_ERR(0, 1589, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1590 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_sdv', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1590, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_5) < (0)) __PYX_ERR(0, 1590, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_sdv) < (0)) __PYX_ERR(0, 1591, __pyx_L1_error) + + /* "cssm.pyx":1592 + * 'n_trials': n_trials, + * 'simulator': 'ddm_sdv', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'trajectory': traj, +*/ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_5) < (0)) __PYX_ERR(0, 1592, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1593 + * 'simulator': 'ddm_sdv', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_5 = PyList_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1593, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1593, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_5) < (0)) __PYX_ERR(0, 1593, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1594 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 1594, __pyx_L1_error) + + /* "cssm.pyx":1595 + * 'possible_choices': [-1, 1], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_sdv', +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 1595, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 1579, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1578 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + } + + /* "cssm.pyx":1596 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_sdv', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1596, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":1597 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_sdv', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1597, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1597, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1597, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_sdv) < (0)) __PYX_ERR(0, 1597, __pyx_L1_error) + + /* "cssm.pyx":1598 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_sdv', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_5 = PyList_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1598, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1598, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1598, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_5) < (0)) __PYX_ERR(0, 1597, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1599 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_sdv', + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_5) < (0)) __PYX_ERR(0, 1597, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1600 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_5) < (0)) __PYX_ERR(0, 1597, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1601 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1601, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_5) < (0)) __PYX_ERR(0, 1597, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 1597, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1596 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_sdv', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":1604 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * + * # ------------------------------------------------------------------------------------------------- +*/ + /*else*/ { + __pyx_t_12 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1604, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1604, __pyx_L1_error) + } + + /* "cssm.pyx":1430 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_sdv(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_8, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sv.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_sdv", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sv.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sv_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_8genexpr6__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":1611 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ornstein_uhlenbeck(np.ndarray[float, ndim = 1] v, # drift parameter # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # initial boundary separation + * np.ndarray[float, ndim = 1] z, # starting point bias +*/ + +static PyObject *__pyx_pf_4cssm_60__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":1618 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # size of timestep # <<<<<<<<<<<<<< + * float max_t = 20, # maximal time in trial + * int n_samples = 20000, # number of samples from process +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":1619 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # size of timestep + * float max_t = 20, # maximal time in trial # <<<<<<<<<<<<<< + * int n_samples = 20000, # number of samples from process + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":1620 + * float delta_t = 0.001, # size of timestep + * float max_t = 20, # maximal time in trial + * int n_samples = 20000, # number of samples from process # <<<<<<<<<<<<<< + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":1621 + * float max_t = 20, # maximal time in trial + * int n_samples = 20000, # number of samples from process + * int n_trials = 1, # <<<<<<<<<<<<<< + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1621, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":1611 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ornstein_uhlenbeck(np.ndarray[float, ndim = 1] v, # drift parameter # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # initial boundary separation + * np.ndarray[float, ndim = 1] z, # starting point bias +*/ + __pyx_t_5 = PyTuple_New(10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, Py_None) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 1611, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_17ornstein_uhlenbeck(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_16ornstein_uhlenbeck, "\n Simulate reaction times and choices from an Ornstein-Uhlenbeck process with flexible boundaries.\n\n Args:\n v (np.ndarray): Drift parameter for each trial.\n a (np.ndarray): Initial boundary separation for each trial.\n z (np.ndarray): Starting point bias for each trial.\n g (np.ndarray): Decay parameter for each trial.\n t (np.ndarray): Non-decision time for each trial.\n deadline (np.ndarray): Maximum reaction time allowed for each trial.\n s (np.ndarray): Noise sigma for each trial.\n delta_t (float): Size of timestep for simulation (default: 0.001).\n max_t (float): Maximum time for simulation (default: 20).\n n_samples (int): Number of samples to simulate per trial (default: 20000).\n n_trials (int): Number of trials to simulate (default: 1).\n boundary_fun (callable): Function defining the shape of the boundary over time.\n boundary_multiplicative (bool): If True, boundary function is multiplicative; if False, additive.\n boundary_params (dict): Parameters for the boundary function.\n random_state (int or None): Seed for random number generator (default: None).\n return_option (str): 'full' for complete output, 'minimal' for basic output (default: 'full').\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times (default: False).\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the return_option.\n\n Raises:\n ValueError: If return_option is not 'full' or 'minimal'.\n "); +static PyMethodDef __pyx_mdef_4cssm_17ornstein_uhlenbeck = {"ornstein_uhlenbeck", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_17ornstein_uhlenbeck, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_16ornstein_uhlenbeck}; +static PyObject *__pyx_pw_4cssm_17ornstein_uhlenbeck(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_g = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[17] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ornstein_uhlenbeck (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_g,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1611, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ornstein_uhlenbeck", 1) < (0)) __PYX_ERR(0, 1611, __pyx_L3_error) + + /* "cssm.pyx":1622 + * int n_samples = 20000, # number of samples from process + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[13]) values[13] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1625 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 7; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ornstein_uhlenbeck", 0, 7, 17, i); __PYX_ERR(0, 1611, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1611, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1611, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1611, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1611, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1611, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1611, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1611, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1611, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":1622 + * int n_samples = 20000, # number of samples from process + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[13]) values[13] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1625 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_g = ((PyArrayObject *)values[3]); + __pyx_v_t = ((PyArrayObject *)values[4]); + __pyx_v_deadline = ((PyArrayObject *)values[5]); + __pyx_v_s = ((PyArrayObject *)values[6]); + if (values[7]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[7]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1618, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[8]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[8]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1619, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[9]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1620, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[10]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[10]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1621, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_boundary_fun = values[11]; + __pyx_v_boundary_multiplicative = values[12]; + __pyx_v_boundary_params = values[13]; + __pyx_v_random_state = values[14]; + __pyx_v_return_option = values[15]; + __pyx_v_smooth_unif = values[16]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ornstein_uhlenbeck", 0, 7, 17, __pyx_nargs); __PYX_ERR(0, 1611, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ornstein_uhlenbeck", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 1611, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 1612, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 1613, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_g), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "g", 0))) __PYX_ERR(0, 1614, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 1615, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 1616, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 1617, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_16ornstein_uhlenbeck(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_g, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":1611 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ornstein_uhlenbeck(np.ndarray[float, ndim = 1] v, # drift parameter # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # initial boundary separation + * np.ndarray[float, ndim = 1] z, # starting point bias +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_16ornstein_uhlenbeck(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_g_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_8genexpr7__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_g; + __Pyx_Buffer __pyx_pybuffer_g; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + PyObject *__pyx_t_7 = NULL; + __Pyx_memviewslice __pyx_t_8 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_t_12; + PyObject *__pyx_t_13 = NULL; + int __pyx_t_14; + int __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + Py_ssize_t __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + int __pyx_t_21; + Py_ssize_t __pyx_t_22; + PyObject *__pyx_t_23 = NULL; + Py_ssize_t __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + int __pyx_t_30; + Py_ssize_t __pyx_t_31; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ornstein_uhlenbeck", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_g.pybuffer.buf = NULL; + __pyx_pybuffer_g.refcount = 0; + __pyx_pybuffernd_g.data = NULL; + __pyx_pybuffernd_g.rcbuffer = &__pyx_pybuffer_g; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1611, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1611, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1611, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_g.rcbuffer->pybuffer, (PyObject*)__pyx_v_g, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1611, __pyx_L1_error) + } + __pyx_pybuffernd_g.diminfo[0].strides = __pyx_pybuffernd_g.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_g.diminfo[0].shape = __pyx_pybuffernd_g.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1611, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1611, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1611, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":1660 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1660, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":1662 + * set_seed(random_state) + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_3, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1662, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1662, __pyx_L1_error); + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1662, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1662, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1663 + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:,:] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 1663, __pyx_L1_error) + + /* "cssm.pyx":1664 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:,:] traj_view = traj # <<<<<<<<<<<<<< + * + * # Param views +*/ + __pyx_t_8 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_8.memview)) __PYX_ERR(0, 1664, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_8; + __pyx_t_8.memview = NULL; + __pyx_t_8.data = NULL; + + /* "cssm.pyx":1667 + * + * # Param views + * cdef float[:] v_view = v # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] z_view = z +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1667, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1668 + * # Param views + * cdef float[:] v_view = v + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] z_view = z + * cdef float[:] g_view = g +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1668, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1669 + * cdef float[:] v_view = v + * cdef float[:] a_view = a + * cdef float[:] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] g_view = g + * cdef float[:] t_view = t +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1669, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1670 + * cdef float[:] a_view = a + * cdef float[:] z_view = z + * cdef float[:] g_view = g # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_g), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1670, __pyx_L1_error) + __pyx_v_g_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1671 + * cdef float[:] z_view = z + * cdef float[:] g_view = g + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1671, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1672 + * cdef float[:] g_view = g + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1672, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1673 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * + * # Initializations +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1673, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1676 + * + * # Initializations + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # rt storage # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # choice storage + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 1676, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 1676, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1676, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_2}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1676, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1676, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1677 + * # Initializations + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # rt storage + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # choice storage # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 1677, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 1677, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1677, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_2 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_2, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1677, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_2); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1677, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1679 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # choice storage + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 1679, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":1680 + * + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = np.sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 1680, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":1682 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = np.sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = s * delta_t_sqrt + * +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_sqrt); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_t_12 = __Pyx_PyFloat_AsFloat(__pyx_t_1); if (unlikely((__pyx_t_12 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1682, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_delta_t_sqrt = __pyx_t_12; + + /* "cssm.pyx":1686 + * + * # Boundary Storage + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":1687 + * # Boundary Storage + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_13 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_t_13}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (4-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_7 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1687, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1688 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_13, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, __pyx_t_5}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_13, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1688, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1688, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":1689 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * cdef float y, t_particle, smooth_u, deadline_tmp, sqrt_st +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1689, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1693 + * cdef float y, t_particle, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1694 + * cdef Py_ssize_t n, ix, k + * cdef Py_ssize_t m = 0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_9 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1694, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1696 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_14 = __pyx_v_n_trials; + __pyx_t_15 = __pyx_t_14; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_15; __pyx_t_16+=1) { + __pyx_v_k = __pyx_t_16; + + /* "cssm.pyx":1698 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1698, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_17 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 1698, __pyx_L7_error) + } + __pyx_t_4 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_18), (&__pyx_t_19)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1698, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); + __pyx_t_7 = __pyx_t_4; + __pyx_t_4 = 0; + while (1) { + __pyx_t_20 = __Pyx_dict_iter_next(__pyx_t_7, __pyx_t_18, &__pyx_t_17, &__pyx_t_4, NULL, NULL, __pyx_t_19); + if (unlikely(__pyx_t_20 == 0)) break; + if (unlikely(__pyx_t_20 == -1)) __PYX_ERR(0, 1698, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_8genexpr7__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_8genexpr7__pyx_v_key); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1698, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_13 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1698, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_13); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_8genexpr7__pyx_v_key, (PyObject*)__pyx_t_13))) __PYX_ERR(0, 1698, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF(__pyx_8genexpr7__pyx_v_key); __pyx_8genexpr7__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_8genexpr7__pyx_v_key); __pyx_8genexpr7__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":1701 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_21 < 0))) __PYX_ERR(0, 1701, __pyx_L1_error) + if (__pyx_t_21) { + + /* "cssm.pyx":1702 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_22 = __pyx_v_k; + __pyx_t_5 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_22 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_23 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1702, __pyx_L1_error) + __pyx_t_3 = __pyx_t_23; + __pyx_t_23 = 0; + if (__Pyx_MergeKeywords(__pyx_t_3, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1702, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_5, __pyx_t_23}; + __pyx_t_13 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 1702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_13); + } + __pyx_t_7 = __pyx_t_13; + __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_13); __pyx_t_13 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1702, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1702, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":1701 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":1704 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __pyx_t_22 = __pyx_v_k; + __pyx_t_23 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_22 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1704, __pyx_L1_error) + __pyx_t_4 = __pyx_t_3; + __pyx_t_3 = 0; + if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1704, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_6 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_6 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_23, __pyx_t_3}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_6, (3-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __pyx_t_13 = __pyx_t_2; + __Pyx_INCREF(__pyx_t_13); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_13, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_13); __pyx_t_13 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1704, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1704, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":1706 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_22 = __pyx_v_k; + __pyx_t_24 = __pyx_v_k; + __pyx_t_12 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_22 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_24 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_21 = (__pyx_t_12 < __pyx_t_25); + if (__pyx_t_21) { + __pyx_t_26 = __pyx_t_12; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":1707 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_24 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_24 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":1709 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * boundary_view[0]) + * t_particle = 0.0 +*/ + __pyx_t_19 = __pyx_v_n_samples; + __pyx_t_20 = __pyx_t_19; + for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_20; __pyx_t_18+=1) { + __pyx_v_n = __pyx_t_18; + + /* "cssm.pyx":1710 + * # Loop over samples + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * boundary_view[0]) # <<<<<<<<<<<<<< + * t_particle = 0.0 + * ix = 0 +*/ + __pyx_t_24 = 0; + __pyx_t_22 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_v_y = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_24 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_22 * __pyx_v_z_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":1711 + * for n in range(n_samples): + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * boundary_view[0]) + * t_particle = 0.0 # <<<<<<<<<<<<<< + * ix = 0 + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":1712 + * y = (-1) * boundary_view[0] + (z_view[k] * 2 * boundary_view[0]) + * t_particle = 0.0 + * ix = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":1714 + * ix = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_21 = (__pyx_v_n == 0); + if (__pyx_t_21) { + + /* "cssm.pyx":1715 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_21 = (__pyx_v_k == 0); + if (__pyx_t_21) { + + /* "cssm.pyx":1716 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_27 = 0; + __pyx_t_22 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_22 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":1715 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":1714 + * ix = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":1719 + * + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * y += ((v_view[k] - (g_view[k] * y)) * delta_t) + sqrt_st * gaussian_values[m] + * t_particle += delta_t +*/ + while (1) { + __pyx_t_22 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_21 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_22 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_21 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_21 = __pyx_t_28; + __pyx_L18_bool_binop_done:; + if (!__pyx_t_21) break; + + /* "cssm.pyx":1720 + * # Random walker + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += ((v_view[k] - (g_view[k] * y)) * delta_t) + sqrt_st * gaussian_values[m] # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_22 = __pyx_v_k; + __pyx_t_27 = __pyx_v_k; + __pyx_t_24 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + ((((*((float *) ( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_22 * __pyx_v_v_view.strides[0]) ))) - ((*((float *) ( /* dim=0 */ (__pyx_v_g_view.data + __pyx_t_27 * __pyx_v_g_view.strides[0]) ))) * __pyx_v_y)) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_24 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":1721 + * while y >= (-1) * boundary_view[ix] and y <= boundary_view[ix] and t_particle <= deadline_tmp: + * y += ((v_view[k] - (g_view[k] * y)) * delta_t) + sqrt_st * gaussian_values[m] + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":1722 + * y += ((v_view[k] - (g_view[k] * y)) * delta_t) + sqrt_st * gaussian_values[m] + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":1723 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":1725 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_21 = (__pyx_v_n == 0); + if (__pyx_t_21) { + + /* "cssm.pyx":1726 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + __pyx_t_21 = (__pyx_v_k == 0); + if (__pyx_t_21) { + + /* "cssm.pyx":1727 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * + * if m == num_draws: +*/ + __pyx_t_24 = __pyx_v_ix; + __pyx_t_27 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_24 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_27 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":1726 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + } + + /* "cssm.pyx":1725 + * m += 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":1729 + * traj_view[ix, 0] = y + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_21 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_21) { + + /* "cssm.pyx":1730 + * + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_9 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 1730, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":1731 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1729 + * traj_view[ix, 0] = y + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":1733 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_21 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_21 < 0))) __PYX_ERR(0, 1733, __pyx_L1_error) + if (__pyx_t_21) { + + /* "cssm.pyx":1734 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_21 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_21) { + + /* "cssm.pyx":1735 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1735, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":1734 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":1736 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_21 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_21) { + + /* "cssm.pyx":1737 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1737, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":1736 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":1739 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L25:; + + /* "cssm.pyx":1733 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L24; + } + + /* "cssm.pyx":1741 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L24:; + + /* "cssm.pyx":1743 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = sign(y) + * +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_24 = __pyx_v_n; + __pyx_t_22 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_24 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_22 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_27 * __pyx_v_t_view.strides[0]) )))) + __pyx_v_smooth_u); + + /* "cssm.pyx":1744 + * + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u + * choices_view[n, k, 0] = sign(y) # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_30 = __pyx_f_4cssm_sign(__pyx_v_y); if (unlikely(__pyx_t_30 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1744, __pyx_L1_error) + __pyx_t_27 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_22 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_22 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_30; + + /* "cssm.pyx":1746 + * choices_view[n, k, 0] = sign(y) + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_22 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_24 = __pyx_v_k; + __pyx_t_31 = __pyx_v_k; + __pyx_t_21 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_22 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_24 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_31 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_21) { + + /* "cssm.pyx":1747 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_31 = __pyx_v_n; + __pyx_t_24 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_31 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_24 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":1746 + * choices_view[n, k, 0] = sign(y) + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":1749 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + __pyx_t_21 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_21 < 0))) __PYX_ERR(0, 1749, __pyx_L1_error) + if (__pyx_t_21) { + + /* "cssm.pyx":1750 + * + * if return_option == 'full': + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(7); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1750, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + + /* "cssm.pyx":1751 + * if return_option == 'full': + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 'g': g, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + + /* "cssm.pyx":1752 + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 'g': g, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + + /* "cssm.pyx":1753 + * 'a': a, + * 'z': z, + * 'g': g, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_g, ((PyObject *)__pyx_v_g)) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + + /* "cssm.pyx":1754 + * 'z': z, + * 'g': g, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + + /* "cssm.pyx":1755 + * 'g': g, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + + /* "cssm.pyx":1756 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + __pyx_t_2 = __pyx_t_5; + __pyx_t_5 = 0; + + /* "cssm.pyx":1757 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 1757, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_2, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 1757, __pyx_L1_error) + } + + /* "cssm.pyx":1758 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1758, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_5) < (0)) __PYX_ERR(0, 1758, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1759 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_5 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1759, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_5) < (0)) __PYX_ERR(0, 1759, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1760 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ornstein_uhlenbeck', +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1760, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_5) < (0)) __PYX_ERR(0, 1760, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1761 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ornstein_uhlenbeck', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1761, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_5) < (0)) __PYX_ERR(0, 1761, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ornstein_uhlenbeck) < (0)) __PYX_ERR(0, 1762, __pyx_L1_error) + + /* "cssm.pyx":1763 + * 'n_trials': n_trials, + * 'simulator': 'ornstein_uhlenbeck', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'trajectory': traj, +*/ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1763, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_5) < (0)) __PYX_ERR(0, 1763, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1764 + * 'simulator': 'ornstein_uhlenbeck', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_5 = PyList_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1764, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1764, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1764, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_5) < (0)) __PYX_ERR(0, 1764, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1765 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [-1, 1], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 1765, __pyx_L1_error) + + /* "cssm.pyx":1766 + * 'possible_choices': [-1, 1], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ornstein_uhlenbeck', +*/ + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 1766, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_2) < (0)) __PYX_ERR(0, 1750, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1749 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { 'rts': rts, 'choices': choices, 'metadata': {'v': v, + * 'a': a, +*/ + } + + /* "cssm.pyx":1767 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ornstein_uhlenbeck', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_21 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_21 < 0))) __PYX_ERR(0, 1767, __pyx_L1_error) + if (likely(__pyx_t_21)) { + + /* "cssm.pyx":1768 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ornstein_uhlenbeck', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1768, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1768, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1768, __pyx_L1_error) + __pyx_t_2 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1768, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ornstein_uhlenbeck) < (0)) __PYX_ERR(0, 1768, __pyx_L1_error) + + /* "cssm.pyx":1769 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ornstein_uhlenbeck', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_5 = PyList_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1769, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1769, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1769, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_5) < (0)) __PYX_ERR(0, 1768, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1770 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ornstein_uhlenbeck', + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1770, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_5) < (0)) __PYX_ERR(0, 1768, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1771 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1771, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_5) < (0)) __PYX_ERR(0, 1768, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1772 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1772, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_5) < (0)) __PYX_ERR(0, 1768, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_2) < (0)) __PYX_ERR(0, 1768, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1767 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ornstein_uhlenbeck', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":1775 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # -------------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_2 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1775, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 1775, __pyx_L1_error) + } + + /* "cssm.pyx":1611 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ornstein_uhlenbeck(np.ndarray[float, ndim = 1] v, # drift parameter # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # initial boundary separation + * np.ndarray[float, ndim = 1] z, # starting point bias +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_8, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_13); + __Pyx_XDECREF(__pyx_t_23); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ornstein_uhlenbeck", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_g_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_8genexpr7__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":1785 + * + * # Function that checks boundary crossing of particles + * cdef bint check_finished(float[:] particles, float boundary, int n): # <<<<<<<<<<<<<< + * """ + * Check if any particle has crossed the boundary. +*/ + +static int __pyx_f_4cssm_check_finished(__Pyx_memviewslice __pyx_v_particles, float __pyx_v_boundary, int __pyx_v_n) { + int __pyx_v_i; + int __pyx_r; + int __pyx_t_1; + int __pyx_t_2; + int __pyx_t_3; + Py_ssize_t __pyx_t_4; + int __pyx_t_5; + + /* "cssm.pyx":1798 + * """ + * cdef int i + * for i in range(n): # <<<<<<<<<<<<<< + * if particles[i] > boundary: + * return True +*/ + __pyx_t_1 = __pyx_v_n; + __pyx_t_2 = __pyx_t_1; + for (__pyx_t_3 = 0; __pyx_t_3 < __pyx_t_2; __pyx_t_3+=1) { + __pyx_v_i = __pyx_t_3; + + /* "cssm.pyx":1799 + * cdef int i + * for i in range(n): + * if particles[i] > boundary: # <<<<<<<<<<<<<< + * return True + * return False +*/ + __pyx_t_4 = __pyx_v_i; + __pyx_t_5 = ((*((float *) ( /* dim=0 */ (__pyx_v_particles.data + __pyx_t_4 * __pyx_v_particles.strides[0]) ))) > __pyx_v_boundary); + if (__pyx_t_5) { + + /* "cssm.pyx":1800 + * for i in range(n): + * if particles[i] > boundary: + * return True # <<<<<<<<<<<<<< + * return False + * +*/ + __pyx_r = 1; + goto __pyx_L0; + + /* "cssm.pyx":1799 + * cdef int i + * for i in range(n): + * if particles[i] > boundary: # <<<<<<<<<<<<<< + * return True + * return False +*/ + } + } + + /* "cssm.pyx":1801 + * if particles[i] > boundary: + * return True + * return False # <<<<<<<<<<<<<< + * + * #def test_check(): +*/ + __pyx_r = 0; + goto __pyx_L0; + + /* "cssm.pyx":1785 + * + * # Function that checks boundary crossing of particles + * cdef bint check_finished(float[:] particles, float boundary, int n): # <<<<<<<<<<<<<< + * """ + * Check if any particle has crossed the boundary. +*/ + + /* function exit code */ + __pyx_L0:; + return __pyx_r; +} + +/* "cssm.pyx":1819 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def race_model(np.ndarray[float, ndim = 2] v, # np.array expected, one column of floats # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # initial boundary separation + * np.ndarray[float, ndim = 2] z, # np.array expected, one column of floats +*/ + +static PyObject *__pyx_pf_4cssm_62__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":1825 + * np.ndarray[float, ndim = 2] s, # np.array expected, one column of floats + * np.ndarray[float, ndim = 1] deadline, + * float delta_t = 0.001, # time increment step # <<<<<<<<<<<<<< + * float max_t = 20, # maximum rt allowed + * int n_samples = 2000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1825, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":1826 + * np.ndarray[float, ndim = 1] deadline, + * float delta_t = 0.001, # time increment step + * float max_t = 20, # maximum rt allowed # <<<<<<<<<<<<<< + * int n_samples = 2000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1826, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":1827 + * float delta_t = 0.001, # time increment step + * float max_t = 20, # maximum rt allowed + * int n_samples = 2000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * boundary_fun = None, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x7D0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1827, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":1828 + * float max_t = 20, # maximum rt allowed + * int n_samples = 2000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * boundary_fun = None, + * boundary_multiplicative = True, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1828, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":1819 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def race_model(np.ndarray[float, ndim = 2] v, # np.array expected, one column of floats # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # initial boundary separation + * np.ndarray[float, ndim = 2] z, # np.array expected, one column of floats +*/ + __pyx_t_5 = PyTuple_New(10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, Py_None) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 1819, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_19race_model(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_18race_model, "\n Simulate reaction times and choices from a race model with N samples.\n\n Args:\n v (np.ndarray): Drift rates for each accumulator and trial.\n a (np.ndarray): Initial boundary separation for each trial.\n z (np.ndarray): Starting points for each accumulator and trial.\n t (np.ndarray): Non-decision time for each trial.\n s (np.ndarray): Noise standard deviation for each accumulator and trial.\n deadline (np.ndarray): Maximum reaction time allowed for each trial.\n delta_t (float): Time increment step for simulation (default: 0.001).\n max_t (float): Maximum time for simulation (default: 20).\n n_samples (int): Number of samples to simulate per trial (default: 2000).\n n_trials (int): Number of trials to simulate (default: 1).\n boundary_fun (callable): Function defining the shape of the boundary over time.\n boundary_multiplicative (bool): If True, boundary function is multiplicative; if False, additive.\n boundary_params (dict): Parameters for the boundary function.\n random_state (int or None): Seed for random number generator (default: None).\n return_option (str): 'full' for complete output, 'minimal' for basic output (default: 'full').\n smooth_unif (bool): Whether to apply uniform smoothing to reaction times (default: False).\n **kwargs: Additional keyword arguments.\n\n Returns:\n dict: A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the return_option.\n\n Raises:\n ValueError: If return_option is not 'full' or 'minimal'.\n "); +static PyMethodDef __pyx_mdef_4cssm_19race_model = {"race_model", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_19race_model, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_18race_model}; +static PyObject *__pyx_pw_4cssm_19race_model(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_s = 0; + PyArrayObject *__pyx_v_deadline = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[16] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("race_model (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 1819, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "race_model", 1) < (0)) __PYX_ERR(0, 1819, __pyx_L3_error) + + /* "cssm.pyx":1829 + * int n_samples = 2000, + * int n_trials = 1, + * boundary_fun = None, # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[12]) values[12] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1832 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 6; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("race_model", 0, 6, 16, i); __PYX_ERR(0, 1819, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 1819, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 1819, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 1819, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 1819, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 1819, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 1819, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 1819, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":1829 + * int n_samples = 2000, + * int n_trials = 1, + * boundary_fun = None, # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[12]) values[12] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":1832 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_t = ((PyArrayObject *)values[3]); + __pyx_v_s = ((PyArrayObject *)values[4]); + __pyx_v_deadline = ((PyArrayObject *)values[5]); + if (values[6]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1825, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[7]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[7]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1826, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[8]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[8]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1827, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x7D0)); + } + if (values[9]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1828, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_boundary_fun = values[10]; + __pyx_v_boundary_multiplicative = values[11]; + __pyx_v_boundary_params = values[12]; + __pyx_v_random_state = values[13]; + __pyx_v_return_option = values[14]; + __pyx_v_smooth_unif = values[15]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("race_model", 0, 6, 16, __pyx_nargs); __PYX_ERR(0, 1819, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.race_model", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 1819, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 1820, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 1821, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 1822, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 1823, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 1824, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_18race_model(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_t, __pyx_v_s, __pyx_v_deadline, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":1819 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def race_model(np.ndarray[float, ndim = 2] v, # np.array expected, one column of floats # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # initial boundary separation + * np.ndarray[float, ndim = 2] z, # np.array expected, one column of floats +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_18race_model(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_s, PyArrayObject *__pyx_v_deadline, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + CYTHON_UNUSED __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + PyObject *__pyx_v_sqrt_st = NULL; + __Pyx_memviewslice __pyx_v_sqrt_st_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_n_particles; + PyObject *__pyx_v_rts = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_particles = NULL; + __Pyx_memviewslice __pyx_v_particles_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_num_steps; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_t_particle; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_j; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + int __pyx_v_num_draws; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_v_v_dict = NULL; + PyObject *__pyx_v_z_dict = NULL; + PyObject *__pyx_v_i = NULL; + PyObject *__pyx_8genexpr8__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_3 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + PyObject *__pyx_t_23 = NULL; + Py_ssize_t __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + float __pyx_t_27; + int __pyx_t_28; + int __pyx_t_29; + Py_ssize_t __pyx_t_30; + int __pyx_t_31; + int __pyx_t_32; + Py_ssize_t __pyx_t_33; + Py_ssize_t __pyx_t_34; + PyObject *(*__pyx_t_35)(PyObject *); + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("race_model", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1819, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_v.diminfo[1].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_v.diminfo[1].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1819, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_a.diminfo[1].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_a.diminfo[1].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1819, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_z.diminfo[1].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_z.diminfo[1].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1819, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_t.diminfo[1].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_t.diminfo[1].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1819, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_s.diminfo[1].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_s.diminfo[1].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 1819, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":1866 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:, :] v_view = v +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1866, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":1868 + * set_seed(random_state) + * # Param views + * cdef float[:, :] v_view = v # <<<<<<<<<<<<<< + * cdef float[:, :] z_view = z + * cdef float[:, :] a_view = a +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1868, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1869 + * # Param views + * cdef float[:, :] v_view = v + * cdef float[:, :] z_view = z # <<<<<<<<<<<<<< + * cdef float[:, :] a_view = a + * cdef float[:, :] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1869, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1870 + * cdef float[:, :] v_view = v + * cdef float[:, :] z_view = z + * cdef float[:, :] a_view = a # <<<<<<<<<<<<<< + * cdef float[:, :] t_view = t + * cdef float[:, :] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1870, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1871 + * cdef float[:, :] z_view = z + * cdef float[:, :] a_view = a + * cdef float[:, :] t_view = t # <<<<<<<<<<<<<< + * cdef float[:, :] s_view = s + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1871, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1872 + * cdef float[:, :] a_view = a + * cdef float[:, :] t_view = t + * cdef float[:, :] s_view = s # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1872, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1873 + * cdef float[:, :] t_view = t + * cdef float[:, :] s_view = s + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) +*/ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 1873, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":1875 + * cdef float[:] deadline_view = deadline + * + * cdef float delta_t_sqrt = sqrt(delta_t) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s + * cdef float[:, :] sqrt_st_view = sqrt_st +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":1876 + * + * cdef float delta_t_sqrt = sqrt(delta_t) + * sqrt_st = delta_t_sqrt * s # <<<<<<<<<<<<<< + * cdef float[:, :] sqrt_st_view = sqrt_st + * +*/ + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_delta_t_sqrt); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1876, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = PyNumber_Multiply(__pyx_t_1, ((PyObject *)__pyx_v_s)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1876, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_sqrt_st = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":1877 + * cdef float delta_t_sqrt = sqrt(delta_t) + * sqrt_st = delta_t_sqrt * s + * cdef float[:, :] sqrt_st_view = sqrt_st # <<<<<<<<<<<<<< + * + * cdef int n_particles = v.shape[1] +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_sqrt_st, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1877, __pyx_L1_error) + __pyx_v_sqrt_st_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1879 + * cdef float[:, :] sqrt_st_view = sqrt_st + * + * cdef int n_particles = v.shape[1] # <<<<<<<<<<<<<< + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_v_n_particles = (__pyx_f_5numpy_7ndarray_5shape_shape(((PyArrayObject *)__pyx_v_v))[1]); + + /* "cssm.pyx":1880 + * + * cdef int n_particles = v.shape[1] + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_view = rts + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) +*/ + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1880, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 1880, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1880, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_1, __pyx_t_8}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1880, __pyx_L1_error) + __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_rts = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":1881 + * cdef int n_particles = v.shape[1] + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef int[:, :, :] choices_view = choices +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 1881, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":1882 + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * cdef float[:, :, :] rts_view = rts + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_1 = PyTuple_New(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 1882, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 1882, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1882, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_1}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1882, __pyx_L1_error) + __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1882, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_choices = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":1883 + * cdef float[:, :, :] rts_view = rts + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * particles = np.zeros((n_particles), dtype = DTYPE) +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 1883, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":1885 + * cdef int[:, :, :] choices_view = choices + * + * particles = np.zeros((n_particles), dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float [:] particles_view = particles + * +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_particles); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GetModuleGlobalName(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_t_8}; + __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_1, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1885, __pyx_L1_error) + __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_particles = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":1886 + * + * particles = np.zeros((n_particles), dtype = DTYPE) + * cdef float [:] particles_view = particles # <<<<<<<<<<<<<< + * + * # TD: Add Trajectory +*/ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_particles, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 1886, __pyx_L1_error) + __pyx_v_particles_view = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":1889 + * + * # TD: Add Trajectory + * traj = np.zeros((int(max_t / delta_t) + 1, n_particles), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyLong_AddObjC(__pyx_t_6, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_particles); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 1889, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 1889, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_1); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_1, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1889, __pyx_L1_error) + __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_1, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_traj = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":1890 + * # TD: Add Trajectory + * traj = np.zeros((int(max_t / delta_t) + 1, n_particles), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 1890, __pyx_L1_error) + + /* "cssm.pyx":1891 + * traj = np.zeros((int(max_t / delta_t) + 1, n_particles), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * # Boundary storage +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 1891, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":1894 + * + * # Boundary storage + * cdef int num_steps = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) +*/ + __pyx_v_num_steps = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":1896 + * cdef int num_steps = int((max_t / delta_t) + 1) + * + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_0, __pyx_t_7, __pyx_t_12}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_1 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1896, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_t_s = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":1897 + * + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_1, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_8, __pyx_t_5}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 1897, __pyx_L1_error) + __pyx_t_4 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_1, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1897, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_v_boundary = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":1898 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * # Initialize variables needed for for loop +*/ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 1898, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":1903 + * cdef float t_particle, smooth_u, deadline_tmp + * cdef Py_ssize_t n, ix, j, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * + * cdef int num_draws = num_steps * n_particles +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1905 + * cdef Py_ssize_t m = 0 + * + * cdef int num_draws = num_steps * n_particles # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_num_draws = (__pyx_v_num_steps * __pyx_v_n_particles); + + /* "cssm.pyx":1906 + * + * cdef int num_draws = num_steps * n_particles + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_3 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 1906, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":1908 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":1910 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_4 = PyDict_New(); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1910, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 1910, __pyx_L7_error) + } + __pyx_t_7 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1910, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_7; + __pyx_t_7 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_17, &__pyx_t_16, &__pyx_t_7, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 1910, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_8genexpr8__pyx_v_key, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_8genexpr8__pyx_v_key); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 1910, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_7, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1910, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_4, (PyObject*)__pyx_8genexpr8__pyx_v_key, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 1910, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_key); __pyx_8genexpr8__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_key); __pyx_8genexpr8__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "cssm.pyx":1913 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1913, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1914 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = 0; + __pyx_t_5 = PyFloat_FromDouble((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) ) + __pyx_t_22 * __pyx_v_a_view.strides[1]) )))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_23 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1914, __pyx_L1_error) + __pyx_t_6 = __pyx_t_23; + __pyx_t_23 = 0; + if (__Pyx_MergeKeywords(__pyx_t_6, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1914, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_5, __pyx_t_23}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_1 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_8}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_4, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1914, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":1913 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":1916 + * boundary[:] = np.multiply(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k, 0]) +*/ + /*else*/ { + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __pyx_t_22 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_23 = PyFloat_FromDouble((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_22 * __pyx_v_a_view.strides[0]) ) + __pyx_t_21 * __pyx_v_a_view.strides[1]) )))); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 1916, __pyx_L1_error) + __pyx_t_7 = __pyx_t_6; + __pyx_t_6 = 0; + if (__Pyx_MergeKeywords(__pyx_t_7, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 1916, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_23, __pyx_t_6}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_12 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_5}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1916, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_4, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 1916, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":1918 + * boundary[:] = np.add(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k, 0]) # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = __pyx_v_k; + __pyx_t_24 = 0; + __pyx_t_25 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_22 * __pyx_v_t_view.strides[0]) ) + __pyx_t_24 * __pyx_v_t_view.strides[1]) )))); + __pyx_t_26 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_25 < __pyx_t_26); + if (__pyx_t_20) { + __pyx_t_27 = __pyx_t_25; + } else { + __pyx_t_27 = __pyx_t_26; + } + __pyx_v_deadline_tmp = __pyx_t_27; + + /* "cssm.pyx":1920 + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k, 0]) + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * for j in range(n_particles): + * particles_view[j] = z_view[k, j] * boundary_view[0] # Reset particle starting points +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":1921 + * # Loop over samples + * for n in range(n_samples): + * for j in range(n_particles): # <<<<<<<<<<<<<< + * particles_view[j] = z_view[k, j] * boundary_view[0] # Reset particle starting points + * +*/ + __pyx_t_28 = __pyx_v_n_particles; + __pyx_t_29 = __pyx_t_28; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_29; __pyx_t_16+=1) { + __pyx_v_j = __pyx_t_16; + + /* "cssm.pyx":1922 + * for n in range(n_samples): + * for j in range(n_particles): + * particles_view[j] = z_view[k, j] * boundary_view[0] # Reset particle starting points # <<<<<<<<<<<<<< + * + * t_particle = 0.0 # reset time +*/ + __pyx_t_24 = __pyx_v_k; + __pyx_t_22 = __pyx_v_j; + __pyx_t_21 = 0; + __pyx_t_30 = __pyx_v_j; + *((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_30 * __pyx_v_particles_view.strides[0]) )) = ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_24 * __pyx_v_z_view.strides[0]) ) + __pyx_t_22 * __pyx_v_z_view.strides[1]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + } + + /* "cssm.pyx":1924 + * particles_view[j] = z_view[k, j] * boundary_view[0] # Reset particle starting points + * + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":1925 + * + * t_particle = 0.0 # reset time + * ix = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":1927 + * ix = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * for j in range(n_particles): +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1928 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * for j in range(n_particles): + * traj_view[0, j] = particles[j] +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1929 + * if n == 0: + * if k == 0: + * for j in range(n_particles): # <<<<<<<<<<<<<< + * traj_view[0, j] = particles[j] + * +*/ + __pyx_t_28 = __pyx_v_n_particles; + __pyx_t_29 = __pyx_t_28; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_29; __pyx_t_16+=1) { + __pyx_v_j = __pyx_t_16; + + /* "cssm.pyx":1930 + * if k == 0: + * for j in range(n_particles): + * traj_view[0, j] = particles[j] # <<<<<<<<<<<<<< + * + * # Random walker +*/ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_particles, __pyx_v_j, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1930, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_27 = __Pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_27 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1930, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_21 = 0; + __pyx_t_22 = __pyx_v_j; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_22 * __pyx_v_traj_view.strides[1]) )) = __pyx_t_27; + } + + /* "cssm.pyx":1928 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * for j in range(n_particles): + * traj_view[0, j] = particles[j] +*/ + } + + /* "cssm.pyx":1927 + * ix = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * for j in range(n_particles): +*/ + } + + /* "cssm.pyx":1933 + * + * # Random walker + * while not check_finished(particles_view, boundary_view[ix], n_particles) and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * for j in range(n_particles): + * particles_view[j] += (v_view[k, j] * delta_t) + sqrt_st_view[k, j] * gaussian_values[m] +*/ + while (1) { + __pyx_t_22 = __pyx_v_ix; + __pyx_t_31 = __pyx_f_4cssm_check_finished(__pyx_v_particles_view, (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) ))), __pyx_v_n_particles); if (unlikely(__pyx_t_31 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1933, __pyx_L1_error) + __pyx_t_32 = (!__pyx_t_31); + if (__pyx_t_32) { + } else { + __pyx_t_20 = __pyx_t_32; + goto __pyx_L22_bool_binop_done; + } + __pyx_t_32 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_32; + __pyx_L22_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":1934 + * # Random walker + * while not check_finished(particles_view, boundary_view[ix], n_particles) and t_particle <= deadline_tmp: + * for j in range(n_particles): # <<<<<<<<<<<<<< + * particles_view[j] += (v_view[k, j] * delta_t) + sqrt_st_view[k, j] * gaussian_values[m] + * particles_view[j] = fmax(0.0, particles_view[j]) # Cut off particles at 0 +*/ + __pyx_t_28 = __pyx_v_n_particles; + __pyx_t_29 = __pyx_t_28; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_29; __pyx_t_16+=1) { + __pyx_v_j = __pyx_t_16; + + /* "cssm.pyx":1935 + * while not check_finished(particles_view, boundary_view[ix], n_particles) and t_particle <= deadline_tmp: + * for j in range(n_particles): + * particles_view[j] += (v_view[k, j] * delta_t) + sqrt_st_view[k, j] * gaussian_values[m] # <<<<<<<<<<<<<< + * particles_view[j] = fmax(0.0, particles_view[j]) # Cut off particles at 0 + * m += 1 +*/ + __pyx_t_22 = __pyx_v_k; + __pyx_t_21 = __pyx_v_j; + __pyx_t_24 = __pyx_v_k; + __pyx_t_30 = __pyx_v_j; + __pyx_t_33 = __pyx_v_m; + __pyx_t_34 = __pyx_v_j; + *((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_34 * __pyx_v_particles_view.strides[0]) )) += (((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_22 * __pyx_v_v_view.strides[0]) ) + __pyx_t_21 * __pyx_v_v_view.strides[1]) ))) * __pyx_v_delta_t) + ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sqrt_st_view.data + __pyx_t_24 * __pyx_v_sqrt_st_view.strides[0]) ) + __pyx_t_30 * __pyx_v_sqrt_st_view.strides[1]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_33 * __pyx_v_gaussian_values.strides[0]) ))))); + + /* "cssm.pyx":1936 + * for j in range(n_particles): + * particles_view[j] += (v_view[k, j] * delta_t) + sqrt_st_view[k, j] * gaussian_values[m] + * particles_view[j] = fmax(0.0, particles_view[j]) # Cut off particles at 0 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_t_33 = __pyx_v_j; + __pyx_t_30 = __pyx_v_j; + *((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_30 * __pyx_v_particles_view.strides[0]) )) = fmax(0.0, (*((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_33 * __pyx_v_particles_view.strides[0]) )))); + + /* "cssm.pyx":1937 + * particles_view[j] += (v_view[k, j] * delta_t) + sqrt_st_view[k, j] * gaussian_values[m] + * particles_view[j] = fmax(0.0, particles_view[j]) # Cut off particles at 0 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * m = 0 +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":1938 + * particles_view[j] = fmax(0.0, particles_view[j]) # Cut off particles at 0 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * m = 0 + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":1939 + * m += 1 + * if m == num_draws: + * m = 0 # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * t_particle += delta_t +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":1940 + * if m == num_draws: + * m = 0 + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_3 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 1940, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":1938 + * particles_view[j] = fmax(0.0, particles_view[j]) # Cut off particles at 0 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * m = 0 + * gaussian_values = draw_gaussian(num_draws) +*/ + } + } + + /* "cssm.pyx":1941 + * m = 0 + * gaussian_values = draw_gaussian(num_draws) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * if n == 0: +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":1942 + * gaussian_values = draw_gaussian(num_draws) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * if n == 0: + * if k == 0: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":1943 + * t_particle += delta_t + * ix += 1 + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * for j in range(n_particles): +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1944 + * ix += 1 + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * for j in range(n_particles): + * traj_view[ix, j] = particles[j] +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":1945 + * if n == 0: + * if k == 0: + * for j in range(n_particles): # <<<<<<<<<<<<<< + * traj_view[ix, j] = particles[j] + * +*/ + __pyx_t_28 = __pyx_v_n_particles; + __pyx_t_29 = __pyx_t_28; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_29; __pyx_t_16+=1) { + __pyx_v_j = __pyx_t_16; + + /* "cssm.pyx":1946 + * if k == 0: + * for j in range(n_particles): + * traj_view[ix, j] = particles[j] # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_t_4 = __Pyx_GetItemInt(__pyx_v_particles, __pyx_v_j, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1946, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_27 = __Pyx_PyFloat_AsFloat(__pyx_t_4); if (unlikely((__pyx_t_27 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1946, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_33 = __pyx_v_ix; + __pyx_t_30 = __pyx_v_j; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_33 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_30 * __pyx_v_traj_view.strides[1]) )) = __pyx_t_27; + } + + /* "cssm.pyx":1944 + * ix += 1 + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * for j in range(n_particles): + * traj_view[ix, j] = particles[j] +*/ + } + + /* "cssm.pyx":1943 + * t_particle += delta_t + * ix += 1 + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * for j in range(n_particles): +*/ + } + } + + /* "cssm.pyx":1948 + * traj_view[ix, j] = particles[j] + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1948, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1949 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":1950 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_27 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_27 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1950, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_27 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":1949 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L32; + } + + /* "cssm.pyx":1951 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":1952 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_27 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_27 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 1952, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_27) * __pyx_v_delta_t); + + /* "cssm.pyx":1951 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L32; + } + + /* "cssm.pyx":1954 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L32:; + + /* "cssm.pyx":1948 + * traj_view[ix, j] = particles[j] + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L31; + } + + /* "cssm.pyx":1956 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n , k, 0] = t_particle + t[k, 0] + smooth_u # for now no t per choice option +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L31:; + + /* "cssm.pyx":1958 + * smooth_u = 0.0 + * + * rts_view[n , k, 0] = t_particle + t[k, 0] + smooth_u # for now no t per choice option # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = np.argmax(particles) + * #rts_view[n, 0] = t + t[choices_view[n, 0]] +*/ + __pyx_t_30 = __pyx_v_k; + __pyx_t_33 = 0; + __pyx_t_24 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_24 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_22 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_t.rcbuffer->pybuffer.buf, __pyx_t_30, __pyx_pybuffernd_t.diminfo[0].strides, __pyx_t_33, __pyx_pybuffernd_t.diminfo[1].strides))) + __pyx_v_smooth_u); + + /* "cssm.pyx":1959 + * + * rts_view[n , k, 0] = t_particle + t[k, 0] + smooth_u # for now no t per choice option + * choices_view[n, k, 0] = np.argmax(particles) # <<<<<<<<<<<<<< + * #rts_view[n, 0] = t + t[choices_view[n, 0]] + * +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_argmax); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_particles}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1959, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_28 = __Pyx_PyLong_As_int(__pyx_t_4); if (unlikely((__pyx_t_28 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 1959, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_33 = __pyx_v_n; + __pyx_t_30 = __pyx_v_k; + __pyx_t_22 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_33 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_30 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_22 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_28; + + /* "cssm.pyx":1962 + * #rts_view[n, 0] = t + t[choices_view[n, 0]] + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_22 = __pyx_v_n; + __pyx_t_30 = __pyx_v_k; + __pyx_t_33 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_24 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_22 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_30 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_33 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_24 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":1963 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_24 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_33 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_24 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_33 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":1962 + * #rts_view[n, 0] = t + t[choices_view[n, 0]] + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + + /* "cssm.pyx":1967 + * + * # Create some dics + * v_dict = {} # <<<<<<<<<<<<<< + * z_dict = {} + * #t_dict = {} +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1967, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_v_dict, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "cssm.pyx":1968 + * # Create some dics + * v_dict = {} + * z_dict = {} # <<<<<<<<<<<<<< + * #t_dict = {} + * for i in range(n_particles): +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_z_dict, ((PyObject*)__pyx_t_4)); + __pyx_t_4 = 0; + + /* "cssm.pyx":1970 + * z_dict = {} + * #t_dict = {} + * for i in range(n_particles): # <<<<<<<<<<<<<< + * v_dict['v' + str(i)] = v[:, i] + * z_dict['z' + str(i)] = z[:, i] +*/ + __pyx_t_12 = NULL; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_particles); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_8}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)(&PyRange_Type), __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_8 = PyObject_GetIter(__pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1970, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_35 = (CYTHON_COMPILING_IN_LIMITED_API) ? PyIter_Next : __Pyx_PyObject_GetIterNextFunc(__pyx_t_8); if (unlikely(!__pyx_t_35)) __PYX_ERR(0, 1970, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + for (;;) { + { + __pyx_t_4 = __pyx_t_35(__pyx_t_8); + if (unlikely(!__pyx_t_4)) { + PyObject* exc_type = PyErr_Occurred(); + if (exc_type) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) __PYX_ERR(0, 1970, __pyx_L1_error) + PyErr_Clear(); + } + break; + } + } + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_v_i, __pyx_t_4); + __pyx_t_4 = 0; + + /* "cssm.pyx":1971 + * #t_dict = {} + * for i in range(n_particles): + * v_dict['v' + str(i)] = v[:, i] # <<<<<<<<<<<<<< + * z_dict['z' + str(i)] = z[:, i] + * #t_dict['t_' + str(i)] = t[i] # for now no t by choice +*/ + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 1971, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_i); + __Pyx_GIVEREF(__pyx_v_i); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_v_i) != (0)) __PYX_ERR(0, 1971, __pyx_L1_error); + __pyx_t_12 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_v), __pyx_t_4); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_Unicode(__pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_v, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1971, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_v_dict, __pyx_t_5, __pyx_t_12) < 0))) __PYX_ERR(0, 1971, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + + /* "cssm.pyx":1972 + * for i in range(n_particles): + * v_dict['v' + str(i)] = v[:, i] + * z_dict['z' + str(i)] = z[:, i] # <<<<<<<<<<<<<< + * #t_dict['t_' + str(i)] = t[i] # for now no t by choice + * +*/ + __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 1972, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_i); + __Pyx_GIVEREF(__pyx_v_i); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_v_i) != (0)) __PYX_ERR(0, 1972, __pyx_L1_error); + __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_z), __pyx_t_12); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyObject_Unicode(__pyx_v_i); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 1972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_z, __pyx_t_12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1972, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_z_dict, __pyx_t_4, __pyx_t_5) < 0))) __PYX_ERR(0, 1972, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":1970 + * z_dict = {} + * #t_dict = {} + * for i in range(n_particles): # <<<<<<<<<<<<<< + * v_dict['v' + str(i)] = v[:, i] + * z_dict['z' + str(i)] = z[:, i] +*/ + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + } + + /* "cssm.pyx":1975 + * #t_dict['t_' + str(i)] = t[i] # for now no t by choice + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1975, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":1976 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, # <<<<<<<<<<<<<< + * 'a': a, + * **z_dict, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_8 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1976, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1976, __pyx_L1_error) + if (unlikely(!__pyx_v_v_dict)) { __Pyx_RaiseUnboundLocalError("v_dict"); __PYX_ERR(0, 1976, __pyx_L1_error) } + __pyx_t_5 = PyDict_Copy(__pyx_v_v_dict); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1976, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "cssm.pyx":1977 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, # <<<<<<<<<<<<<< + * **z_dict, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 1977, __pyx_L1_error) + + /* "cssm.pyx":1978 + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, + * **z_dict, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (unlikely(!__pyx_v_z_dict)) { __Pyx_RaiseUnboundLocalError("z_dict"); __PYX_ERR(0, 1978, __pyx_L1_error) } + if (unlikely(PyDict_Update(__pyx_t_5, __pyx_v_z_dict) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_z_dict); + __PYX_ERR(0, 1978, __pyx_L1_error) + } + + /* "cssm.pyx":1979 + * 'a': a, + * **z_dict, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * # **t_dict, # for now no t by choice +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 1979, __pyx_L1_error) + + /* "cssm.pyx":1980 + * **z_dict, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * # **t_dict, # for now no t by choice + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 1980, __pyx_L1_error) + + /* "cssm.pyx":1982 + * 'deadline': deadline, + * # **t_dict, # for now no t by choice + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 1982, __pyx_L1_error) + + /* "cssm.pyx":1983 + * # **t_dict, # for now no t by choice + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 1983, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_5, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 1983, __pyx_L1_error) + } + + /* "cssm.pyx":1984 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1984, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_4) < (0)) __PYX_ERR(0, 1984, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":1985 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_4) < (0)) __PYX_ERR(0, 1985, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":1986 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'race_model', +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1986, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 1986, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":1987 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'race_model', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1987, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_4) < (0)) __PYX_ERR(0, 1987, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_race_model) < (0)) __PYX_ERR(0, 1988, __pyx_L1_error) + + /* "cssm.pyx":1989 + * 'n_trials': n_trials, + * 'simulator': 'race_model', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': list(np.arange(0, n_particles, 1)), + * 'trajectory': traj, +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1989, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_4) < (0)) __PYX_ERR(0, 1989, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":1990 + * 'simulator': 'race_model', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': list(np.arange(0, n_particles, 1)), # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_12 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_particles); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 1990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_23))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_23); + assert(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_23, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_12, __pyx_mstate_global->__pyx_int_0, __pyx_t_6, __pyx_mstate_global->__pyx_int_1}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_23, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_23 = __Pyx_PySequence_ListKeepNew(__pyx_t_4); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1990, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_23) < (0)) __PYX_ERR(0, 1990, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + + /* "cssm.pyx":1991 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': list(np.arange(0, n_particles, 1)), + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 1991, __pyx_L1_error) + + /* "cssm.pyx":1992 + * 'possible_choices': list(np.arange(0, n_particles, 1)), + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'race_model', +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 1992, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_5) < (0)) __PYX_ERR(0, 1976, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_8; + __pyx_t_8 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1975 + * #t_dict['t_' + str(i)] = t[i] # for now no t by choice + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, +*/ + } + + /* "cssm.pyx":1993 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'race_model', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 1993, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":1994 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'race_model', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_8 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 1994, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 1994, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_race_model) < (0)) __PYX_ERR(0, 1994, __pyx_L1_error) + + /* "cssm.pyx":1995 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'race_model', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_23 = PyList_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1995, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_23, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 1995, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_23, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 1995, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_23) < (0)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + + /* "cssm.pyx":1996 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'race_model', + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1996, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_23) < (0)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + + /* "cssm.pyx":1997 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_23 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_23) < (0)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + + /* "cssm.pyx":1998 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * +*/ + __pyx_t_23 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 1998, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_23) < (0)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_5) < (0)) __PYX_ERR(0, 1994, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_8; + __pyx_t_8 = 0; + goto __pyx_L0; + + /* "cssm.pyx":1993 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'race_model', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":2002 + * + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # ------------------------------------------------------------------------------------------------- + * # @cythonboundscheck(False) +*/ + /*else*/ { + __pyx_t_5 = NULL; + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2002, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __Pyx_Raise(__pyx_t_8, 0, 0, 0); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __PYX_ERR(0, 2002, __pyx_L1_error) + } + + /* "cssm.pyx":1819 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def race_model(np.ndarray[float, ndim = 2] v, # np.array expected, one column of floats # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # initial boundary separation + * np.ndarray[float, ndim = 2] z, # np.array expected, one column of floats +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_3, 1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_23); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.race_model", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __Pyx_XDECREF(__pyx_v_sqrt_st); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sqrt_st_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_particles); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_particles_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_v_v_dict); + __Pyx_XDECREF(__pyx_v_z_dict); + __Pyx_XDECREF(__pyx_v_i); + __Pyx_XDECREF(__pyx_8genexpr8__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":2008 + * + * # Simulate (rt, choice) tuples from: Leaky Competing Accumulator Model ----------------------------- + * def lca(np.ndarray[float, ndim = 2] v, # drift parameters (np.array expect: one column of floats) # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # criterion height + * np.ndarray[float, ndim = 2] z, # initial bias parameters (np.array expect: one column of floats) +*/ + +static PyObject *__pyx_pf_4cssm_64__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":2016 + * np.ndarray[float, ndim = 2] s, # variance (can be one value or np.array of size as v and w) + * np.ndarray[float, ndim = 1] deadline, + * float delta_t = 0.001, # time-step size in simulator # <<<<<<<<<<<<<< + * float max_t = 20, # maximal time + * int n_samples = 2000, # number of samples to produce +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2016, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":2017 + * np.ndarray[float, ndim = 1] deadline, + * float delta_t = 0.001, # time-step size in simulator + * float max_t = 20, # maximal time # <<<<<<<<<<<<<< + * int n_samples = 2000, # number of samples to produce + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2017, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":2018 + * float delta_t = 0.001, # time-step size in simulator + * float max_t = 20, # maximal time + * int n_samples = 2000, # number of samples to produce # <<<<<<<<<<<<<< + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x7D0)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":2019 + * float max_t = 20, # maximal time + * int n_samples = 2000, # number of samples to produce + * int n_trials = 1, # <<<<<<<<<<<<<< + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2019, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":2008 + * + * # Simulate (rt, choice) tuples from: Leaky Competing Accumulator Model ----------------------------- + * def lca(np.ndarray[float, ndim = 2] v, # drift parameters (np.array expect: one column of floats) # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # criterion height + * np.ndarray[float, ndim = 2] z, # initial bias parameters (np.array expect: one column of floats) +*/ + __pyx_t_5 = PyTuple_New(10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, Py_None) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, Py_None) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 2008, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_21lca(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_20lca, "\n Simulate reaction times and choices from a Leaky Competing Accumulator (LCA) model.\n\n Parameters:\n -----------\n v : np.ndarray, shape (n_trials, n_particles)\n Drift rate parameters for each particle.\n a : np.ndarray, shape (n_trials, 1)\n Criterion height (decision threshold).\n z : np.ndarray, shape (n_trials, n_particles)\n Initial bias parameters for each particle.\n g : np.ndarray, shape (n_trials, 1)\n Decay parameter.\n b : np.ndarray, shape (n_trials, 1)\n Inhibition parameter.\n t : np.ndarray, shape (n_trials, 1)\n Non-decision time.\n s : np.ndarray, shape (n_trials, n_particles)\n Standard deviation of the diffusion process.\n deadline : np.ndarray, shape (n_trials,)\n Deadline for each trial.\n delta_t : float, optional\n Time step size for the simulation (default: 0.001).\n max_t : float, optional\n Maximum time for the simulation (default: 20).\n n_samples : int, optional\n Number of samples to simulate (default: 2000).\n n_trials : int, optional\n Number of trials to simulate (default: 1).\n boundary_fun : callable, optional\n Boundary function that takes time as input (default: None).\n boundary_multiplicative : bool, optional\n If True, the boundary function is multiplicative; if False, it's additive (default: True).\n boundary_params : dict, optional\n Parameters for the boundary function (default: {}).\n random_state : int or None, optional\n Seed for random number generation (default: None).\n return_option : str, optional\n Determines the amount of data returned. Can be 'full' or 'minimal' (default: 'full').\n smooth_unif : bool, optional\n If True, applies uniform smoothing to reaction times (default: False).\n\n Returns:\n --------\n dict\n A dictionary containing simulated reaction times, choices, and metadata.\n The exact co""ntents depend on the 'return_option' parameter.\n "); +static PyMethodDef __pyx_mdef_4cssm_21lca = {"lca", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_21lca, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_20lca}; +static PyObject *__pyx_pw_4cssm_21lca(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_g = 0; + PyArrayObject *__pyx_v_b = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_s = 0; + PyArrayObject *__pyx_v_deadline = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[18] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lca (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_g,&__pyx_mstate_global->__pyx_n_u_b,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2008, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "lca", 1) < (0)) __PYX_ERR(0, 2008, __pyx_L3_error) + + /* "cssm.pyx":2020 + * int n_samples = 2000, # number of samples to produce + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[14]) values[14] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":2023 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 8; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lca", 0, 8, 18, i); __PYX_ERR(0, 2008, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2008, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2008, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2008, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2008, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2008, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2008, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2008, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2008, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2008, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":2020 + * int n_samples = 2000, # number of samples to produce + * int n_trials = 1, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[13]) values[13] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[14]) values[14] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":2023 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_g = ((PyArrayObject *)values[3]); + __pyx_v_b = ((PyArrayObject *)values[4]); + __pyx_v_t = ((PyArrayObject *)values[5]); + __pyx_v_s = ((PyArrayObject *)values[6]); + __pyx_v_deadline = ((PyArrayObject *)values[7]); + if (values[8]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[8]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2016, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[9]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[9]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2017, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[10]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[10]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2018, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x7D0)); + } + if (values[11]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[11]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2019, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_boundary_fun = values[12]; + __pyx_v_boundary_multiplicative = values[13]; + __pyx_v_boundary_params = values[14]; + __pyx_v_random_state = values[15]; + __pyx_v_return_option = values[16]; + __pyx_v_smooth_unif = values[17]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lca", 0, 8, 18, __pyx_nargs); __PYX_ERR(0, 2008, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.lca", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 2008, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 2009, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 2010, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_g), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "g", 0))) __PYX_ERR(0, 2011, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_b), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "b", 0))) __PYX_ERR(0, 2012, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 2013, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 2014, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 2015, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_20lca(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_g, __pyx_v_b, __pyx_v_t, __pyx_v_s, __pyx_v_deadline, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":2008 + * + * # Simulate (rt, choice) tuples from: Leaky Competing Accumulator Model ----------------------------- + * def lca(np.ndarray[float, ndim = 2] v, # drift parameters (np.array expect: one column of floats) # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # criterion height + * np.ndarray[float, ndim = 2] z, # initial bias parameters (np.array expect: one column of floats) +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_20lca(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_b, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_s, PyArrayObject *__pyx_v_deadline, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_g_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_b_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + CYTHON_UNUSED __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_n_particles; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_particles = NULL; + __Pyx_memviewslice __pyx_v_particles_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_particles_reduced_sum = NULL; + __Pyx_memviewslice __pyx_v_particles_reduced_sum_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + PyObject *__pyx_v_sqrt_st = NULL; + __Pyx_memviewslice __pyx_v_sqrt_st_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_i; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + float __pyx_v_particles_sum; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + int __pyx_v_num_steps; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_num_draws; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + double __pyx_v_t_particle; + PyObject *__pyx_v_v_dict = NULL; + PyObject *__pyx_v_z_dict = NULL; + PyObject *__pyx_8genexpr9__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_b; + __Pyx_Buffer __pyx_pybuffer_b; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_g; + __Pyx_Buffer __pyx_pybuffer_g; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_3 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + PyObject *__pyx_t_23 = NULL; + Py_ssize_t __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + float __pyx_t_27; + int __pyx_t_28; + int __pyx_t_29; + Py_ssize_t __pyx_t_30; + int __pyx_t_31; + int __pyx_t_32; + Py_ssize_t __pyx_t_33; + Py_ssize_t __pyx_t_34; + Py_ssize_t __pyx_t_35; + Py_ssize_t __pyx_t_36; + Py_ssize_t __pyx_t_37; + Py_ssize_t __pyx_t_38; + Py_ssize_t __pyx_t_39; + Py_ssize_t __pyx_t_40; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lca", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_g.pybuffer.buf = NULL; + __pyx_pybuffer_g.refcount = 0; + __pyx_pybuffernd_g.data = NULL; + __pyx_pybuffernd_g.rcbuffer = &__pyx_pybuffer_g; + __pyx_pybuffer_b.pybuffer.buf = NULL; + __pyx_pybuffer_b.refcount = 0; + __pyx_pybuffernd_b.data = NULL; + __pyx_pybuffernd_b.rcbuffer = &__pyx_pybuffer_b; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2008, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_v.diminfo[1].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_v.diminfo[1].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2008, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_a.diminfo[1].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_a.diminfo[1].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2008, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_z.diminfo[1].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_z.diminfo[1].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_g.rcbuffer->pybuffer, (PyObject*)__pyx_v_g, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2008, __pyx_L1_error) + } + __pyx_pybuffernd_g.diminfo[0].strides = __pyx_pybuffernd_g.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_g.diminfo[0].shape = __pyx_pybuffernd_g.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_g.diminfo[1].strides = __pyx_pybuffernd_g.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_g.diminfo[1].shape = __pyx_pybuffernd_g.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_b.rcbuffer->pybuffer, (PyObject*)__pyx_v_b, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2008, __pyx_L1_error) + } + __pyx_pybuffernd_b.diminfo[0].strides = __pyx_pybuffernd_b.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_b.diminfo[0].shape = __pyx_pybuffernd_b.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_b.diminfo[1].strides = __pyx_pybuffernd_b.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_b.diminfo[1].shape = __pyx_pybuffernd_b.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2008, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_t.diminfo[1].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_t.diminfo[1].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2008, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_s.diminfo[1].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_s.diminfo[1].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2008, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":2076 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:, :] v_view = v +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2076, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":2078 + * set_seed(random_state) + * # Param views + * cdef float[:, :] v_view = v # <<<<<<<<<<<<<< + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2078, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2079 + * # Param views + * cdef float[:, :] v_view = v + * cdef float[:, :] a_view = a # <<<<<<<<<<<<<< + * cdef float[:, :] z_view = z + * cdef float[:, :] g_view = g +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2079, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2080 + * cdef float[:, :] v_view = v + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z # <<<<<<<<<<<<<< + * cdef float[:, :] g_view = g + * cdef float[:, :] b_view = b +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2080, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2081 + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z + * cdef float[:, :] g_view = g # <<<<<<<<<<<<<< + * cdef float[:, :] b_view = b + * cdef float[:, :] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_g), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2081, __pyx_L1_error) + __pyx_v_g_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2082 + * cdef float[:, :] z_view = z + * cdef float[:, :] g_view = g + * cdef float[:, :] b_view = b # <<<<<<<<<<<<<< + * cdef float[:, :] t_view = t + * cdef float[:, :] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_b), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2082, __pyx_L1_error) + __pyx_v_b_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2083 + * cdef float[:, :] g_view = g + * cdef float[:, :] b_view = b + * cdef float[:, :] t_view = t # <<<<<<<<<<<<<< + * cdef float[:, :] s_view = s + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2083, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2084 + * cdef float[:, :] b_view = b + * cdef float[:, :] t_view = t + * cdef float[:, :] s_view = s # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2084, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2085 + * cdef float[:, :] t_view = t + * cdef float[:, :] s_view = s + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * + * # Trajectory +*/ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 2085, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":2088 + * + * # Trajectory + * cdef int n_particles = v.shape[1] # <<<<<<<<<<<<<< + * traj = np.zeros((int(max_t / delta_t) + 1, n_particles), dtype = DTYPE) + * traj[:, :] = -999 +*/ + __pyx_v_n_particles = (__pyx_f_5numpy_7ndarray_5shape_shape(((PyArrayObject *)__pyx_v_v))[1]); + + /* "cssm.pyx":2089 + * # Trajectory + * cdef int n_particles = v.shape[1] + * traj = np.zeros((int(max_t / delta_t) + 1, n_particles), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_particles); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 2089, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 2089, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_8}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2089, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2089, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2090 + * cdef int n_particles = v.shape[1] + * traj = np.zeros((int(max_t / delta_t) + 1, n_particles), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 2090, __pyx_L1_error) + + /* "cssm.pyx":2091 + * traj = np.zeros((int(max_t / delta_t) + 1, n_particles), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2091, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2093 + * cdef float[:, :] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_view = rts + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 2093, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 2093, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2093, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_4}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2093, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2093, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2094 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 2094, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":2096 + * cdef float[:, :, :] rts_view = rts + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 2096, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2096, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2096, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2096, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2096, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2097 + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * particles = np.zeros(n_particles, dtype = DTYPE) +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 2097, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":2099 + * cdef int[:, :, :] choices_view = choices + * + * particles = np.zeros(n_particles, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] particles_view = particles + * +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_particles); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_8, __pyx_t_4}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2099, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2099, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_particles = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2100 + * + * particles = np.zeros(n_particles, dtype = DTYPE) + * cdef float[:] particles_view = particles # <<<<<<<<<<<<<< + * + * particles_reduced_sum = np.zeros(n_particles, dtype = DTYPE) +*/ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_particles, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 2100, __pyx_L1_error) + __pyx_v_particles_view = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":2102 + * cdef float[:] particles_view = particles + * + * particles_reduced_sum = np.zeros(n_particles, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] particles_reduced_sum_view = particles_reduced_sum + * +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_particles); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2102, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2102, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_particles_reduced_sum = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2103 + * + * particles_reduced_sum = np.zeros(n_particles, dtype = DTYPE) + * cdef float[:] particles_reduced_sum_view = particles_reduced_sum # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) +*/ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_particles_reduced_sum, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 2103, __pyx_L1_error) + __pyx_v_particles_reduced_sum_view = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":2105 + * cdef float[:] particles_reduced_sum_view = particles_reduced_sum + * + * cdef float delta_t_sqrt = sqrt(delta_t) # <<<<<<<<<<<<<< + * sqrt_st = s * delta_t_sqrt + * cdef float[:, :] sqrt_st_view = sqrt_st +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":2106 + * + * cdef float delta_t_sqrt = sqrt(delta_t) + * sqrt_st = s * delta_t_sqrt # <<<<<<<<<<<<<< + * cdef float[:, :] sqrt_st_view = sqrt_st + * +*/ + __pyx_t_1 = PyFloat_FromDouble(__pyx_v_delta_t_sqrt); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_6 = PyNumber_Multiply(((PyObject *)__pyx_v_s), __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2106, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_v_sqrt_st = __pyx_t_6; + __pyx_t_6 = 0; + + /* "cssm.pyx":2107 + * cdef float delta_t_sqrt = sqrt(delta_t) + * sqrt_st = s * delta_t_sqrt + * cdef float[:, :] sqrt_st_view = sqrt_st # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t n, i, ix, k +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_sqrt_st, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2107, __pyx_L1_error) + __pyx_v_sqrt_st_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2110 + * + * cdef Py_ssize_t n, i, ix, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float t_par, particles_sum, smooth_u, deadline_tmp + * +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2114 + * + * # Boundary storage + * cdef int num_steps = int((max_t / delta_t) + 2) # <<<<<<<<<<<<<< + * + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) +*/ + __pyx_v_num_steps = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 2.0)); + + /* "cssm.pyx":2116 + * cdef int num_steps = int((max_t / delta_t) + 2) + * + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_mstate_global->__pyx_int_0, __pyx_t_5, __pyx_t_12}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_1 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_7}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_v_t_s = __pyx_t_6; + __pyx_t_6 = 0; + + /* "cssm.pyx":2117 + * + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_1))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_1); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_1); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_1, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_8, __pyx_t_7}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2117, __pyx_L1_error) + __pyx_t_6 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_1, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2117, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_v_boundary = __pyx_t_6; + __pyx_t_6 = 0; + + /* "cssm.pyx":2118 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * cdef int num_draws = num_steps * n_particles +*/ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 2118, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":2120 + * cdef float[:] boundary_view = boundary + * + * cdef int num_draws = num_steps * n_particles # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_num_draws = (__pyx_v_num_steps * __pyx_v_n_particles); + + /* "cssm.pyx":2121 + * + * cdef int num_draws = num_steps * n_particles + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_3 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 2121, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":2123 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":2125 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_6 = PyDict_New(); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2125, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 2125, __pyx_L7_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2125, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_1); + __pyx_t_1 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_1, __pyx_t_17, &__pyx_t_16, &__pyx_t_5, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 2125, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_8genexpr9__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_8genexpr9__pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2125, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2125, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_6, (PyObject*)__pyx_8genexpr9__pyx_v_key, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 2125, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_8genexpr9__pyx_v_key); __pyx_8genexpr9__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_8genexpr9__pyx_v_key); __pyx_8genexpr9__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_6)); + __pyx_t_6 = 0; + + /* "cssm.pyx":2128 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2128, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2129 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = 0; + __pyx_t_7 = PyFloat_FromDouble((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) ) + __pyx_t_22 * __pyx_v_a_view.strides[1]) )))); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_23 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 2129, __pyx_L1_error) + __pyx_t_4 = __pyx_t_23; + __pyx_t_23 = 0; + if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 2129, __pyx_L1_error) + __pyx_t_23 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_7, __pyx_t_23}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_1 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_1); + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_t_8}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_6, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 2129, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2128 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":2131 + * boundary[:] = np.multiply(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k, 0]) +*/ + /*else*/ { + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __pyx_t_22 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_23 = PyFloat_FromDouble((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_22 * __pyx_v_a_view.strides[0]) ) + __pyx_t_21 * __pyx_v_a_view.strides[1]) )))); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 2131, __pyx_L1_error) + __pyx_t_5 = __pyx_t_4; + __pyx_t_4 = 0; + if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 2131, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_t_23, __pyx_t_4}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_12 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_7}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_6, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 2131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":2133 + * boundary[:] = np.add(a_view[k, 0], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k, 0]) # <<<<<<<<<<<<<< + * for n in range(n_samples): + * # Reset particle starting points +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = __pyx_v_k; + __pyx_t_24 = 0; + __pyx_t_25 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_22 * __pyx_v_t_view.strides[0]) ) + __pyx_t_24 * __pyx_v_t_view.strides[1]) )))); + __pyx_t_26 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_25 < __pyx_t_26); + if (__pyx_t_20) { + __pyx_t_27 = __pyx_t_25; + } else { + __pyx_t_27 = __pyx_t_26; + } + __pyx_v_deadline_tmp = __pyx_t_27; + + /* "cssm.pyx":2134 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k, 0]) + * for n in range(n_samples): # <<<<<<<<<<<<<< + * # Reset particle starting points + * for i in range(n_particles): +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":2136 + * for n in range(n_samples): + * # Reset particle starting points + * for i in range(n_particles): # <<<<<<<<<<<<<< + * particles_view[i] = z_view[k, i] * boundary_view[0] + * +*/ + __pyx_t_28 = __pyx_v_n_particles; + __pyx_t_29 = __pyx_t_28; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_29; __pyx_t_16+=1) { + __pyx_v_i = __pyx_t_16; + + /* "cssm.pyx":2137 + * # Reset particle starting points + * for i in range(n_particles): + * particles_view[i] = z_view[k, i] * boundary_view[0] # <<<<<<<<<<<<<< + * + * t_particle = 0.0 # reset time +*/ + __pyx_t_24 = __pyx_v_k; + __pyx_t_22 = __pyx_v_i; + __pyx_t_21 = 0; + __pyx_t_30 = __pyx_v_i; + *((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_30 * __pyx_v_particles_view.strides[0]) )) = ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_z_view.data + __pyx_t_24 * __pyx_v_z_view.strides[0]) ) + __pyx_t_22 * __pyx_v_z_view.strides[1]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + } + + /* "cssm.pyx":2139 + * particles_view[i] = z_view[k, i] * boundary_view[0] + * + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":2140 + * + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":2142 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * for i in range(n_particles): +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2143 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * for i in range(n_particles): + * traj_view[0, i] = particles[i] +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2144 + * if n == 0: + * if k == 0: + * for i in range(n_particles): # <<<<<<<<<<<<<< + * traj_view[0, i] = particles[i] + * +*/ + __pyx_t_28 = __pyx_v_n_particles; + __pyx_t_29 = __pyx_t_28; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_29; __pyx_t_16+=1) { + __pyx_v_i = __pyx_t_16; + + /* "cssm.pyx":2145 + * if k == 0: + * for i in range(n_particles): + * traj_view[0, i] = particles[i] # <<<<<<<<<<<<<< + * + * while not check_finished(particles_view, boundary_view[ix], n_particles) and t_particle <= deadline_tmp: +*/ + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_particles, __pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_27 = __Pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_27 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2145, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_21 = 0; + __pyx_t_22 = __pyx_v_i; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_22 * __pyx_v_traj_view.strides[1]) )) = __pyx_t_27; + } + + /* "cssm.pyx":2143 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * for i in range(n_particles): + * traj_view[0, i] = particles[i] +*/ + } + + /* "cssm.pyx":2142 + * ix = 0 # reset boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * for i in range(n_particles): +*/ + } + + /* "cssm.pyx":2147 + * traj_view[0, i] = particles[i] + * + * while not check_finished(particles_view, boundary_view[ix], n_particles) and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * # calculate current sum over particle positions + * particles_sum = csum(particles_view) +*/ + while (1) { + __pyx_t_22 = __pyx_v_ix; + __pyx_t_31 = __pyx_f_4cssm_check_finished(__pyx_v_particles_view, (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) ))), __pyx_v_n_particles); if (unlikely(__pyx_t_31 == ((int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2147, __pyx_L1_error) + __pyx_t_32 = (!__pyx_t_31); + if (__pyx_t_32) { + } else { + __pyx_t_20 = __pyx_t_32; + goto __pyx_L22_bool_binop_done; + } + __pyx_t_32 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_32; + __pyx_L22_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":2149 + * while not check_finished(particles_view, boundary_view[ix], n_particles) and t_particle <= deadline_tmp: + * # calculate current sum over particle positions + * particles_sum = csum(particles_view) # <<<<<<<<<<<<<< + * + * # update particle positions +*/ + __pyx_t_27 = __pyx_f_4cssm_csum(__pyx_v_particles_view); if (unlikely(__pyx_t_27 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2149, __pyx_L1_error) + __pyx_v_particles_sum = __pyx_t_27; + + /* "cssm.pyx":2152 + * + * # update particle positions + * for i in range(n_particles): # <<<<<<<<<<<<<< + * particles_reduced_sum_view[i] = (- 1) * particles_view[i] + particles_sum + * particles_view[i] += ((v_view[k, i] - (g_view[k, 0] * particles_view[i]) - \ +*/ + __pyx_t_28 = __pyx_v_n_particles; + __pyx_t_29 = __pyx_t_28; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_29; __pyx_t_16+=1) { + __pyx_v_i = __pyx_t_16; + + /* "cssm.pyx":2153 + * # update particle positions + * for i in range(n_particles): + * particles_reduced_sum_view[i] = (- 1) * particles_view[i] + particles_sum # <<<<<<<<<<<<<< + * particles_view[i] += ((v_view[k, i] - (g_view[k, 0] * particles_view[i]) - \ + * (b_view[k, 0] * particles_reduced_sum_view[i])) * delta_t) + (sqrt_st_view[k, i] * gaussian_values[m]) +*/ + __pyx_t_22 = __pyx_v_i; + __pyx_t_21 = __pyx_v_i; + *((float *) ( /* dim=0 */ (__pyx_v_particles_reduced_sum_view.data + __pyx_t_21 * __pyx_v_particles_reduced_sum_view.strides[0]) )) = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_22 * __pyx_v_particles_view.strides[0]) )))) + __pyx_v_particles_sum); + + /* "cssm.pyx":2154 + * for i in range(n_particles): + * particles_reduced_sum_view[i] = (- 1) * particles_view[i] + particles_sum + * particles_view[i] += ((v_view[k, i] - (g_view[k, 0] * particles_view[i]) - \ # <<<<<<<<<<<<<< + * (b_view[k, 0] * particles_reduced_sum_view[i])) * delta_t) + (sqrt_st_view[k, i] * gaussian_values[m]) + * particles_view[i] = fmax(0.0, particles_view[i]) +*/ + __pyx_t_22 = __pyx_v_k; + __pyx_t_21 = __pyx_v_i; + __pyx_t_24 = __pyx_v_k; + __pyx_t_30 = 0; + __pyx_t_33 = __pyx_v_i; + + /* "cssm.pyx":2155 + * particles_reduced_sum_view[i] = (- 1) * particles_view[i] + particles_sum + * particles_view[i] += ((v_view[k, i] - (g_view[k, 0] * particles_view[i]) - \ + * (b_view[k, 0] * particles_reduced_sum_view[i])) * delta_t) + (sqrt_st_view[k, i] * gaussian_values[m]) # <<<<<<<<<<<<<< + * particles_view[i] = fmax(0.0, particles_view[i]) + * m += 1 +*/ + __pyx_t_34 = __pyx_v_k; + __pyx_t_35 = 0; + __pyx_t_36 = __pyx_v_i; + + /* "cssm.pyx":2154 + * for i in range(n_particles): + * particles_reduced_sum_view[i] = (- 1) * particles_view[i] + particles_sum + * particles_view[i] += ((v_view[k, i] - (g_view[k, 0] * particles_view[i]) - \ # <<<<<<<<<<<<<< + * (b_view[k, 0] * particles_reduced_sum_view[i])) * delta_t) + (sqrt_st_view[k, i] * gaussian_values[m]) + * particles_view[i] = fmax(0.0, particles_view[i]) +*/ + __pyx_t_37 = __pyx_v_k; + __pyx_t_38 = __pyx_v_i; + + /* "cssm.pyx":2155 + * particles_reduced_sum_view[i] = (- 1) * particles_view[i] + particles_sum + * particles_view[i] += ((v_view[k, i] - (g_view[k, 0] * particles_view[i]) - \ + * (b_view[k, 0] * particles_reduced_sum_view[i])) * delta_t) + (sqrt_st_view[k, i] * gaussian_values[m]) # <<<<<<<<<<<<<< + * particles_view[i] = fmax(0.0, particles_view[i]) + * m += 1 +*/ + __pyx_t_39 = __pyx_v_m; + + /* "cssm.pyx":2154 + * for i in range(n_particles): + * particles_reduced_sum_view[i] = (- 1) * particles_view[i] + particles_sum + * particles_view[i] += ((v_view[k, i] - (g_view[k, 0] * particles_view[i]) - \ # <<<<<<<<<<<<<< + * (b_view[k, 0] * particles_reduced_sum_view[i])) * delta_t) + (sqrt_st_view[k, i] * gaussian_values[m]) + * particles_view[i] = fmax(0.0, particles_view[i]) +*/ + __pyx_t_40 = __pyx_v_i; + *((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_40 * __pyx_v_particles_view.strides[0]) )) += (((((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_22 * __pyx_v_v_view.strides[0]) ) + __pyx_t_21 * __pyx_v_v_view.strides[1]) ))) - ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_g_view.data + __pyx_t_24 * __pyx_v_g_view.strides[0]) ) + __pyx_t_30 * __pyx_v_g_view.strides[1]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_33 * __pyx_v_particles_view.strides[0]) ))))) - ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_b_view.data + __pyx_t_34 * __pyx_v_b_view.strides[0]) ) + __pyx_t_35 * __pyx_v_b_view.strides[1]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_particles_reduced_sum_view.data + __pyx_t_36 * __pyx_v_particles_reduced_sum_view.strides[0]) ))))) * __pyx_v_delta_t) + ((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_sqrt_st_view.data + __pyx_t_37 * __pyx_v_sqrt_st_view.strides[0]) ) + __pyx_t_38 * __pyx_v_sqrt_st_view.strides[1]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_39 * __pyx_v_gaussian_values.strides[0]) ))))); + + /* "cssm.pyx":2156 + * particles_view[i] += ((v_view[k, i] - (g_view[k, 0] * particles_view[i]) - \ + * (b_view[k, 0] * particles_reduced_sum_view[i])) * delta_t) + (sqrt_st_view[k, i] * gaussian_values[m]) + * particles_view[i] = fmax(0.0, particles_view[i]) # <<<<<<<<<<<<<< + * m += 1 + * +*/ + __pyx_t_39 = __pyx_v_i; + __pyx_t_38 = __pyx_v_i; + *((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_38 * __pyx_v_particles_view.strides[0]) )) = fmax(0.0, (*((float *) ( /* dim=0 */ (__pyx_v_particles_view.data + __pyx_t_39 * __pyx_v_particles_view.strides[0]) )))); + + /* "cssm.pyx":2157 + * (b_view[k, 0] * particles_reduced_sum_view[i])) * delta_t) + (sqrt_st_view[k, i] * gaussian_values[m]) + * particles_view[i] = fmax(0.0, particles_view[i]) + * m += 1 # <<<<<<<<<<<<<< + * + * if m == num_draws: +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":2159 + * m += 1 + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":2160 + * + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_3 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 2160, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":2161 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * t_particle += delta_t # increment time +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2159 + * m += 1 + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":2163 + * m = 0 + * + * t_particle += delta_t # increment time # <<<<<<<<<<<<<< + * ix += 1 # increment boundary index + * +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":2164 + * + * t_particle += delta_t # increment time + * ix += 1 # increment boundary index # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":2166 + * ix += 1 # increment boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * for i in range(n_particles): +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2167 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * for i in range(n_particles): + * traj_view[ix, i] = particles[i] +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2168 + * if n == 0: + * if k == 0: + * for i in range(n_particles): # <<<<<<<<<<<<<< + * traj_view[ix, i] = particles[i] + * +*/ + __pyx_t_28 = __pyx_v_n_particles; + __pyx_t_29 = __pyx_t_28; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_29; __pyx_t_16+=1) { + __pyx_v_i = __pyx_t_16; + + /* "cssm.pyx":2169 + * if k == 0: + * for i in range(n_particles): + * traj_view[ix, i] = particles[i] # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_t_6 = __Pyx_GetItemInt(__pyx_v_particles, __pyx_v_i, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2169, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_27 = __Pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_27 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2169, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_39 = __pyx_v_ix; + __pyx_t_38 = __pyx_v_i; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_39 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_38 * __pyx_v_traj_view.strides[1]) )) = __pyx_t_27; + } + + /* "cssm.pyx":2167 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * for i in range(n_particles): + * traj_view[ix, i] = particles[i] +*/ + } + + /* "cssm.pyx":2166 + * ix += 1 # increment boundary index + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * for i in range(n_particles): +*/ + } + } + + /* "cssm.pyx":2171 + * traj_view[ix, i] = particles[i] + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2171, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2172 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":2173 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_27 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_27 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2173, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_27 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":2172 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L32; + } + + /* "cssm.pyx":2174 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":2175 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_27 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_27 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2175, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_27) * __pyx_v_delta_t); + + /* "cssm.pyx":2174 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L32; + } + + /* "cssm.pyx":2177 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L32:; + + /* "cssm.pyx":2171 + * traj_view[ix, i] = particles[i] + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L31; + } + + /* "cssm.pyx":2179 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * choices_view[n, k, 0] = np.argmax(particles) # store choices for sample n +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L31:; + + /* "cssm.pyx":2181 + * smooth_u = 0.0 + * + * choices_view[n, k, 0] = np.argmax(particles) # store choices for sample n # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = t_particle + t_view[k, 0] + smooth_u # t[choices_view[n, 0]] # store reaction time for sample n + * +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_argmax); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_v_particles}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2181, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_28 = __Pyx_PyLong_As_int(__pyx_t_6); if (unlikely((__pyx_t_28 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2181, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_38 = __pyx_v_n; + __pyx_t_39 = __pyx_v_k; + __pyx_t_37 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_38 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_39 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_37 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_28; + + /* "cssm.pyx":2182 + * + * choices_view[n, k, 0] = np.argmax(particles) # store choices for sample n + * rts_view[n, k, 0] = t_particle + t_view[k, 0] + smooth_u # t[choices_view[n, 0]] # store reaction time for sample n # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_37 = __pyx_v_k; + __pyx_t_39 = 0; + __pyx_t_38 = __pyx_v_n; + __pyx_t_36 = __pyx_v_k; + __pyx_t_35 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_38 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_36 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_35 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_37 * __pyx_v_t_view.strides[0]) ) + __pyx_t_39 * __pyx_v_t_view.strides[1]) )))) + __pyx_v_smooth_u); + + /* "cssm.pyx":2184 + * rts_view[n, k, 0] = t_particle + t_view[k, 0] + smooth_u # t[choices_view[n, 0]] # store reaction time for sample n + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_39 = __pyx_v_n; + __pyx_t_37 = __pyx_v_k; + __pyx_t_35 = 0; + __pyx_t_36 = __pyx_v_k; + __pyx_t_38 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_39 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_37 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_35 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_36 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_38 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":2185 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * # Create some dics +*/ + __pyx_t_38 = __pyx_v_n; + __pyx_t_36 = __pyx_v_k; + __pyx_t_35 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_38 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_36 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_35 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":2184 + * rts_view[n, k, 0] = t_particle + t_view[k, 0] + smooth_u # t[choices_view[n, 0]] # store reaction time for sample n + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":2188 + * + * # Create some dics + * v_dict = {} # <<<<<<<<<<<<<< + * z_dict = {} + * #t_dict = {} +*/ + __pyx_t_6 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_v_v_dict = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; + + /* "cssm.pyx":2189 + * # Create some dics + * v_dict = {} + * z_dict = {} # <<<<<<<<<<<<<< + * #t_dict = {} + * +*/ + __pyx_t_6 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2189, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_v_z_dict = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; + + /* "cssm.pyx":2192 + * #t_dict = {} + * + * for i in range(n_particles): # <<<<<<<<<<<<<< + * v_dict['v' + str(i)] = v[:, i] + * z_dict['z' + str(i)] = z[:, i] +*/ + __pyx_t_13 = __pyx_v_n_particles; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_i = __pyx_t_15; + + /* "cssm.pyx":2193 + * + * for i in range(n_particles): + * v_dict['v' + str(i)] = v[:, i] # <<<<<<<<<<<<<< + * z_dict['z' + str(i)] = z[:, i] + * +*/ + __pyx_t_6 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 2193, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 2193, __pyx_L1_error); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_v), __pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = __Pyx_PyObject_Unicode(__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_v, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2193, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_v_dict, __pyx_t_12, __pyx_t_6) < 0))) __PYX_ERR(0, 2193, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2194 + * for i in range(n_particles): + * v_dict['v' + str(i)] = v[:, i] + * z_dict['z' + str(i)] = z[:, i] # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_6 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_12 = PyTuple_New(2); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 2194, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 2194, __pyx_L1_error); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_z), __pyx_t_12); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = __Pyx_PyObject_Unicode(__pyx_t_12); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_z, __pyx_t_8); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_z_dict, __pyx_t_12, __pyx_t_6) < 0))) __PYX_ERR(0, 2194, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + + /* "cssm.pyx":2196 + * z_dict['z' + str(i)] = z[:, i] + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2196, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2197 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, # <<<<<<<<<<<<<< + * 'a': a, + * **z_dict, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_6 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 2197, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 2197, __pyx_L1_error) + __pyx_t_12 = PyDict_Copy(__pyx_v_v_dict); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + + /* "cssm.pyx":2198 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, # <<<<<<<<<<<<<< + * **z_dict, + * 'g': g, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 2198, __pyx_L1_error) + + /* "cssm.pyx":2199 + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, + * **z_dict, # <<<<<<<<<<<<<< + * 'g': g, + * 'b': b, +*/ + if (unlikely(PyDict_Update(__pyx_t_12, __pyx_v_z_dict) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_z_dict); + __PYX_ERR(0, 2199, __pyx_L1_error) + } + + /* "cssm.pyx":2200 + * 'a': a, + * **z_dict, + * 'g': g, # <<<<<<<<<<<<<< + * 'b': b, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_g, ((PyObject *)__pyx_v_g)) < (0)) __PYX_ERR(0, 2200, __pyx_L1_error) + + /* "cssm.pyx":2201 + * **z_dict, + * 'g': g, + * 'b': b, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_b, ((PyObject *)__pyx_v_b)) < (0)) __PYX_ERR(0, 2201, __pyx_L1_error) + + /* "cssm.pyx":2202 + * 'g': g, + * 'b': b, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 2202, __pyx_L1_error) + + /* "cssm.pyx":2203 + * 'b': b, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 2203, __pyx_L1_error) + + /* "cssm.pyx":2204 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 2204, __pyx_L1_error) + + /* "cssm.pyx":2205 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 2205, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_12, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 2205, __pyx_L1_error) + } + + /* "cssm.pyx":2206 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_8 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2206, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_8) < (0)) __PYX_ERR(0, 2206, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "cssm.pyx":2207 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_8 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2207, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_8) < (0)) __PYX_ERR(0, 2207, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "cssm.pyx":2208 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator' : 'lca', +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_8) < (0)) __PYX_ERR(0, 2208, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "cssm.pyx":2209 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator' : 'lca', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_8) < (0)) __PYX_ERR(0, 2209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_lca) < (0)) __PYX_ERR(0, 2210, __pyx_L1_error) + + /* "cssm.pyx":2211 + * 'n_trials': n_trials, + * 'simulator' : 'lca', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': list(np.arange(0, n_particles, 1)), + * 'trajectory': traj, +*/ + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_8) < (0)) __PYX_ERR(0, 2211, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + + /* "cssm.pyx":2212 + * 'simulator' : 'lca', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': list(np.arange(0, n_particles, 1)), # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_particles); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_23))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_23); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_23); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_23, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_mstate_global->__pyx_int_1}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_23, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_23 = __Pyx_PySequence_ListKeepNew(__pyx_t_8); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_23) < (0)) __PYX_ERR(0, 2212, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + + /* "cssm.pyx":2213 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': list(np.arange(0, n_particles, 1)), + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 2213, __pyx_L1_error) + + /* "cssm.pyx":2214 + * 'possible_choices': list(np.arange(0, n_particles, 1)), + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'lca', +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 2214, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 2197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "cssm.pyx":2196 + * z_dict['z' + str(i)] = z[:, i] + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, +*/ + } + + /* "cssm.pyx":2215 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'lca', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2215, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":2216 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'lca', # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_6 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 2216, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 2216, __pyx_L1_error) + __pyx_t_12 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2216, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_lca) < (0)) __PYX_ERR(0, 2216, __pyx_L1_error) + + /* "cssm.pyx":2217 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'lca', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_23 = PyList_New(2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2217, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_23, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 2217, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_23, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2217, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_23) < (0)) __PYX_ERR(0, 2216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + + /* "cssm.pyx":2218 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'lca', + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_23 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2218, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_23) < (0)) __PYX_ERR(0, 2216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + + /* "cssm.pyx":2219 + * 'possible_choices': [-1, 1], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_23 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2219, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_23) < (0)) __PYX_ERR(0, 2216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + + /* "cssm.pyx":2220 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_23 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 2220, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_23) < (0)) __PYX_ERR(0, 2216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 2216, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "cssm.pyx":2215 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'lca', + * 'possible_choices': [-1, 1], +*/ + } + + /* "cssm.pyx":2223 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # ----------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_12 = NULL; + __pyx_t_9 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __Pyx_Raise(__pyx_t_6, 0, 0, 0); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __PYX_ERR(0, 2223, __pyx_L1_error) + } + + /* "cssm.pyx":2008 + * + * # Simulate (rt, choice) tuples from: Leaky Competing Accumulator Model ----------------------------- + * def lca(np.ndarray[float, ndim = 2] v, # drift parameters (np.array expect: one column of floats) # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # criterion height + * np.ndarray[float, ndim = 2] z, # initial bias parameters (np.array expect: one column of floats) +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_3, 1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_23); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_b.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.lca", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_b.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_g_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_b_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_particles); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_particles_view, 1); + __Pyx_XDECREF(__pyx_v_particles_reduced_sum); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_particles_reduced_sum_view, 1); + __Pyx_XDECREF(__pyx_v_sqrt_st); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sqrt_st_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_v_v_dict); + __Pyx_XDECREF(__pyx_v_z_dict); + __Pyx_XDECREF(__pyx_8genexpr9__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":2229 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_seq2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + +static PyObject *__pyx_pf_4cssm_66__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":2239 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2239, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":2240 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2240, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":2241 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * print_info = True, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":2242 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2242, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":2229 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_seq2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_5 = PyTuple_New(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, Py_None) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, Py_None) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 10, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 2229, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_23ddm_flexbound_seq2(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_22ddm_flexbound_seq2, "\n Simulate reaction times and choices from a sequential two-stage drift diffusion model with flexible boundaries.\n\n Parameters:\n -----------\n vh : np.ndarray, shape (n_trials,)\n Drift rate for the high-level decision.\n vl1, vl2 : np.ndarray, shape (n_trials,)\n Drift rates for the two low-level decisions.\n a : np.ndarray, shape (n_trials,)\n Initial boundary separation.\n zh : np.ndarray, shape (n_trials,)\n Starting point bias for the high-level decision.\n zl1, zl2 : np.ndarray, shape (n_trials,)\n Starting point biases for the two low-level decisions.\n t : np.ndarray, shape (n_trials,)\n Non-decision time.\n deadline : np.ndarray, shape (n_trials,)\n Deadline for each trial.\n s : np.ndarray, shape (n_trials,)\n Diffusion coefficient (standard deviation of the diffusion process).\n delta_t : float, optional\n Size of the time step in the simulation (default: 0.001).\n max_t : float, optional\n Maximum time for the simulation (default: 20).\n n_samples : int, optional\n Number of samples to simulate (default: 20000).\n n_trials : int, optional\n Number of trials to simulate (default: 1).\n print_info : bool, optional\n Whether to print information during the simulation (default: True).\n boundary_fun : callable, optional\n Function that determines the decision boundary over time (default: None).\n boundary_multiplicative : bool, optional\n If True, the boundary function is multiplicative; if False, it's additive (default: True).\n boundary_params : dict, optional\n Parameters for the boundary function (default: {}).\n random_state : int or None, optional\n Seed for the random number generator (default: None).\n return_option : str, optional\n Determines the amount of data returned. Can be 'full' or 'minimal' (default: 'full').\n smooth_unif : bool, optional\n ""If True, applies uniform smoothing to reaction times (default: False).\n\n Returns:\n --------\n dict\n A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the 'return_option' parameter.\n "); +static PyMethodDef __pyx_mdef_4cssm_23ddm_flexbound_seq2 = {"ddm_flexbound_seq2", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_23ddm_flexbound_seq2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_22ddm_flexbound_seq2}; +static PyObject *__pyx_pw_4cssm_23ddm_flexbound_seq2(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_vh = 0; + PyArrayObject *__pyx_v_vl1 = 0; + PyArrayObject *__pyx_v_vl2 = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_zh = 0; + PyArrayObject *__pyx_v_zl1 = 0; + PyArrayObject *__pyx_v_zl2 = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + CYTHON_UNUSED PyObject *__pyx_v_print_info = 0; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[21] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_flexbound_seq2 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_vh,&__pyx_mstate_global->__pyx_n_u_vl1,&__pyx_mstate_global->__pyx_n_u_vl2,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_zh,&__pyx_mstate_global->__pyx_n_u_zl1,&__pyx_mstate_global->__pyx_n_u_zl2,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_print_info,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2229, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_flexbound_seq2", 1) < (0)) __PYX_ERR(0, 2229, __pyx_L3_error) + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":2244 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[17]) values[17] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":2247 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 10; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_flexbound_seq2", 0, 10, 21, i); __PYX_ERR(0, 2229, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2229, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2229, __pyx_L3_error) + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2229, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2229, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2229, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2229, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2229, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2229, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2229, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2229, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2229, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":2244 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[17]) values[17] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":2247 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_vh = ((PyArrayObject *)values[0]); + __pyx_v_vl1 = ((PyArrayObject *)values[1]); + __pyx_v_vl2 = ((PyArrayObject *)values[2]); + __pyx_v_a = ((PyArrayObject *)values[3]); + __pyx_v_zh = ((PyArrayObject *)values[4]); + __pyx_v_zl1 = ((PyArrayObject *)values[5]); + __pyx_v_zl2 = ((PyArrayObject *)values[6]); + __pyx_v_t = ((PyArrayObject *)values[7]); + __pyx_v_deadline = ((PyArrayObject *)values[8]); + __pyx_v_s = ((PyArrayObject *)values[9]); + if (values[10]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[10]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2239, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[11]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[11]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2240, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[12]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[12]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2241, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[13]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[13]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2242, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_print_info = values[14]; + __pyx_v_boundary_fun = values[15]; + __pyx_v_boundary_multiplicative = values[16]; + __pyx_v_boundary_params = values[17]; + __pyx_v_random_state = values[18]; + __pyx_v_return_option = values[19]; + __pyx_v_smooth_unif = values[20]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_flexbound_seq2", 0, 10, 21, __pyx_nargs); __PYX_ERR(0, 2229, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_flexbound_seq2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vh", 0))) __PYX_ERR(0, 2229, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl1", 0))) __PYX_ERR(0, 2230, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl2", 0))) __PYX_ERR(0, 2231, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 2232, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zh", 0))) __PYX_ERR(0, 2233, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl1", 0))) __PYX_ERR(0, 2234, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl2", 0))) __PYX_ERR(0, 2235, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 2236, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 2237, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 2238, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_22ddm_flexbound_seq2(__pyx_self, __pyx_v_vh, __pyx_v_vl1, __pyx_v_vl2, __pyx_v_a, __pyx_v_zh, __pyx_v_zl1, __pyx_v_zl2, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_print_info, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":2229 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_seq2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_22ddm_flexbound_seq2(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_vh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_v_decision_taken; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y_h; + float __pyx_v_t_particle; + float __pyx_v_t_particle1; + float __pyx_v_t_particle2; + float __pyx_v_y_l; + float __pyx_v_y_l1; + float __pyx_v_y_l2; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_ix1; + Py_ssize_t __pyx_v_ix2; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_9genexpr10__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vh; + __Pyx_Buffer __pyx_pybuffer_vh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl1; + __Pyx_Buffer __pyx_pybuffer_vl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl2; + __Pyx_Buffer __pyx_pybuffer_vl2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zh; + __Pyx_Buffer __pyx_pybuffer_zh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl1; + __Pyx_Buffer __pyx_pybuffer_zl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl2; + __Pyx_Buffer __pyx_pybuffer_zl2; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + Py_ssize_t __pyx_t_30; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_flexbound_seq2", 0); + __pyx_pybuffer_vh.pybuffer.buf = NULL; + __pyx_pybuffer_vh.refcount = 0; + __pyx_pybuffernd_vh.data = NULL; + __pyx_pybuffernd_vh.rcbuffer = &__pyx_pybuffer_vh; + __pyx_pybuffer_vl1.pybuffer.buf = NULL; + __pyx_pybuffer_vl1.refcount = 0; + __pyx_pybuffernd_vl1.data = NULL; + __pyx_pybuffernd_vl1.rcbuffer = &__pyx_pybuffer_vl1; + __pyx_pybuffer_vl2.pybuffer.buf = NULL; + __pyx_pybuffer_vl2.refcount = 0; + __pyx_pybuffernd_vl2.data = NULL; + __pyx_pybuffernd_vl2.rcbuffer = &__pyx_pybuffer_vl2; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_zh.pybuffer.buf = NULL; + __pyx_pybuffer_zh.refcount = 0; + __pyx_pybuffernd_zh.data = NULL; + __pyx_pybuffernd_zh.rcbuffer = &__pyx_pybuffer_zh; + __pyx_pybuffer_zl1.pybuffer.buf = NULL; + __pyx_pybuffer_zl1.refcount = 0; + __pyx_pybuffernd_zl1.data = NULL; + __pyx_pybuffernd_zl1.rcbuffer = &__pyx_pybuffer_zl1; + __pyx_pybuffer_zl2.pybuffer.buf = NULL; + __pyx_pybuffer_zl2.refcount = 0; + __pyx_pybuffernd_zl2.data = NULL; + __pyx_pybuffernd_zl2.rcbuffer = &__pyx_pybuffer_zl2; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vh.rcbuffer->pybuffer, (PyObject*)__pyx_v_vh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_vh.diminfo[0].strides = __pyx_pybuffernd_vh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vh.diminfo[0].shape = __pyx_pybuffernd_vh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_vl1.diminfo[0].strides = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl1.diminfo[0].shape = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_vl2.diminfo[0].strides = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl2.diminfo[0].shape = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zh.rcbuffer->pybuffer, (PyObject*)__pyx_v_zh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_zh.diminfo[0].strides = __pyx_pybuffernd_zh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zh.diminfo[0].shape = __pyx_pybuffernd_zh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_zl1.diminfo[0].strides = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl1.diminfo[0].shape = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_zl2.diminfo[0].strides = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl2.diminfo[0].shape = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2229, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":2302 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:] vh_view = vh +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2302, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":2304 + * set_seed(random_state) + * # Param views + * cdef float[:] vh_view = vh # <<<<<<<<<<<<<< + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2304, __pyx_L1_error) + __pyx_v_vh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2305 + * # Param views + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 # <<<<<<<<<<<<<< + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2305, __pyx_L1_error) + __pyx_v_vl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2306 + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2306, __pyx_L1_error) + __pyx_v_vl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2307 + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2307, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2308 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh # <<<<<<<<<<<<<< + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2308, __pyx_L1_error) + __pyx_v_zh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2309 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 # <<<<<<<<<<<<<< + * cdef float[:] zl2_view = zl2 + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2309, __pyx_L1_error) + __pyx_v_zl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2310 + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2310, __pyx_L1_error) + __pyx_v_zl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2311 + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2311, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2312 + * cdef float[:] zl2_view = zl2 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2312, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2313 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2313, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2314 + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2314, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 2314, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2314, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2314, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2314, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2315 + * cdef float[:] s_view = s + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2315, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 2315, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2315, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2315, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2315, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2317 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * cdef int decision_taken = 0 +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 2317, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":2318 + * + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * cdef int decision_taken = 0 + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 2318, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":2319 + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices + * cdef int decision_taken = 0 # <<<<<<<<<<<<<< + * + * # TD: Add Trajectory +*/ + __pyx_v_decision_taken = 0; + + /* "cssm.pyx":2322 + * + * # TD: Add Trajectory + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyLong_AddObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 2322, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 2322, __pyx_L1_error); + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_7}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2322, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2322, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2323 + * # TD: Add Trajectory + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 2323, __pyx_L1_error) + + /* "cssm.pyx":2324 + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 2324, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":2326 + * cdef float[:, :] traj_view = traj + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":2330 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":2331 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_mstate_global->__pyx_int_0, __pyx_t_7, __pyx_t_12}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_4 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2331, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2332 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2332, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2332, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2333 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * cdef float y_h, t_particle, t_particle1, t_particle2, y_l, y_l1, y_l2, smooth_u, deadline_tmp, sqrt_st +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2333, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2337 + * cdef float y_h, t_particle, t_particle1, t_particle2, y_l, y_l1, y_l2, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, ix1, ix2, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * #cdef Py_ssize_t traj_id + * cdef float[:] gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2339 + * cdef Py_ssize_t m = 0 + * #cdef Py_ssize_t traj_id + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2339, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2341 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":2343 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2343, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 2343, __pyx_L7_error) + } + __pyx_t_7 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2343, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); + __pyx_t_4 = __pyx_t_7; + __pyx_t_7 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_4, __pyx_t_17, &__pyx_t_16, &__pyx_t_7, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 2343, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_9genexpr10__pyx_v_key, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_9genexpr10__pyx_v_key); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2343, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_7, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2343, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_9genexpr10__pyx_v_key, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 2343, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_9genexpr10__pyx_v_key); __pyx_9genexpr10__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_9genexpr10__pyx_v_key); __pyx_9genexpr10__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":2346 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2346, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2347 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_6 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 2347, __pyx_L1_error) + __pyx_t_3 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_3, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 2347, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_3); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_t_22}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_4 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2347, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 2347, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":2346 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":2349 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_3 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 2349, __pyx_L1_error) + __pyx_t_7 = __pyx_t_3; + __pyx_t_3 = 0; + if (__Pyx_MergeKeywords(__pyx_t_7, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 2349, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_22, __pyx_t_3}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_12 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2349, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 2349, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":2351 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_20) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":2352 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":2354 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * decision_taken = 0 + * t_particle = 0.0 # reset time +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":2355 + * # Loop over samples + * for n in range(n_samples): + * decision_taken = 0 # <<<<<<<<<<<<<< + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index +*/ + __pyx_v_decision_taken = 0; + + /* "cssm.pyx":2356 + * for n in range(n_samples): + * decision_taken = 0 + * t_particle = 0.0 # reset time # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":2357 + * decision_taken = 0 + * t_particle = 0.0 # reset time + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * # Random walker 1 (high dimensional) +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":2360 + * + * # Random walker 1 (high dimensional) + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) # reset starting position # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_t_23 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_v_y_h = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zh_view.data + __pyx_t_21 * __pyx_v_zh_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":2362 + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) # reset starting position + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2363 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2364 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y_h # <<<<<<<<<<<<<< + * + * while y_h >= (-1) * boundary_view[ix] and y_h <= boundary_view[ix] and t_particle <= deadline_tmp: +*/ + __pyx_t_27 = 0; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":2363 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + } + + /* "cssm.pyx":2362 + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) # reset starting position + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + } + + /* "cssm.pyx":2366 + * traj_view[0, 0] = y_h + * + * while y_h >= (-1) * boundary_view[ix] and y_h <= boundary_view[ix] and t_particle <= deadline_tmp: # <<<<<<<<<<<<<< + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_21 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_particle <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L18_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":2367 + * + * while y_h >= (-1) * boundary_view[ix] and y_h <= boundary_view[ix] and t_particle <= deadline_tmp: + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_m; + __pyx_v_y_h = (__pyx_v_y_h + (((*((float *) ( /* dim=0 */ (__pyx_v_vh_view.data + __pyx_t_21 * __pyx_v_vh_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_27 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":2368 + * while y_h >= (-1) * boundary_view[ix] and y_h <= boundary_view[ix] and t_particle <= deadline_tmp: + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":2369 + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":2370 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * + * if m == num_draws: +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":2372 + * m += 1 + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":2373 + * + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2373, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2374 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2372 + * m += 1 + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":2376 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2377 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2378 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y_h # <<<<<<<<<<<<<< + * + * # If we are already at maximum t, to generate a choice we just sample from a bernoulli +*/ + __pyx_t_27 = __pyx_v_ix; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":2377 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y_h + * +*/ + } + + /* "cssm.pyx":2376 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y_h +*/ + } + } + + /* "cssm.pyx":2381 + * + * # If we are already at maximum t, to generate a choice we just sample from a bernoulli + * if t_particle >= max_t: # <<<<<<<<<<<<<< + * # High dim choice depends on position of particle + * if boundary_view[ix] <= 0: +*/ + __pyx_t_20 = (__pyx_v_t_particle >= __pyx_v_max_t); + if (__pyx_t_20) { + + /* "cssm.pyx":2383 + * if t_particle >= max_t: + * # High dim choice depends on position of particle + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":2384 + * # High dim choice depends on position of particle + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2384, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":2385 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 2 +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":2384 + * # High dim choice depends on position of particle + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + } + + /* "cssm.pyx":2383 + * if t_particle >= max_t: + * # High dim choice depends on position of particle + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + goto __pyx_L25; + } + + /* "cssm.pyx":2386 + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2386, __pyx_L1_error) + __pyx_t_23 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":2387 + * choices_view[n, k, 0] += 2 + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * + * # Low dim choice random (didn't even get to process it if rt is at max after first choice) +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":2386 + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + } + __pyx_L25:; + + /* "cssm.pyx":2391 + * # Low dim choice random (didn't even get to process it if rt is at max after first choice) + * # so we just apply a priori bias + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * if random_uniform() <= zl1_view[k]: + * choices_view[n, k, 0] += 1 +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2392 + * # so we just apply a priori bias + * if choices_view[n, k, 0] == 0: + * if random_uniform() <= zl1_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * else: +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2392, __pyx_L1_error) + __pyx_t_27 = __pyx_v_k; + __pyx_t_20 = (__pyx_t_26 <= (*((float *) ( /* dim=0 */ (__pyx_v_zl1_view.data + __pyx_t_27 * __pyx_v_zl1_view.strides[0]) )))); + if (__pyx_t_20) { + + /* "cssm.pyx":2393 + * if choices_view[n, k, 0] == 0: + * if random_uniform() <= zl1_view[k]: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * else: + * if random_uniform() <= zl2_view[k]: +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":2392 + * # so we just apply a priori bias + * if choices_view[n, k, 0] == 0: + * if random_uniform() <= zl1_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * else: +*/ + } + + /* "cssm.pyx":2391 + * # Low dim choice random (didn't even get to process it if rt is at max after first choice) + * # so we just apply a priori bias + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * if random_uniform() <= zl1_view[k]: + * choices_view[n, k, 0] += 1 +*/ + goto __pyx_L27; + } + + /* "cssm.pyx":2395 + * choices_view[n, k, 0] += 1 + * else: + * if random_uniform() <= zl2_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * rts_view[n, k, 0] = t_particle +*/ + /*else*/ { + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2395, __pyx_L1_error) + __pyx_t_21 = __pyx_v_k; + __pyx_t_20 = (__pyx_t_26 <= (*((float *) ( /* dim=0 */ (__pyx_v_zl2_view.data + __pyx_t_21 * __pyx_v_zl2_view.strides[0]) )))); + if (__pyx_t_20) { + + /* "cssm.pyx":2396 + * else: + * if random_uniform() <= zl2_view[k]: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = t_particle + * decision_taken = 1 +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":2395 + * choices_view[n, k, 0] += 1 + * else: + * if random_uniform() <= zl2_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * rts_view[n, k, 0] = t_particle +*/ + } + } + __pyx_L27:; + + /* "cssm.pyx":2397 + * if random_uniform() <= zl2_view[k]: + * choices_view[n, k, 0] += 1 + * rts_view[n, k, 0] = t_particle # <<<<<<<<<<<<<< + * decision_taken = 1 + * else: +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_27 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) )) = __pyx_v_t_particle; + + /* "cssm.pyx":2398 + * choices_view[n, k, 0] += 1 + * rts_view[n, k, 0] = t_particle + * decision_taken = 1 # <<<<<<<<<<<<<< + * else: + * # If boundary is negative (or 0) already, we flip a coin +*/ + __pyx_v_decision_taken = 1; + + /* "cssm.pyx":2381 + * + * # If we are already at maximum t, to generate a choice we just sample from a bernoulli + * if t_particle >= max_t: # <<<<<<<<<<<<<< + * # High dim choice depends on position of particle + * if boundary_view[ix] <= 0: +*/ + goto __pyx_L24; + } + + /* "cssm.pyx":2401 + * else: + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + /*else*/ { + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":2402 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2402, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":2403 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":2402 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise apply rule from above +*/ + } + + /* "cssm.pyx":2401 + * else: + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + goto __pyx_L30; + } + + /* "cssm.pyx":2405 + * choices_view[n, k, 0] += 2 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2405, __pyx_L1_error) + __pyx_t_27 = __pyx_v_ix; + __pyx_t_23 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":2406 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * + * y_l1 = (-1) * boundary_view[ix] + (zl1_view[k] * 2 * (boundary_view[ix])) +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":2405 + * choices_view[n, k, 0] += 2 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + } + __pyx_L30:; + + /* "cssm.pyx":2408 + * choices_view[n, k, 0] += 2 + * + * y_l1 = (-1) * boundary_view[ix] + (zl1_view[k] * 2 * (boundary_view[ix])) # <<<<<<<<<<<<<< + * y_l2 = (-1) * boundary_view[ix] + (zl2_view[k] * 2 * (boundary_view[ix])) + * +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = __pyx_v_ix; + __pyx_v_y_l1 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl1_view.data + __pyx_t_27 * __pyx_v_zl1_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":2409 + * + * y_l1 = (-1) * boundary_view[ix] + (zl1_view[k] * 2 * (boundary_view[ix])) + * y_l2 = (-1) * boundary_view[ix] + (zl2_view[k] * 2 * (boundary_view[ix])) # <<<<<<<<<<<<<< + * + * ix1 = ix +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = __pyx_v_ix; + __pyx_v_y_l2 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl2_view.data + __pyx_t_27 * __pyx_v_zl2_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":2411 + * y_l2 = (-1) * boundary_view[ix] + (zl2_view[k] * 2 * (boundary_view[ix])) + * + * ix1 = ix # <<<<<<<<<<<<<< + * t_particle1 = t_particle + * ix2 = ix +*/ + __pyx_v_ix1 = __pyx_v_ix; + + /* "cssm.pyx":2412 + * + * ix1 = ix + * t_particle1 = t_particle # <<<<<<<<<<<<<< + * ix2 = ix + * t_particle2 = t_particle +*/ + __pyx_v_t_particle1 = __pyx_v_t_particle; + + /* "cssm.pyx":2413 + * ix1 = ix + * t_particle1 = t_particle + * ix2 = ix # <<<<<<<<<<<<<< + * t_particle2 = t_particle + * +*/ + __pyx_v_ix2 = __pyx_v_ix; + + /* "cssm.pyx":2414 + * t_particle1 = t_particle + * ix2 = ix + * t_particle2 = t_particle # <<<<<<<<<<<<<< + * + * # Figure out negative bound for low level +*/ + __pyx_v_t_particle2 = __pyx_v_t_particle; + + /* "cssm.pyx":2417 + * + * # Figure out negative bound for low level + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l1 >= boundary_view[ix]) or (y_l1 <= ((-1) * boundary_view[ix])): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2419 + * if choices_view[n, k, 0] == 0: + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l1 >= boundary_view[ix]) or (y_l1 <= ((-1) * boundary_view[ix])): # <<<<<<<<<<<<<< + * if random_uniform() < zl1_view[k]: + * choices_view[n, k, 0] += 1 +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_l1 >= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))); + if (!__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L34_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_l1 <= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + __pyx_t_20 = __pyx_t_28; + __pyx_L34_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":2420 + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l1 >= boundary_view[ix]) or (y_l1 <= ((-1) * boundary_view[ix])): + * if random_uniform() < zl1_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * decision_taken = 1 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2420, __pyx_L1_error) + __pyx_t_23 = __pyx_v_k; + __pyx_t_20 = (__pyx_t_26 < (*((float *) ( /* dim=0 */ (__pyx_v_zl1_view.data + __pyx_t_23 * __pyx_v_zl1_view.strides[0]) )))); + if (__pyx_t_20) { + + /* "cssm.pyx":2421 + * if (y_l1 >= boundary_view[ix]) or (y_l1 <= ((-1) * boundary_view[ix])): + * if random_uniform() < zl1_view[k]: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * decision_taken = 1 + * +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":2420 + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l1 >= boundary_view[ix]) or (y_l1 <= ((-1) * boundary_view[ix])): + * if random_uniform() < zl1_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * decision_taken = 1 +*/ + } + + /* "cssm.pyx":2422 + * if random_uniform() < zl1_view[k]: + * choices_view[n, k, 0] += 1 + * decision_taken = 1 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_decision_taken = 1; + + /* "cssm.pyx":2419 + * if choices_view[n, k, 0] == 0: + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l1 >= boundary_view[ix]) or (y_l1 <= ((-1) * boundary_view[ix])): # <<<<<<<<<<<<<< + * if random_uniform() < zl1_view[k]: + * choices_view[n, k, 0] += 1 +*/ + } + + /* "cssm.pyx":2424 + * decision_taken = 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 1] = y_l1 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2425 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 1] = y_l1 + * else: +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2426 + * if n == 0: + * if k == 0: + * traj_view[ix, 1] = y_l1 # <<<<<<<<<<<<<< + * else: + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_27 = 1; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_27 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l1; + + /* "cssm.pyx":2425 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 1] = y_l1 + * else: +*/ + } + + /* "cssm.pyx":2424 + * decision_taken = 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 1] = y_l1 +*/ + } + + /* "cssm.pyx":2417 + * + * # Figure out negative bound for low level + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l1 >= boundary_view[ix]) or (y_l1 <= ((-1) * boundary_view[ix])): +*/ + goto __pyx_L32; + } + + /* "cssm.pyx":2429 + * else: + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l2 >= boundary_view[ix]) or (y_l2 <= ((-1) * boundary_view[ix])): # <<<<<<<<<<<<<< + * if random_uniform() < zl2_view[k]: + * choices_view[n, k, 0] += 1 +*/ + /*else*/ { + __pyx_t_27 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_l2 >= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))); + if (!__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L40_bool_binop_done; + } + __pyx_t_27 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_l2 <= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + __pyx_t_20 = __pyx_t_28; + __pyx_L40_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":2430 + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l2 >= boundary_view[ix]) or (y_l2 <= ((-1) * boundary_view[ix])): + * if random_uniform() < zl2_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * decision_taken = 1 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2430, __pyx_L1_error) + __pyx_t_27 = __pyx_v_k; + __pyx_t_20 = (__pyx_t_26 < (*((float *) ( /* dim=0 */ (__pyx_v_zl2_view.data + __pyx_t_27 * __pyx_v_zl2_view.strides[0]) )))); + if (__pyx_t_20) { + + /* "cssm.pyx":2431 + * if (y_l2 >= boundary_view[ix]) or (y_l2 <= ((-1) * boundary_view[ix])): + * if random_uniform() < zl2_view[k]: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * decision_taken = 1 + * +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":2430 + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l2 >= boundary_view[ix]) or (y_l2 <= ((-1) * boundary_view[ix])): + * if random_uniform() < zl2_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * decision_taken = 1 +*/ + } + + /* "cssm.pyx":2432 + * if random_uniform() < zl2_view[k]: + * choices_view[n, k, 0] += 1 + * decision_taken = 1 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_decision_taken = 1; + + /* "cssm.pyx":2429 + * else: + * # In case boundary is negative already, we flip a coin with bias determined by w_l_ parameter + * if (y_l2 >= boundary_view[ix]) or (y_l2 <= ((-1) * boundary_view[ix])): # <<<<<<<<<<<<<< + * if random_uniform() < zl2_view[k]: + * choices_view[n, k, 0] += 1 +*/ + } + + /* "cssm.pyx":2434 + * decision_taken = 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 2] = y_l2 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2435 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 2] = y_l2 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2436 + * if n == 0: + * if k == 0: + * traj_view[ix, 2] = y_l2 # <<<<<<<<<<<<<< + * + * # Random walker low level (1) +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_21 = 2; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l2; + + /* "cssm.pyx":2435 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 2] = y_l2 + * +*/ + } + + /* "cssm.pyx":2434 + * decision_taken = 1 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 2] = y_l2 +*/ + } + } + __pyx_L32:; + + /* "cssm.pyx":2439 + * + * # Random walker low level (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_particle1 <= deadline_tmp): + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) ))) == 0) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":2440 + * # Random walker low level (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_particle1 <= deadline_tmp): # <<<<<<<<<<<<<< + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle1 += delta_t +*/ + while (1) { + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L48_bool_binop_done; + } + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L48_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_particle1 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L48_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":2441 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_particle1 <= deadline_tmp): + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle1 += delta_t + * ix1 += 1 +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = __pyx_v_m; + __pyx_v_y_l1 = (__pyx_v_y_l1 + (((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_27 * __pyx_v_vl1_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":2442 + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_particle1 <= deadline_tmp): + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle1 += delta_t # <<<<<<<<<<<<<< + * ix1 += 1 + * m += 1 +*/ + __pyx_v_t_particle1 = (__pyx_v_t_particle1 + __pyx_v_delta_t); + + /* "cssm.pyx":2443 + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle1 += delta_t + * ix1 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix1 = (__pyx_v_ix1 + 1); + + /* "cssm.pyx":2444 + * t_particle1 += delta_t + * ix1 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":2445 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":2446 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2446, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2447 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2445 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":2449 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2450 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2451 + * if n == 0: + * if k == 0: + * traj_view[ix1, 1] = y_l1 # <<<<<<<<<<<<<< + * + * # Random walker low level (2) +*/ + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_27 = 1; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_27 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l1; + + /* "cssm.pyx":2450 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + } + + /* "cssm.pyx":2449 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + } + } + + /* "cssm.pyx":2439 + * + * # Random walker low level (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_particle1 <= deadline_tmp): + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) +*/ + } + + /* "cssm.pyx":2454 + * + * # Random walker low level (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_particle2 <= deadline_tmp): + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) ))) == 2) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":2455 + * # Random walker low level (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_particle2 <= deadline_tmp): # <<<<<<<<<<<<<< + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle2 += delta_t +*/ + while (1) { + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L57_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L57_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_particle2 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L57_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":2456 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_particle2 <= deadline_tmp): + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle2 += delta_t + * ix2 += 1 +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_m; + __pyx_v_y_l2 = (__pyx_v_y_l2 + (((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_21 * __pyx_v_vl2_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":2457 + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_particle2 <= deadline_tmp): + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle2 += delta_t # <<<<<<<<<<<<<< + * ix2 += 1 + * m += 1 +*/ + __pyx_v_t_particle2 = (__pyx_v_t_particle2 + __pyx_v_delta_t); + + /* "cssm.pyx":2458 + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle2 += delta_t + * ix2 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix2 = (__pyx_v_ix2 + 1); + + /* "cssm.pyx":2459 + * t_particle2 += delta_t + * ix2 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":2460 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":2461 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2461, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2462 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2460 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":2464 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2465 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2466 + * if n == 0: + * if k == 0: + * traj_view[ix2, 2] = y_l2 # <<<<<<<<<<<<<< + * + * # Get back to single t_particle +*/ + __pyx_t_23 = __pyx_v_ix2; + __pyx_t_21 = 2; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l2; + + /* "cssm.pyx":2465 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + } + + /* "cssm.pyx":2464 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + } + } + + /* "cssm.pyx":2454 + * + * # Random walker low level (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_particle2 <= deadline_tmp): + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) +*/ + } + + /* "cssm.pyx":2469 + * + * # Get back to single t_particle + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_particle = t_particle1 + * ix = ix1 +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2470 + * # Get back to single t_particle + * if (choices_view[n, k, 0] == 0): + * t_particle = t_particle1 # <<<<<<<<<<<<<< + * ix = ix1 + * y_l = y_l1 +*/ + __pyx_v_t_particle = __pyx_v_t_particle1; + + /* "cssm.pyx":2471 + * if (choices_view[n, k, 0] == 0): + * t_particle = t_particle1 + * ix = ix1 # <<<<<<<<<<<<<< + * y_l = y_l1 + * else: +*/ + __pyx_v_ix = __pyx_v_ix1; + + /* "cssm.pyx":2472 + * t_particle = t_particle1 + * ix = ix1 + * y_l = y_l1 # <<<<<<<<<<<<<< + * else: + * t_particle = t_particle2 +*/ + __pyx_v_y_l = __pyx_v_y_l1; + + /* "cssm.pyx":2469 + * + * # Get back to single t_particle + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_particle = t_particle1 + * ix = ix1 +*/ + goto __pyx_L63; + } + + /* "cssm.pyx":2474 + * y_l = y_l1 + * else: + * t_particle = t_particle2 # <<<<<<<<<<<<<< + * ix = ix2 + * y_l = y_l2 +*/ + /*else*/ { + __pyx_v_t_particle = __pyx_v_t_particle2; + + /* "cssm.pyx":2475 + * else: + * t_particle = t_particle2 + * ix = ix2 # <<<<<<<<<<<<<< + * y_l = y_l2 + * +*/ + __pyx_v_ix = __pyx_v_ix2; + + /* "cssm.pyx":2476 + * t_particle = t_particle2 + * ix = ix2 + * y_l = y_l2 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_y_l = __pyx_v_y_l2; + } + __pyx_L63:; + } + __pyx_L24:; + + /* "cssm.pyx":2478 + * y_l = y_l2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2478, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2479 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":2480 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2480, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":2479 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: +*/ + goto __pyx_L65; + } + + /* "cssm.pyx":2481 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (__pyx_v_t_particle < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":2482 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2482, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":2481 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L65; + } + + /* "cssm.pyx":2484 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L65:; + + /* "cssm.pyx":2478 + * y_l = y_l2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L64; + } + + /* "cssm.pyx":2486 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * # Add nondecision time and smoothing of rt +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L64:; + + /* "cssm.pyx":2489 + * + * # Add nondecision time and smoothing of rt + * rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u # <<<<<<<<<<<<<< + * + * # Take account of deadline +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_23 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_27 * __pyx_v_t_view.strides[0]) )))) + __pyx_v_smooth_u); + + /* "cssm.pyx":2492 + * + * # Take account of deadline + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_23 = __pyx_v_k; + __pyx_t_30 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_27 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_23 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_30 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":2493 + * # Take account of deadline + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_30 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_30 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":2492 + * + * # Take account of deadline + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + + /* "cssm.pyx":2500 + * + * # If boundary is negative (or 0) already, we flip a coin + * if not decision_taken: # <<<<<<<<<<<<<< + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: +*/ + __pyx_t_20 = (!(__pyx_v_decision_taken != 0)); + if (__pyx_t_20) { + + /* "cssm.pyx":2501 + * # If boundary is negative (or 0) already, we flip a coin + * if not decision_taken: + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":2502 + * if not decision_taken: + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2502, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":2503 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_30 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_30 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":2502 + * if not decision_taken: + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + } + + /* "cssm.pyx":2501 + * # If boundary is negative (or 0) already, we flip a coin + * if not decision_taken: + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + goto __pyx_L68; + } + + /* "cssm.pyx":2505 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2505, __pyx_L1_error) + __pyx_t_30 = __pyx_v_ix; + __pyx_t_23 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_l + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_30 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":2506 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_30 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_30 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":2505 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + } + __pyx_L68:; + + /* "cssm.pyx":2500 + * + * # If boundary is negative (or 0) already, we flip a coin + * if not decision_taken: # <<<<<<<<<<<<<< + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: +*/ + } + } + } + + /* "cssm.pyx":2508 + * choices_view[n, k, 0] += 1 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, + * 'vl1': vl1, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2508, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2509 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, # <<<<<<<<<<<<<< + * 'vl1': vl1, + * 'vl2': vl2, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(10); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2509, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_vh, ((PyObject *)__pyx_v_vh)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + + /* "cssm.pyx":2510 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, + * 'vl1': vl1, # <<<<<<<<<<<<<< + * 'vl2': vl2, + * 'a': a, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_vl1, ((PyObject *)__pyx_v_vl1)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + + /* "cssm.pyx":2511 + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, + * 'vl1': vl1, + * 'vl2': vl2, # <<<<<<<<<<<<<< + * 'a': a, + * 'zh': zh, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_vl2, ((PyObject *)__pyx_v_vl2)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + + /* "cssm.pyx":2512 + * 'vl1': vl1, + * 'vl2': vl2, + * 'a': a, # <<<<<<<<<<<<<< + * 'zh': zh, + * 'zl1': zl1, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + + /* "cssm.pyx":2513 + * 'vl2': vl2, + * 'a': a, + * 'zh': zh, # <<<<<<<<<<<<<< + * 'zl1': zl1, + * 'zl2': zl2, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zh, ((PyObject *)__pyx_v_zh)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + + /* "cssm.pyx":2514 + * 'a': a, + * 'zh': zh, + * 'zl1': zl1, # <<<<<<<<<<<<<< + * 'zl2': zl2, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zl1, ((PyObject *)__pyx_v_zl1)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + + /* "cssm.pyx":2515 + * 'zh': zh, + * 'zl1': zl1, + * 'zl2': zl2, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_zl2, ((PyObject *)__pyx_v_zl2)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + + /* "cssm.pyx":2516 + * 'zl1': zl1, + * 'zl2': zl2, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + + /* "cssm.pyx":2517 + * 'zl2': zl2, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + + /* "cssm.pyx":2518 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + __pyx_t_5 = __pyx_t_6; + __pyx_t_6 = 0; + + /* "cssm.pyx":2519 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 2519, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_5, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 2519, __pyx_L1_error) + } + + /* "cssm.pyx":2520 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2520, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_6) < (0)) __PYX_ERR(0, 2520, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2521 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2521, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_6) < (0)) __PYX_ERR(0, 2521, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2522 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound', +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2522, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 2522, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2523 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2523, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 2523, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound) < (0)) __PYX_ERR(0, 2524, __pyx_L1_error) + + /* "cssm.pyx":2525 + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'possible_choices': [0, 1, 2, 3], +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2525, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_6) < (0)) __PYX_ERR(0, 2525, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2526 + * 'simulator': 'ddm_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'boundary': boundary}} +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 2526, __pyx_L1_error) + + /* "cssm.pyx":2527 + * 'boundary_fun_type': boundary_fun.__name__, + * 'trajectory': traj, + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + __pyx_t_6 = PyList_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 2527, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2527, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 2527, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 2527, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 2527, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2528 + * 'trajectory': traj, + * 'possible_choices': [0, 1, 2, 3], + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 2528, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_5) < (0)) __PYX_ERR(0, 2509, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":2508 + * choices_view[n, k, 0] += 1 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, + * 'vl1': vl1, +*/ + } + + /* "cssm.pyx":2529 + * 'possible_choices': [0, 1, 2, 3], + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [0, 1, 2, 3], +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2529, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":2530 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2530, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 2530, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 2530, __pyx_L1_error) + __pyx_t_5 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2530, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound) < (0)) __PYX_ERR(0, 2530, __pyx_L1_error) + + /* "cssm.pyx":2531 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_6 = PyList_New(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2531, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 2531, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2531, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 2531, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 2531, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_6) < (0)) __PYX_ERR(0, 2530, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2532 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2532, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_6) < (0)) __PYX_ERR(0, 2530, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2533 + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_6) < (0)) __PYX_ERR(0, 2530, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":2534 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2534, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_6) < (0)) __PYX_ERR(0, 2530, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_5) < (0)) __PYX_ERR(0, 2530, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":2529 + * 'possible_choices': [0, 1, 2, 3], + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [0, 1, 2, 3], +*/ + } + + /* "cssm.pyx":2537 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # ----------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_5 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2537, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 2537, __pyx_L1_error) + } + + /* "cssm.pyx":2229 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_seq2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_flexbound_seq2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_9genexpr10__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":2543 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_par2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + +static PyObject *__pyx_pf_4cssm_68__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":2553 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2553, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":2554 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2554, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":2555 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * print_info = True, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2555, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":2556 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2556, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":2543 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_par2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_5 = PyTuple_New(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, Py_None) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, Py_None) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 10, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 2543, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_25ddm_flexbound_par2(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_24ddm_flexbound_par2, "\n Simulate a parallel diffusion decision model with flexible boundaries.\n\n This function simulates a two-stage decision process where a high-dimensional choice\n is made first, followed by a low-dimensional choice. The process uses a flexible\n boundary that can change over time.\n\n Parameters:\n -----------\n vh, vl1, vl2 : np.ndarray\n Drift rates for high-dimensional and two low-dimensional choices.\n a : np.ndarray\n Initial boundary separation.\n zh, zl1, zl2 : np.ndarray\n Starting points for high-dimensional and two low-dimensional choices.\n t : np.ndarray\n Non-decision time.\n deadline : np.ndarray\n Time limit for each trial.\n s : np.ndarray\n Noise standard deviation.\n delta_t : float, optional\n Size of time steps in simulation. Default is 0.001.\n max_t : float, optional\n Maximum time for each trial. Default is 20.\n n_samples : int, optional\n Number of simulations per trial. Default is 20000.\n n_trials : int, optional\n Number of trials to simulate. Default is 1.\n print_info : bool, optional\n Whether to print information during simulation. Default is True.\n boundary_fun : callable, optional\n Function defining the decision boundary over time.\n boundary_multiplicative : bool, optional\n If True, boundary function is multiplied by 'a'. If False, it's added. Default is True.\n boundary_params : dict, optional\n Additional parameters for the boundary function.\n random_state : int or None, optional\n Seed for random number generator. Default is None.\n return_option : str, optional\n Determines the content of the returned dictionary. Can be 'full' or 'minimal'. Default is 'full'.\n smooth_unif : bool, optional\n If True, adds uniform noise to simulate continuous time. Default is False.\n\n Returns:\n --------\n dict\n A dictionary containing ""simulation results. The exact contents depend on the return_option.\n 'full' returns all simulation data and parameters, while 'minimal' returns only essential outputs.\n "); +static PyMethodDef __pyx_mdef_4cssm_25ddm_flexbound_par2 = {"ddm_flexbound_par2", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_25ddm_flexbound_par2, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_24ddm_flexbound_par2}; +static PyObject *__pyx_pw_4cssm_25ddm_flexbound_par2(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_vh = 0; + PyArrayObject *__pyx_v_vl1 = 0; + PyArrayObject *__pyx_v_vl2 = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_zh = 0; + PyArrayObject *__pyx_v_zl1 = 0; + PyArrayObject *__pyx_v_zl2 = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + CYTHON_UNUSED PyObject *__pyx_v_print_info = 0; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[21] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_flexbound_par2 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_vh,&__pyx_mstate_global->__pyx_n_u_vl1,&__pyx_mstate_global->__pyx_n_u_vl2,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_zh,&__pyx_mstate_global->__pyx_n_u_zl1,&__pyx_mstate_global->__pyx_n_u_zl2,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_print_info,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2543, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_flexbound_par2", 1) < (0)) __PYX_ERR(0, 2543, __pyx_L3_error) + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":2558 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[17]) values[17] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":2561 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 10; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_flexbound_par2", 0, 10, 21, i); __PYX_ERR(0, 2543, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2543, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2543, __pyx_L3_error) + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2543, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2543, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2543, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2543, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2543, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2543, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2543, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2543, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2543, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[14]) values[14] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":2558 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[17]) values[17] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":2561 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_vh = ((PyArrayObject *)values[0]); + __pyx_v_vl1 = ((PyArrayObject *)values[1]); + __pyx_v_vl2 = ((PyArrayObject *)values[2]); + __pyx_v_a = ((PyArrayObject *)values[3]); + __pyx_v_zh = ((PyArrayObject *)values[4]); + __pyx_v_zl1 = ((PyArrayObject *)values[5]); + __pyx_v_zl2 = ((PyArrayObject *)values[6]); + __pyx_v_t = ((PyArrayObject *)values[7]); + __pyx_v_deadline = ((PyArrayObject *)values[8]); + __pyx_v_s = ((PyArrayObject *)values[9]); + if (values[10]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[10]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2553, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[11]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[11]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2554, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[12]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[12]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2555, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[13]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[13]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2556, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_print_info = values[14]; + __pyx_v_boundary_fun = values[15]; + __pyx_v_boundary_multiplicative = values[16]; + __pyx_v_boundary_params = values[17]; + __pyx_v_random_state = values[18]; + __pyx_v_return_option = values[19]; + __pyx_v_smooth_unif = values[20]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_flexbound_par2", 0, 10, 21, __pyx_nargs); __PYX_ERR(0, 2543, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_flexbound_par2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vh", 0))) __PYX_ERR(0, 2543, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl1", 0))) __PYX_ERR(0, 2544, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl2", 0))) __PYX_ERR(0, 2545, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 2546, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zh", 0))) __PYX_ERR(0, 2547, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl1", 0))) __PYX_ERR(0, 2548, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl2", 0))) __PYX_ERR(0, 2549, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 2550, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 2551, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 2552, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_24ddm_flexbound_par2(__pyx_self, __pyx_v_vh, __pyx_v_vl1, __pyx_v_vl2, __pyx_v_a, __pyx_v_zh, __pyx_v_zl1, __pyx_v_zl2, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_print_info, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":2543 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_par2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_24ddm_flexbound_par2(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_vh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_rts_high = NULL; + PyObject *__pyx_v_rts_low = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_high_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_low_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y_h; + float __pyx_v_y_l; + float __pyx_v_y_l1; + float __pyx_v_y_l2; + float __pyx_v_t_h; + float __pyx_v_t_l; + float __pyx_v_t_l1; + float __pyx_v_t_l2; + float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_ix1; + Py_ssize_t __pyx_v_ix2; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_9genexpr11__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vh; + __Pyx_Buffer __pyx_pybuffer_vh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl1; + __Pyx_Buffer __pyx_pybuffer_vl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl2; + __Pyx_Buffer __pyx_pybuffer_vl2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zh; + __Pyx_Buffer __pyx_pybuffer_zh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl1; + __Pyx_Buffer __pyx_pybuffer_zl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl2; + __Pyx_Buffer __pyx_pybuffer_zl2; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + size_t __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + Py_ssize_t __pyx_t_30; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_flexbound_par2", 0); + __pyx_pybuffer_vh.pybuffer.buf = NULL; + __pyx_pybuffer_vh.refcount = 0; + __pyx_pybuffernd_vh.data = NULL; + __pyx_pybuffernd_vh.rcbuffer = &__pyx_pybuffer_vh; + __pyx_pybuffer_vl1.pybuffer.buf = NULL; + __pyx_pybuffer_vl1.refcount = 0; + __pyx_pybuffernd_vl1.data = NULL; + __pyx_pybuffernd_vl1.rcbuffer = &__pyx_pybuffer_vl1; + __pyx_pybuffer_vl2.pybuffer.buf = NULL; + __pyx_pybuffer_vl2.refcount = 0; + __pyx_pybuffernd_vl2.data = NULL; + __pyx_pybuffernd_vl2.rcbuffer = &__pyx_pybuffer_vl2; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_zh.pybuffer.buf = NULL; + __pyx_pybuffer_zh.refcount = 0; + __pyx_pybuffernd_zh.data = NULL; + __pyx_pybuffernd_zh.rcbuffer = &__pyx_pybuffer_zh; + __pyx_pybuffer_zl1.pybuffer.buf = NULL; + __pyx_pybuffer_zl1.refcount = 0; + __pyx_pybuffernd_zl1.data = NULL; + __pyx_pybuffernd_zl1.rcbuffer = &__pyx_pybuffer_zl1; + __pyx_pybuffer_zl2.pybuffer.buf = NULL; + __pyx_pybuffer_zl2.refcount = 0; + __pyx_pybuffernd_zl2.data = NULL; + __pyx_pybuffernd_zl2.rcbuffer = &__pyx_pybuffer_zl2; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vh.rcbuffer->pybuffer, (PyObject*)__pyx_v_vh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_vh.diminfo[0].strides = __pyx_pybuffernd_vh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vh.diminfo[0].shape = __pyx_pybuffernd_vh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_vl1.diminfo[0].strides = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl1.diminfo[0].shape = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_vl2.diminfo[0].strides = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl2.diminfo[0].shape = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zh.rcbuffer->pybuffer, (PyObject*)__pyx_v_zh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_zh.diminfo[0].strides = __pyx_pybuffernd_zh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zh.diminfo[0].shape = __pyx_pybuffernd_zh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_zl1.diminfo[0].strides = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl1.diminfo[0].shape = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_zl2.diminfo[0].strides = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl2.diminfo[0].shape = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2543, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":2616 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:] vh_view = vh +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":2618 + * set_seed(random_state) + * # Param views + * cdef float[:] vh_view = vh # <<<<<<<<<<<<<< + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2618, __pyx_L1_error) + __pyx_v_vh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2619 + * # Param views + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 # <<<<<<<<<<<<<< + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2619, __pyx_L1_error) + __pyx_v_vl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2620 + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2620, __pyx_L1_error) + __pyx_v_vl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2621 + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2621, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2622 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh # <<<<<<<<<<<<<< + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2622, __pyx_L1_error) + __pyx_v_zh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2623 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 # <<<<<<<<<<<<<< + * cdef float[:] zl2_view = zl2 + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2623, __pyx_L1_error) + __pyx_v_zl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2624 + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2624, __pyx_L1_error) + __pyx_v_zl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2625 + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2625, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2626 + * cdef float[:] zl2_view = zl2 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2626, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2627 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * + * # TD: Add trajectory --> Tricky here because the simulator is optimized to include only two instead of three particles (high dimension choice determines which low dimension choice will matter for ultimate choice) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2627, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2631 + * # TD: Add trajectory --> Tricky here because the simulator is optimized to include only two instead of three particles (high dimension choice determines which low dimension choice will matter for ultimate choice) + * # TD: Add Trajectory + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_4, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 2631, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 2631, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2631, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2631, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2632 + * # TD: Add Trajectory + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 2632, __pyx_L1_error) + + /* "cssm.pyx":2633 + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 2633, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":2635 + * cdef float[:, :] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 2635, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 2635, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2635, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2635, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2636 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 2636, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2636, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2636, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2636, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2636, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_high = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2637 + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 2637, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 2637, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2637, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2637, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2637, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_low = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2638 + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_8) != (0)) __PYX_ERR(0, 2638, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 2638, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2638, __pyx_L1_error); + __pyx_t_8 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_4}; + __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_8, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2638, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2638, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2640 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 2640, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":2641 + * + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_high, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 2641, __pyx_L1_error) + __pyx_v_rts_high_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":2642 + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_low, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 2642, __pyx_L1_error) + __pyx_v_rts_low_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":2643 + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 2643, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":2645 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":2649 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":2651 + * cdef int num_draws = int((max_t / delta_t) + 1) + * + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_8, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_t_12}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_7, (4-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2651, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2652 + * + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2652, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2652, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2653 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * cdef float y_h, y_l, y_l1, y_l2, v_l, v_l1, v_l2, t_h, t_l, t_l1, t_l2, smooth_u, deadline_tmp, sqrt_st +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2653, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2657 + * cdef float y_h, y_l, y_l1, y_l2, v_l, v_l1, v_l2, t_h, t_l, t_l1, t_l2, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, ix1, ix2, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2658 + * cdef Py_ssize_t n, ix, ix1, ix2, k + * cdef Py_ssize_t m = 0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2658, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2660 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":2662 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2662, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 2662, __pyx_L7_error) + } + __pyx_t_4 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2662, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __pyx_t_5 = __pyx_t_4; + __pyx_t_4 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_5, __pyx_t_17, &__pyx_t_16, &__pyx_t_4, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 2662, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_XDECREF_SET(__pyx_9genexpr11__pyx_v_key, __pyx_t_4); + __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_9genexpr11__pyx_v_key); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2662, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_GetItemInt(__pyx_t_4, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2662, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_9genexpr11__pyx_v_key, (PyObject*)__pyx_t_12))) __PYX_ERR(0, 2662, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + } + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XDECREF(__pyx_9genexpr11__pyx_v_key); __pyx_9genexpr11__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_9genexpr11__pyx_v_key); __pyx_9genexpr11__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":2665 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2665, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2666 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_3 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 2666, __pyx_L1_error) + __pyx_t_8 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_8, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 2666, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_8); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, __pyx_t_3, __pyx_t_22}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_5 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2666, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 2666, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":2665 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":2668 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_8 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 2668, __pyx_L1_error) + __pyx_t_4 = __pyx_t_8; + __pyx_t_8 = 0; + if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 2668, __pyx_L1_error) + __pyx_t_8 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 2668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_7 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_7 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_22, __pyx_t_8}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_7, (3-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_12 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_7 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2668, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 2668, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":2670 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_20) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":2671 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":2673 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * t_h = 0.0 # reset time high dimension + * t_l1 = 0.0 # reset time low dimension (1) +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":2674 + * # Loop over samples + * for n in range(n_samples): + * t_h = 0.0 # reset time high dimension # <<<<<<<<<<<<<< + * t_l1 = 0.0 # reset time low dimension (1) + * t_l2 = 0.0 # reset time low dimension (2) +*/ + __pyx_v_t_h = 0.0; + + /* "cssm.pyx":2675 + * for n in range(n_samples): + * t_h = 0.0 # reset time high dimension + * t_l1 = 0.0 # reset time low dimension (1) # <<<<<<<<<<<<<< + * t_l2 = 0.0 # reset time low dimension (2) + * t_l = 0.0 # reset time low dimension (1 or 2) +*/ + __pyx_v_t_l1 = 0.0; + + /* "cssm.pyx":2676 + * t_h = 0.0 # reset time high dimension + * t_l1 = 0.0 # reset time low dimension (1) + * t_l2 = 0.0 # reset time low dimension (2) # <<<<<<<<<<<<<< + * t_l = 0.0 # reset time low dimension (1 or 2) + * ix = 0 # reset boundary index +*/ + __pyx_v_t_l2 = 0.0; + + /* "cssm.pyx":2677 + * t_l1 = 0.0 # reset time low dimension (1) + * t_l2 = 0.0 # reset time low dimension (2) + * t_l = 0.0 # reset time low dimension (1 or 2) # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_l = 0.0; + + /* "cssm.pyx":2678 + * t_l2 = 0.0 # reset time low dimension (2) + * t_l = 0.0 # reset time low dimension (1 or 2) + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * # Initialize walkers +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":2681 + * + * # Initialize walkers + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_t_23 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_v_y_h = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zh_view.data + __pyx_t_21 * __pyx_v_zh_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":2683 + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2684 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2685 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y_h # <<<<<<<<<<<<<< + * + * # Random walks until y_h hits bound +*/ + __pyx_t_27 = 0; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":2684 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + } + + /* "cssm.pyx":2683 + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + } + + /* "cssm.pyx":2688 + * + * # Random walks until y_h hits bound + * while (y_h >= (-1) * boundary_view[ix]) and (y_h <= boundary_view[ix]) and (t_h <= deadline_tmp): # <<<<<<<<<<<<<< + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_h += delta_t +*/ + while (1) { + __pyx_t_21 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_h <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L18_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":2689 + * # Random walks until y_h hits bound + * while (y_h >= (-1) * boundary_view[ix]) and (y_h <= boundary_view[ix]) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_h += delta_t + * ix += 1 +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_m; + __pyx_v_y_h = (__pyx_v_y_h + (((*((float *) ( /* dim=0 */ (__pyx_v_vh_view.data + __pyx_t_21 * __pyx_v_vh_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_27 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":2690 + * while (y_h >= (-1) * boundary_view[ix]) and (y_h <= boundary_view[ix]) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_h += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_h = (__pyx_v_t_h + __pyx_v_delta_t); + + /* "cssm.pyx":2691 + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_h += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":2692 + * t_h += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":2693 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":2694 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2694, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2695 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2693 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":2697 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2698 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2699 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y_h # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_27 = __pyx_v_ix; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":2698 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y_h + * +*/ + } + + /* "cssm.pyx":2697 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y_h +*/ + } + } + + /* "cssm.pyx":2706 + * + * # if boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":2707 + * # if boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2707, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":2708 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":2707 + * # if boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise apply rule from above +*/ + } + + /* "cssm.pyx":2706 + * + * # if boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + goto __pyx_L24; + } + + /* "cssm.pyx":2710 + * choices_view[n, k, 0] += 2 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2710, __pyx_L1_error) + __pyx_t_23 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":2711 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * + * # Initialize lower level walkers +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":2710 + * choices_view[n, k, 0] += 2 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + } + __pyx_L24:; + + /* "cssm.pyx":2714 + * + * # Initialize lower level walkers + * y_l1 = (-1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * y_l2 = (-1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) + * +*/ + __pyx_t_21 = 0; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_v_y_l1 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl1_view.data + __pyx_t_23 * __pyx_v_zl1_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":2715 + * # Initialize lower level walkers + * y_l1 = (-1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * y_l2 = (-1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * + * # Random walker lower level (1) +*/ + __pyx_t_27 = 0; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_v_y_l2 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl2_view.data + __pyx_t_23 * __pyx_v_zl2_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":2718 + * + * # Random walker lower level (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * ix1 = 0 + * while (y_l1 >= (-1) * boundary_view[ix1]) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) ))) == 0) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":2719 + * # Random walker lower level (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * ix1 = 0 # <<<<<<<<<<<<<< + * while (y_l1 >= (-1) * boundary_view[ix1]) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) +*/ + __pyx_v_ix1 = 0; + + /* "cssm.pyx":2720 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * ix1 = 0 + * while (y_l1 >= (-1) * boundary_view[ix1]) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): # <<<<<<<<<<<<<< + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_l1 += delta_t +*/ + while (1) { + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L29_bool_binop_done; + } + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L29_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l1 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L29_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":2721 + * ix1 = 0 + * while (y_l1 >= (-1) * boundary_view[ix1]) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_l1 += delta_t + * ix1 += 1 +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = __pyx_v_m; + __pyx_v_y_l1 = (__pyx_v_y_l1 + (((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_27 * __pyx_v_vl1_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":2722 + * while (y_l1 >= (-1) * boundary_view[ix1]) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_l1 += delta_t # <<<<<<<<<<<<<< + * ix1 += 1 + * m += 1 +*/ + __pyx_v_t_l1 = (__pyx_v_t_l1 + __pyx_v_delta_t); + + /* "cssm.pyx":2723 + * y_l1 += (vl1_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_l1 += delta_t + * ix1 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix1 = (__pyx_v_ix1 + 1); + + /* "cssm.pyx":2724 + * t_l1 += delta_t + * ix1 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":2725 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":2726 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2726, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2727 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2725 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":2729 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2730 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2731 + * if n == 0: + * if k == 0: + * traj_view[ix1, 1] = y_l1 # <<<<<<<<<<<<<< + * + * # Random walker lower level (2) +*/ + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_27 = 1; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_27 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l1; + + /* "cssm.pyx":2730 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + } + + /* "cssm.pyx":2729 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + } + } + + /* "cssm.pyx":2718 + * + * # Random walker lower level (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * ix1 = 0 + * while (y_l1 >= (-1) * boundary_view[ix1]) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): +*/ + } + + /* "cssm.pyx":2734 + * + * # Random walker lower level (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * ix2 = 0 + * while (y_l2 >= (-1) * boundary_view[ix2]) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) ))) == 2) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":2735 + * # Random walker lower level (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * ix2 = 0 # <<<<<<<<<<<<<< + * while (y_l2 >= (-1) * boundary_view[ix2]) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) +*/ + __pyx_v_ix2 = 0; + + /* "cssm.pyx":2736 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * ix2 = 0 + * while (y_l2 >= (-1) * boundary_view[ix2]) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): # <<<<<<<<<<<<<< + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_l2 += delta_t +*/ + while (1) { + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L38_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L38_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l2 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L38_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":2737 + * ix2 = 0 + * while (y_l2 >= (-1) * boundary_view[ix2]) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_l2 += delta_t + * ix2 += 1 +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_m; + __pyx_v_y_l2 = (__pyx_v_y_l2 + (((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_21 * __pyx_v_vl2_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":2738 + * while (y_l2 >= (-1) * boundary_view[ix2]) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_l2 += delta_t # <<<<<<<<<<<<<< + * ix2 += 1 + * m += 1 +*/ + __pyx_v_t_l2 = (__pyx_v_t_l2 + __pyx_v_delta_t); + + /* "cssm.pyx":2739 + * y_l2 += (vl2_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_l2 += delta_t + * ix2 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix2 = (__pyx_v_ix2 + 1); + + /* "cssm.pyx":2740 + * t_l2 += delta_t + * ix2 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":2741 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":2742 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2742, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2743 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2741 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":2745 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2746 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2747 + * if n == 0: + * if k == 0: + * traj_view[ix2, 2] = y_l2 # <<<<<<<<<<<<<< + * + * # Consider only relevant lower-dim walker for final rt +*/ + __pyx_t_23 = __pyx_v_ix2; + __pyx_t_21 = 2; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l2; + + /* "cssm.pyx":2746 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + } + + /* "cssm.pyx":2745 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + } + } + + /* "cssm.pyx":2734 + * + * # Random walker lower level (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * ix2 = 0 + * while (y_l2 >= (-1) * boundary_view[ix2]) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): +*/ + } + + /* "cssm.pyx":2750 + * + * # Consider only relevant lower-dim walker for final rt + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2751 + * # Consider only relevant lower-dim walker for final rt + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 # <<<<<<<<<<<<<< + * y_l = y_l1 + * ix = ix1 +*/ + __pyx_v_t_l = __pyx_v_t_l1; + + /* "cssm.pyx":2752 + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 + * y_l = y_l1 # <<<<<<<<<<<<<< + * ix = ix1 + * else: +*/ + __pyx_v_y_l = __pyx_v_y_l1; + + /* "cssm.pyx":2753 + * t_l = t_l1 + * y_l = y_l1 + * ix = ix1 # <<<<<<<<<<<<<< + * else: + * t_l = t_l2 +*/ + __pyx_v_ix = __pyx_v_ix1; + + /* "cssm.pyx":2750 + * + * # Consider only relevant lower-dim walker for final rt + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + goto __pyx_L44; + } + + /* "cssm.pyx":2755 + * ix = ix1 + * else: + * t_l = t_l2 # <<<<<<<<<<<<<< + * y_l = y_l2 + * ix = ix2 +*/ + /*else*/ { + __pyx_v_t_l = __pyx_v_t_l2; + + /* "cssm.pyx":2756 + * else: + * t_l = t_l2 + * y_l = y_l2 # <<<<<<<<<<<<<< + * ix = ix2 + * +*/ + __pyx_v_y_l = __pyx_v_y_l2; + + /* "cssm.pyx":2757 + * t_l = t_l2 + * y_l = y_l2 + * ix = ix2 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_ix = __pyx_v_ix2; + } + __pyx_L44:; + + /* "cssm.pyx":2759 + * ix = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2759, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2760 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_h == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":2761 + * if smooth_unif: + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2761, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":2760 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + goto __pyx_L46; + } + + /* "cssm.pyx":2762 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (fmax(__pyx_v_t_h, __pyx_v_t_l) < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":2763 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2763, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":2762 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L46; + } + + /* "cssm.pyx":2765 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L46:; + + /* "cssm.pyx":2759 + * ix = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L45; + } + + /* "cssm.pyx":2767 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + smooth_u +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L45:; + + /* "cssm.pyx":2769 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + smooth_u # <<<<<<<<<<<<<< + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_23 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = ((fmax(__pyx_v_t_h, __pyx_v_t_l) + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_27 * __pyx_v_t_view.strides[0]) )))) + __pyx_v_smooth_u); + + /* "cssm.pyx":2770 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + smooth_u + * rts_high_view[n, k, 0] = t_h + t_view[k] # <<<<<<<<<<<<<< + * rts_low_view[n, k, 0] = t_l + t_view[k] + * +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_29 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_high_view.data + __pyx_t_29 * __pyx_v_rts_high_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_high_view.strides[1]) ) + __pyx_t_23 * __pyx_v_rts_high_view.strides[2]) )) = (__pyx_v_t_h + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_27 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":2771 + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + smooth_u + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_low_view.data + __pyx_t_23 * __pyx_v_rts_low_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_low_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_low_view.strides[2]) )) = (__pyx_v_t_l + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_27 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":2778 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + __pyx_t_27 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":2779 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2779, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":2780 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":2779 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + } + + /* "cssm.pyx":2778 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + goto __pyx_L47; + } + + /* "cssm.pyx":2782 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2782, __pyx_L1_error) + __pyx_t_21 = __pyx_v_ix; + __pyx_t_29 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_l + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_29 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":2783 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_29 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_29 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":2782 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + } + __pyx_L47:; + + /* "cssm.pyx":2785 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = 0; + __pyx_t_23 = __pyx_v_k; + __pyx_t_30 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_27 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_23 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_30 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":2786 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_30 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_30 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":2785 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":2788 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, + * 'metadata': {'vh': vh, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2788, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2789 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, # <<<<<<<<<<<<<< + * 'metadata': {'vh': vh, + * 'vl1': vl1, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2789, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 2789, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 2789, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 2789, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 2789, __pyx_L1_error) + + /* "cssm.pyx":2790 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, + * 'metadata': {'vh': vh, # <<<<<<<<<<<<<< + * 'vl1': vl1, + * 'vl2': vl2, +*/ + __pyx_t_3 = __Pyx_PyDict_NewPresized(10); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2790, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_vh, ((PyObject *)__pyx_v_vh)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + + /* "cssm.pyx":2791 + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, + * 'metadata': {'vh': vh, + * 'vl1': vl1, # <<<<<<<<<<<<<< + * 'vl2': vl2, + * 'a': a, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_vl1, ((PyObject *)__pyx_v_vl1)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + + /* "cssm.pyx":2792 + * 'metadata': {'vh': vh, + * 'vl1': vl1, + * 'vl2': vl2, # <<<<<<<<<<<<<< + * 'a': a, + * 'zh': zh, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_vl2, ((PyObject *)__pyx_v_vl2)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + + /* "cssm.pyx":2793 + * 'vl1': vl1, + * 'vl2': vl2, + * 'a': a, # <<<<<<<<<<<<<< + * 'zh': zh, + * 'zl1': zl1, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + + /* "cssm.pyx":2794 + * 'vl2': vl2, + * 'a': a, + * 'zh': zh, # <<<<<<<<<<<<<< + * 'zl1': zl1, + * 'zl2': zl2, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zh, ((PyObject *)__pyx_v_zh)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + + /* "cssm.pyx":2795 + * 'a': a, + * 'zh': zh, + * 'zl1': zl1, # <<<<<<<<<<<<<< + * 'zl2': zl2, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zl1, ((PyObject *)__pyx_v_zl1)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + + /* "cssm.pyx":2796 + * 'zh': zh, + * 'zl1': zl1, + * 'zl2': zl2, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zl2, ((PyObject *)__pyx_v_zl2)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + + /* "cssm.pyx":2797 + * 'zl1': zl1, + * 'zl2': zl2, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + + /* "cssm.pyx":2798 + * 'zl2': zl2, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + + /* "cssm.pyx":2799 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 2790, __pyx_L1_error) + __pyx_t_6 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":2800 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 2800, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_6, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 2800, __pyx_L1_error) + } + + /* "cssm.pyx":2801 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2801, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_3) < (0)) __PYX_ERR(0, 2801, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":2802 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2802, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_3) < (0)) __PYX_ERR(0, 2802, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":2803 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound', +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2803, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 2803, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":2804 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2804, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 2804, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound) < (0)) __PYX_ERR(0, 2805, __pyx_L1_error) + + /* "cssm.pyx":2806 + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2806, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_3) < (0)) __PYX_ERR(0, 2806, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":2807 + * 'simulator': 'ddm_flexbound', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_3 = PyList_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2807, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 2807, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2807, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 2807, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 2807, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 2807, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":2808 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 2808, __pyx_L1_error) + + /* "cssm.pyx":2809 + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 2809, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_6) < (0)) __PYX_ERR(0, 2789, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":2788 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, + * 'metadata': {'vh': vh, +*/ + } + + /* "cssm.pyx":2810 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, + * 'metadata': {'simulator': 'ddm_flexbound', +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2810, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":2811 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, # <<<<<<<<<<<<<< + * 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [0, 1, 2, 3], +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2811, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 2811, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 2811, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 2811, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 2811, __pyx_L1_error) + + /* "cssm.pyx":2812 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, + * 'metadata': {'simulator': 'ddm_flexbound', # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_6 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2812, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound) < (0)) __PYX_ERR(0, 2812, __pyx_L1_error) + + /* "cssm.pyx":2813 + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, + * 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_3 = PyList_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2813, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 2813, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2813, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 2813, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 2813, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 2812, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":2814 + * 'metadata': {'simulator': 'ddm_flexbound', + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2814, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_3) < (0)) __PYX_ERR(0, 2812, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":2815 + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2815, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 2812, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":2816 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2816, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 2812, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_6) < (0)) __PYX_ERR(0, 2811, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":2810 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_low': rts_low, 'rts_high': rts_high, + * 'metadata': {'simulator': 'ddm_flexbound', +*/ + } + + /* "cssm.pyx":2819 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # ----------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_6 = NULL; + __pyx_t_7 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_7, (2-__pyx_t_7) | (__pyx_t_7*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 2819, __pyx_L1_error) + } + + /* "cssm.pyx":2543 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_par2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_flexbound_par2", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_rts_high); + __Pyx_XDECREF(__pyx_v_rts_low); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_high_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_low_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_9genexpr11__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":2825 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + +static PyObject *__pyx_pf_4cssm_70__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":2838 + * np.ndarray[float, ndim = 1] s_pre_high_level_choice, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2838, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":2839 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 2839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":2840 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * print_info = True, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2840, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":2841 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2841, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":2825 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_5 = PyTuple_New(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2825, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, Py_None) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, Py_None) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 10, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2825, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 2825, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_27ddm_flexbound_mic2_ornstein(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_26ddm_flexbound_mic2_ornstein, "\n Simulate (rt, choice) tuples from a DDM with flexible boundaries and Ornstein-Uhlenbeck process.\n\n Parameters:\n -----------\n vh, vl1, vl2 : np.ndarray, shape (n_trials,)\n Drift rates for high-level, low-level 1, and low-level 2 processes.\n a : np.ndarray, shape (n_trials,)\n Initial boundary separation.\n zh, zl1, zl2 : np.ndarray, shape (n_trials,)\n Starting points for high-level, low-level 1, and low-level 2 processes.\n d : np.ndarray, shape (n_trials,)\n Damping parameter (1: no drift on low level until high level done, 0: full drift on low level).\n g : np.ndarray, shape (n_trials,)\n Inhibition parameter for the low-dimensional choice process while high-dimensional is running.\n t : np.ndarray, shape (n_trials,)\n Non-decision time.\n deadline : np.ndarray, shape (n_trials,)\n Response deadline.\n s_pre_high_level_choice : np.ndarray, shape (n_trials,)\n Noise level before high-level choice is made.\n s : np.ndarray, shape (n_trials,)\n Noise level (sigma).\n delta_t : float, optional\n Size of time steps for simulation (default: 0.001).\n max_t : float, optional\n Maximum time for simulation (default: 20).\n n_samples : int, optional\n Number of samples to simulate (default: 20000).\n n_trials : int, optional\n Number of trials to simulate (default: 1).\n print_info : bool, optional\n Whether to print information during simulation (default: True).\n boundary_fun : callable, optional\n Boundary function of t and potentially other parameters (default: None).\n boundary_multiplicative : bool, optional\n Whether the boundary function is multiplicative (default: True).\n boundary_params : dict, optional\n Parameters for the boundary function (default: {}).\n random_state : int or None, optional\n Random seed for reproducibility (default: None).\n return_option : str"", optional\n Determines what to return, either 'full' or 'minimal' (default: 'full').\n smooth_unif : bool, optional\n Whether to use smooth uniform distribution for RT jitter (default: False).\n\n Returns:\n --------\n dict\n Dictionary containing simulated data and metadata. The exact contents depend on the return_option.\n "); +static PyMethodDef __pyx_mdef_4cssm_27ddm_flexbound_mic2_ornstein = {"ddm_flexbound_mic2_ornstein", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_27ddm_flexbound_mic2_ornstein, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_26ddm_flexbound_mic2_ornstein}; +static PyObject *__pyx_pw_4cssm_27ddm_flexbound_mic2_ornstein(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_vh = 0; + PyArrayObject *__pyx_v_vl1 = 0; + PyArrayObject *__pyx_v_vl2 = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_zh = 0; + PyArrayObject *__pyx_v_zl1 = 0; + PyArrayObject *__pyx_v_zl2 = 0; + PyArrayObject *__pyx_v_d = 0; + PyArrayObject *__pyx_v_g = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s_pre_high_level_choice = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + CYTHON_UNUSED PyObject *__pyx_v_print_info = 0; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[24] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_flexbound_mic2_ornstein (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_vh,&__pyx_mstate_global->__pyx_n_u_vl1,&__pyx_mstate_global->__pyx_n_u_vl2,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_zh,&__pyx_mstate_global->__pyx_n_u_zl1,&__pyx_mstate_global->__pyx_n_u_zl2,&__pyx_mstate_global->__pyx_n_u_d,&__pyx_mstate_global->__pyx_n_u_g,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s_pre_high_level_choice,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_print_info,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 2825, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 24: + values[23] = __Pyx_ArgRef_FASTCALL(__pyx_args, 23); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[23])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 23: + values[22] = __Pyx_ArgRef_FASTCALL(__pyx_args, 22); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[22])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_flexbound_mic2_ornstein", 1) < (0)) __PYX_ERR(0, 2825, __pyx_L3_error) + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":2843 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[20]) values[20] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":2846 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[22]) values[22] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[23]) values[23] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 13; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_flexbound_mic2_ornstein", 0, 13, 24, i); __PYX_ERR(0, 2825, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 24: + values[23] = __Pyx_ArgRef_FASTCALL(__pyx_args, 23); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[23])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 23: + values[22] = __Pyx_ArgRef_FASTCALL(__pyx_args, 22); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[22])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 2825, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 2825, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 2825, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":2843 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[20]) values[20] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":2846 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[22]) values[22] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[23]) values[23] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_vh = ((PyArrayObject *)values[0]); + __pyx_v_vl1 = ((PyArrayObject *)values[1]); + __pyx_v_vl2 = ((PyArrayObject *)values[2]); + __pyx_v_a = ((PyArrayObject *)values[3]); + __pyx_v_zh = ((PyArrayObject *)values[4]); + __pyx_v_zl1 = ((PyArrayObject *)values[5]); + __pyx_v_zl2 = ((PyArrayObject *)values[6]); + __pyx_v_d = ((PyArrayObject *)values[7]); + __pyx_v_g = ((PyArrayObject *)values[8]); + __pyx_v_t = ((PyArrayObject *)values[9]); + __pyx_v_deadline = ((PyArrayObject *)values[10]); + __pyx_v_s_pre_high_level_choice = ((PyArrayObject *)values[11]); + __pyx_v_s = ((PyArrayObject *)values[12]); + if (values[13]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[13]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2838, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[14]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[14]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 2839, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[15]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[15]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2840, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[16]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[16]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 2841, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_print_info = values[17]; + __pyx_v_boundary_fun = values[18]; + __pyx_v_boundary_multiplicative = values[19]; + __pyx_v_boundary_params = values[20]; + __pyx_v_random_state = values[21]; + __pyx_v_return_option = values[22]; + __pyx_v_smooth_unif = values[23]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_flexbound_mic2_ornstein", 0, 13, 24, __pyx_nargs); __PYX_ERR(0, 2825, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_flexbound_mic2_ornstein", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vh", 0))) __PYX_ERR(0, 2825, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl1", 0))) __PYX_ERR(0, 2826, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl2", 0))) __PYX_ERR(0, 2827, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 2828, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zh", 0))) __PYX_ERR(0, 2829, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl1", 0))) __PYX_ERR(0, 2830, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl2", 0))) __PYX_ERR(0, 2831, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_d), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "d", 0))) __PYX_ERR(0, 2832, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_g), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "g", 0))) __PYX_ERR(0, 2833, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 2834, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 2835, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s_pre_high_level_choice), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s_pre_high_level_choice", 0))) __PYX_ERR(0, 2836, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 2837, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_26ddm_flexbound_mic2_ornstein(__pyx_self, __pyx_v_vh, __pyx_v_vl1, __pyx_v_vl2, __pyx_v_a, __pyx_v_zh, __pyx_v_zl1, __pyx_v_zl2, __pyx_v_d, __pyx_v_g, __pyx_v_t, __pyx_v_deadline, __pyx_v_s_pre_high_level_choice, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_print_info, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":2825 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_26ddm_flexbound_mic2_ornstein(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s_pre_high_level_choice, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_vh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_d_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_g_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_pre_high_level_choice_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + PyObject *__pyx_v_rts_low = NULL; + PyObject *__pyx_v_rts_high = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_high_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_low_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_bias_trace_l1 = NULL; + PyObject *__pyx_v_bias_trace_l2 = NULL; + __Pyx_memviewslice __pyx_v_bias_trace_l1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_bias_trace_l2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y_h; + float __pyx_v_y_l; + float __pyx_v_y_l1; + float __pyx_v_y_l2; + float __pyx_v_t_h; + float __pyx_v_t_l; + float __pyx_v_t_l1; + float __pyx_v_t_l2; + CYTHON_UNUSED float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_ix1; + Py_ssize_t __pyx_v_ix2; + Py_ssize_t __pyx_v_ix_l; + Py_ssize_t __pyx_v_ix1_tmp; + Py_ssize_t __pyx_v_ix2_tmp; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_9genexpr12__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_d; + __Pyx_Buffer __pyx_pybuffer_d; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_g; + __Pyx_Buffer __pyx_pybuffer_g; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s_pre_high_level_choice; + __Pyx_Buffer __pyx_pybuffer_s_pre_high_level_choice; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vh; + __Pyx_Buffer __pyx_pybuffer_vh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl1; + __Pyx_Buffer __pyx_pybuffer_vl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl2; + __Pyx_Buffer __pyx_pybuffer_vl2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zh; + __Pyx_Buffer __pyx_pybuffer_zh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl1; + __Pyx_Buffer __pyx_pybuffer_zl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl2; + __Pyx_Buffer __pyx_pybuffer_zl2; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + Py_ssize_t __pyx_t_30; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_flexbound_mic2_ornstein", 0); + __pyx_pybuffer_vh.pybuffer.buf = NULL; + __pyx_pybuffer_vh.refcount = 0; + __pyx_pybuffernd_vh.data = NULL; + __pyx_pybuffernd_vh.rcbuffer = &__pyx_pybuffer_vh; + __pyx_pybuffer_vl1.pybuffer.buf = NULL; + __pyx_pybuffer_vl1.refcount = 0; + __pyx_pybuffernd_vl1.data = NULL; + __pyx_pybuffernd_vl1.rcbuffer = &__pyx_pybuffer_vl1; + __pyx_pybuffer_vl2.pybuffer.buf = NULL; + __pyx_pybuffer_vl2.refcount = 0; + __pyx_pybuffernd_vl2.data = NULL; + __pyx_pybuffernd_vl2.rcbuffer = &__pyx_pybuffer_vl2; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_zh.pybuffer.buf = NULL; + __pyx_pybuffer_zh.refcount = 0; + __pyx_pybuffernd_zh.data = NULL; + __pyx_pybuffernd_zh.rcbuffer = &__pyx_pybuffer_zh; + __pyx_pybuffer_zl1.pybuffer.buf = NULL; + __pyx_pybuffer_zl1.refcount = 0; + __pyx_pybuffernd_zl1.data = NULL; + __pyx_pybuffernd_zl1.rcbuffer = &__pyx_pybuffer_zl1; + __pyx_pybuffer_zl2.pybuffer.buf = NULL; + __pyx_pybuffer_zl2.refcount = 0; + __pyx_pybuffernd_zl2.data = NULL; + __pyx_pybuffernd_zl2.rcbuffer = &__pyx_pybuffer_zl2; + __pyx_pybuffer_d.pybuffer.buf = NULL; + __pyx_pybuffer_d.refcount = 0; + __pyx_pybuffernd_d.data = NULL; + __pyx_pybuffernd_d.rcbuffer = &__pyx_pybuffer_d; + __pyx_pybuffer_g.pybuffer.buf = NULL; + __pyx_pybuffer_g.refcount = 0; + __pyx_pybuffernd_g.data = NULL; + __pyx_pybuffernd_g.rcbuffer = &__pyx_pybuffer_g; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s_pre_high_level_choice.pybuffer.buf = NULL; + __pyx_pybuffer_s_pre_high_level_choice.refcount = 0; + __pyx_pybuffernd_s_pre_high_level_choice.data = NULL; + __pyx_pybuffernd_s_pre_high_level_choice.rcbuffer = &__pyx_pybuffer_s_pre_high_level_choice; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vh.rcbuffer->pybuffer, (PyObject*)__pyx_v_vh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_vh.diminfo[0].strides = __pyx_pybuffernd_vh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vh.diminfo[0].shape = __pyx_pybuffernd_vh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_vl1.diminfo[0].strides = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl1.diminfo[0].shape = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_vl2.diminfo[0].strides = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl2.diminfo[0].shape = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zh.rcbuffer->pybuffer, (PyObject*)__pyx_v_zh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_zh.diminfo[0].strides = __pyx_pybuffernd_zh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zh.diminfo[0].shape = __pyx_pybuffernd_zh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_zl1.diminfo[0].strides = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl1.diminfo[0].shape = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_zl2.diminfo[0].strides = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl2.diminfo[0].shape = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_d.rcbuffer->pybuffer, (PyObject*)__pyx_v_d, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_d.diminfo[0].strides = __pyx_pybuffernd_d.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_d.diminfo[0].shape = __pyx_pybuffernd_d.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_g.rcbuffer->pybuffer, (PyObject*)__pyx_v_g, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_g.diminfo[0].strides = __pyx_pybuffernd_g.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_g.diminfo[0].shape = __pyx_pybuffernd_g.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s_pre_high_level_choice.rcbuffer->pybuffer, (PyObject*)__pyx_v_s_pre_high_level_choice, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_s_pre_high_level_choice.diminfo[0].strides = __pyx_pybuffernd_s_pre_high_level_choice.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s_pre_high_level_choice.diminfo[0].shape = __pyx_pybuffernd_s_pre_high_level_choice.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 2825, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":2902 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:] vh_view = vh +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2902, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":2904 + * set_seed(random_state) + * # Param views + * cdef float[:] vh_view = vh # <<<<<<<<<<<<<< + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2904, __pyx_L1_error) + __pyx_v_vh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2905 + * # Param views + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 # <<<<<<<<<<<<<< + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2905, __pyx_L1_error) + __pyx_v_vl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2906 + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2906, __pyx_L1_error) + __pyx_v_vl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2907 + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2907, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2908 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh # <<<<<<<<<<<<<< + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2908, __pyx_L1_error) + __pyx_v_zh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2909 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 # <<<<<<<<<<<<<< + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2909, __pyx_L1_error) + __pyx_v_zl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2910 + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 # <<<<<<<<<<<<<< + * cdef float[:] d_view = d + * cdef float[:] g_view = g +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2910, __pyx_L1_error) + __pyx_v_zl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2911 + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d # <<<<<<<<<<<<<< + * cdef float[:] g_view = g + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_d), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2911, __pyx_L1_error) + __pyx_v_d_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2912 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d + * cdef float[:] g_view = g # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_g), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2912, __pyx_L1_error) + __pyx_v_g_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2913 + * cdef float[:] d_view = d + * cdef float[:] g_view = g + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * cdef float[:] s_pre_high_level_choice_view = s_pre_high_level_choice +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2913, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2914 + * cdef float[:] g_view = g + * cdef float[:] t_view = t + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * cdef float[:] s_pre_high_level_choice_view = s_pre_high_level_choice + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2914, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2915 + * cdef float[:] t_view = t + * cdef float[:] s_view = s + * cdef float[:] s_pre_high_level_choice_view = s_pre_high_level_choice # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s_pre_high_level_choice), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2915, __pyx_L1_error) + __pyx_v_s_pre_high_level_choice_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2916 + * cdef float[:] s_view = s + * cdef float[:] s_pre_high_level_choice_view = s_pre_high_level_choice + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2916, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2919 + * + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2919, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 2919, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2919, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2919, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2919, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2920 + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 2920, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 2920, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2920, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2920, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2921 + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 2921, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 2921, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2921, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2921, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2921, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_low = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2922 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 2922, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 2922, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 2922, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2922, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_high = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2924 + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 2924, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":2925 + * + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_high, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 2925, __pyx_L1_error) + __pyx_v_rts_high_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":2926 + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_low, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 2926, __pyx_L1_error) + __pyx_v_rts_low_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":2927 + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 2927, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":2929 + * cdef int[:, :, :] choices_view = choices + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 2929, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 2929, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2929, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2930 + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 2930, __pyx_L1_error) + + /* "cssm.pyx":2931 + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 2931, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":2933 + * cdef float[:, :] traj_view = traj + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":2937 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":2938 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_0, __pyx_t_7, __pyx_t_12}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2938, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2939 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2939, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2940 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * # Y particle trace +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2940, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2943 + * + * # Y particle trace + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) # <<<<<<<<<<<<<< + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_num_draws); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2943, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_bias_trace_l1 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2944 + * # Y particle trace + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] bias_trace_l1_view = bias_trace_l1 + * cdef float[:] bias_trace_l2_view = bias_trace_l2 +*/ + __pyx_t_12 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 2944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_num_draws); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_12, __pyx_t_4}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 2944, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2944, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_bias_trace_l2 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":2945 + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 # <<<<<<<<<<<<<< + * cdef float[:] bias_trace_l2_view = bias_trace_l2 + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_bias_trace_l1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2945, __pyx_L1_error) + __pyx_v_bias_trace_l1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2946 + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 + * cdef float[:] bias_trace_l2_view = bias_trace_l2 # <<<<<<<<<<<<<< + * + * cdef float y_h, y_l, y_l1, y_l2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_bias_trace_l2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2946, __pyx_L1_error) + __pyx_v_bias_trace_l2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2952 + * cdef float t_h, t_l, t_l1, t_l2, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, ix1, ix2, ix_l, ix_tmp, ix1_tmp, ix2_tmp, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2953 + * cdef Py_ssize_t n, ix, ix1, ix2, ix_l, ix_tmp, ix1_tmp, ix2_tmp, k + * cdef Py_ssize_t m = 0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2953, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2955 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":2957 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2957, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 2957, __pyx_L7_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2957, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_17, &__pyx_t_16, &__pyx_t_5, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 2957, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_9genexpr12__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_9genexpr12__pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 2957, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2957, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_9genexpr12__pyx_v_key, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 2957, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_9genexpr12__pyx_v_key); __pyx_9genexpr12__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_9genexpr12__pyx_v_key); __pyx_9genexpr12__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":2960 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 2960, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":2961 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_4 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 2961, __pyx_L1_error) + __pyx_t_6 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_6, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 2961, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_4, __pyx_t_22}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 2961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_3 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_12}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2961, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 2961, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":2960 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":2963 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 2963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 2963, __pyx_L1_error) + __pyx_t_5 = __pyx_t_6; + __pyx_t_6 = 0; + if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 2963, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 2963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_22, __pyx_t_6}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 2963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_7 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 2963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 2963, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":2965 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_20) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":2966 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":2968 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":2969 + * # Loop over samples + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice # <<<<<<<<<<<<<< + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) = 0; + + /* "cssm.pyx":2970 + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension # <<<<<<<<<<<<<< + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) +*/ + __pyx_v_t_h = 0.0; + + /* "cssm.pyx":2971 + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension # <<<<<<<<<<<<<< + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) +*/ + __pyx_v_t_l = 0.0; + + /* "cssm.pyx":2972 + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) # <<<<<<<<<<<<<< + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index +*/ + __pyx_v_t_l1 = 0.0; + + /* "cssm.pyx":2973 + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) +*/ + __pyx_v_t_l2 = 0.0; + + /* "cssm.pyx":2974 + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * ix1 = 0 # reset boundary index (1) + * ix2 = 0 # reset boundary index (2) +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":2975 + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) # <<<<<<<<<<<<<< + * ix2 = 0 # reset boundary index (2) + * +*/ + __pyx_v_ix1 = 0; + + /* "cssm.pyx":2976 + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) + * ix2 = 0 # reset boundary index (2) # <<<<<<<<<<<<<< + * + * # Initialize walkers +*/ + __pyx_v_ix2 = 0; + + /* "cssm.pyx":2980 + * # Initialize walkers + * # Particle + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) +*/ + __pyx_t_27 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_v_y_h = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zh_view.data + __pyx_t_21 * __pyx_v_zh_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":2982 + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) # <<<<<<<<<<<<<< + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] + * +*/ + __pyx_t_23 = 0; + __pyx_t_21 = 0; + __pyx_t_27 = 0; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":2983 + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_t_21 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) )) = (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )))); + + /* "cssm.pyx":2985 + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2986 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":2987 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y_h # <<<<<<<<<<<<<< + * + * # Random walks until y_h hits bound +*/ + __pyx_t_21 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":2986 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + } + + /* "cssm.pyx":2985 + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + } + + /* "cssm.pyx":2990 + * + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): # <<<<<<<<<<<<<< + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) +*/ + while (1) { + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_h <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L18_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":2991 + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = __pyx_v_m; + __pyx_v_y_h = (__pyx_v_y_h + (((*((float *) ( /* dim=0 */ (__pyx_v_vh_view.data + __pyx_t_23 * __pyx_v_vh_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_21 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":2992 + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] + * t_h += delta_t +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_23 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_ix; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":2993 + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] # <<<<<<<<<<<<<< + * t_h += delta_t + * ix += 1 +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_21 = __pyx_v_ix; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) )) = (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )))); + + /* "cssm.pyx":2994 + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] + * t_h += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_h = (__pyx_v_t_h + __pyx_v_delta_t); + + /* "cssm.pyx":2995 + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] + * t_h += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":2996 + * t_h += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":2997 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":2998 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 2998, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":2999 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":2997 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":3001 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3002 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3003 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y_h # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":3002 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y_h + * +*/ + } + + /* "cssm.pyx":3001 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y_h +*/ + } + } + + /* "cssm.pyx":3010 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":3011 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3011, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":3012 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":3011 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above +*/ + } + + /* "cssm.pyx":3010 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + goto __pyx_L24; + } + + /* "cssm.pyx":3014 + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3014, __pyx_L1_error) + __pyx_t_27 = __pyx_v_ix; + __pyx_t_23 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":3015 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":3014 + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + } + __pyx_L24:; + + /* "cssm.pyx":3017 + * choices_view[n, k, 0] += 2 + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * +*/ + __pyx_t_21 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_v_y_l2 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl2_view.data + __pyx_t_27 * __pyx_v_zl2_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3018 + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * + * if choices_view[n, k, 0] == 0: +*/ + __pyx_t_23 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_v_y_l1 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl1_view.data + __pyx_t_27 * __pyx_v_zl1_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3020 + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3022 + * if choices_view[n, k, 0] == 0: + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 +*/ + __pyx_v_ix1_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":3023 + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 + * while ix1_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 +*/ + while (1) { + __pyx_t_20 = (__pyx_v_ix1_tmp < __pyx_v_num_draws); + if (!__pyx_t_20) break; + + /* "cssm.pyx":3024 + * ix1_tmp = ix + 1 + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix1_tmp] = 1.0 + * ix1_tmp += 1 +*/ + __pyx_t_23 = __pyx_v_ix1_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )) = 0.0; + + /* "cssm.pyx":3025 + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 # <<<<<<<<<<<<<< + * ix1_tmp += 1 + * +*/ + __pyx_t_23 = __pyx_v_ix1_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) )) = 1.0; + + /* "cssm.pyx":3026 + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 + * ix1_tmp += 1 # <<<<<<<<<<<<<< + * + * else: # Store intermediate choice +*/ + __pyx_v_ix1_tmp = (__pyx_v_ix1_tmp + 1); + } + + /* "cssm.pyx":3020 + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 +*/ + goto __pyx_L26; + } + + /* "cssm.pyx":3030 + * else: # Store intermediate choice + * # Fill bias tracea until max_rt reached + * ix2_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 +*/ + /*else*/ { + __pyx_v_ix2_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":3031 + * # Fill bias tracea until max_rt reached + * ix2_tmp = ix + 1 + * while ix2_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 +*/ + while (1) { + __pyx_t_20 = (__pyx_v_ix2_tmp < __pyx_v_num_draws); + if (!__pyx_t_20) break; + + /* "cssm.pyx":3032 + * ix2_tmp = ix + 1 + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix2_tmp] = 0.0 + * ix2_tmp += 1 +*/ + __pyx_t_23 = __pyx_v_ix2_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )) = 1.0; + + /* "cssm.pyx":3033 + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 # <<<<<<<<<<<<<< + * ix2_tmp += 1 + * +*/ + __pyx_t_23 = __pyx_v_ix2_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) )) = 0.0; + + /* "cssm.pyx":3034 + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 + * ix2_tmp += 1 # <<<<<<<<<<<<<< + * + * # lower level random walker (1) +*/ + __pyx_v_ix2_tmp = (__pyx_v_ix2_tmp + 1); + } + } + __pyx_L26:; + + /* "cssm.pyx":3037 + * + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) ))) == 0) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":3038 + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): # <<<<<<<<<<<<<< + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) +*/ + while (1) { + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L34_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L34_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l1 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L34_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":3039 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) +*/ + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) ))) < 1.0); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L38_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) ))) > 0.0); + __pyx_t_20 = __pyx_t_28; + __pyx_L38_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":3041 + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) * s_pre_high_level_choice_view[k] +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = __pyx_v_k; + __pyx_v_y_l1 = (__pyx_v_y_l1 + (((((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_21 * __pyx_v_vl1_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_27 * __pyx_v_bias_trace_l1_view.strides[0]) )))) * (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_23 * __pyx_v_d_view.strides[0]) ))))) - ((*((float *) ( /* dim=0 */ (__pyx_v_g_view.data + __pyx_t_29 * __pyx_v_g_view.strides[0]) ))) * __pyx_v_y_l1)) * __pyx_v_delta_t)); + + /* "cssm.pyx":3043 + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) * s_pre_high_level_choice_view[k] # <<<<<<<<<<<<<< + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) +*/ + __pyx_t_29 = __pyx_v_m; + __pyx_t_23 = __pyx_v_k; + __pyx_v_y_l1 = (__pyx_v_y_l1 + ((__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_29 * __pyx_v_gaussian_values.strides[0]) )))) * (*((float *) ( /* dim=0 */ (__pyx_v_s_pre_high_level_choice_view.data + __pyx_t_23 * __pyx_v_s_pre_high_level_choice_view.strides[0]) ))))); + + /* "cssm.pyx":3039 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) +*/ + goto __pyx_L37; + } + + /* "cssm.pyx":3046 + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) + * y_l1 += (vl1_view[k] * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) +*/ + /*else*/ { + __pyx_t_23 = __pyx_v_k; + __pyx_v_y_l1 = (__pyx_v_y_l1 + ((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_23 * __pyx_v_vl1_view.strides[0]) ))) * __pyx_v_delta_t)); + + /* "cssm.pyx":3048 + * y_l1 += (vl1_view[k] * delta_t) + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_23 = __pyx_v_m; + __pyx_v_y_l1 = (__pyx_v_y_l1 + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) ))))); + } + __pyx_L37:; + + /* "cssm.pyx":3052 + * + * # propagate time and indices + * t_l1 += delta_t # <<<<<<<<<<<<<< + * ix1 += 1 + * m += 1 +*/ + __pyx_v_t_l1 = (__pyx_v_t_l1 + __pyx_v_delta_t); + + /* "cssm.pyx":3053 + * # propagate time and indices + * t_l1 += delta_t + * ix1 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix1 = (__pyx_v_ix1 + 1); + + /* "cssm.pyx":3054 + * t_l1 += delta_t + * ix1 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":3055 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":3056 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3056, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3057 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3055 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":3059 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3060 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3061 + * if n == 0: + * if k == 0: + * traj_view[ix1, 1] = y_l1 # <<<<<<<<<<<<<< + * + * # lower level random walker (2) +*/ + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_29 = 1; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_29 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l1; + + /* "cssm.pyx":3060 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + } + + /* "cssm.pyx":3059 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + } + } + + /* "cssm.pyx":3037 + * + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): +*/ + } + + /* "cssm.pyx":3064 + * + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): +*/ + __pyx_t_29 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_29 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) ))) == 2) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":3065 + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): # <<<<<<<<<<<<<< + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) +*/ + while (1) { + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L46_bool_binop_done; + } + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L46_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l2 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L46_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":3066 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) +*/ + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) ))) < 1.0); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L50_bool_binop_done; + } + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) ))) > 0.0); + __pyx_t_20 = __pyx_t_28; + __pyx_L50_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":3068 + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) * s_pre_high_level_choice_view[k] +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = __pyx_v_ix2; + __pyx_t_29 = __pyx_v_k; + __pyx_t_21 = __pyx_v_k; + __pyx_v_y_l2 = (__pyx_v_y_l2 + (((((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_27 * __pyx_v_vl2_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )))) * (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_29 * __pyx_v_d_view.strides[0]) ))))) - ((*((float *) ( /* dim=0 */ (__pyx_v_g_view.data + __pyx_t_21 * __pyx_v_g_view.strides[0]) ))) * __pyx_v_y_l2)) * __pyx_v_delta_t)); + + /* "cssm.pyx":3070 + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) * s_pre_high_level_choice_view[k] # <<<<<<<<<<<<<< + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) +*/ + __pyx_t_21 = __pyx_v_m; + __pyx_t_29 = __pyx_v_k; + __pyx_v_y_l2 = (__pyx_v_y_l2 + ((__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_21 * __pyx_v_gaussian_values.strides[0]) )))) * (*((float *) ( /* dim=0 */ (__pyx_v_s_pre_high_level_choice_view.data + __pyx_t_29 * __pyx_v_s_pre_high_level_choice_view.strides[0]) ))))); + + /* "cssm.pyx":3066 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) +*/ + goto __pyx_L49; + } + + /* "cssm.pyx":3073 + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) + * y_l2 += (vl2_view[k] * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) +*/ + /*else*/ { + __pyx_t_29 = __pyx_v_k; + __pyx_v_y_l2 = (__pyx_v_y_l2 + ((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_29 * __pyx_v_vl2_view.strides[0]) ))) * __pyx_v_delta_t)); + + /* "cssm.pyx":3075 + * y_l2 += (vl2_view[k] * delta_t) + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * + * # propagate time and indices +*/ + __pyx_t_29 = __pyx_v_m; + __pyx_v_y_l2 = (__pyx_v_y_l2 + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_29 * __pyx_v_gaussian_values.strides[0]) ))))); + } + __pyx_L49:; + + /* "cssm.pyx":3078 + * + * # propagate time and indices + * t_l2 += delta_t # <<<<<<<<<<<<<< + * ix2 += 1 + * m += 1 +*/ + __pyx_v_t_l2 = (__pyx_v_t_l2 + __pyx_v_delta_t); + + /* "cssm.pyx":3079 + * # propagate time and indices + * t_l2 += delta_t + * ix2 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix2 = (__pyx_v_ix2 + 1); + + /* "cssm.pyx":3080 + * t_l2 += delta_t + * ix2 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":3081 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":3082 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3082, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3083 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3081 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":3085 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3086 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3087 + * if n == 0: + * if k == 0: + * traj_view[ix2, 2] = y_l2 # <<<<<<<<<<<<<< + * + * # Get back to single y_l and t_l +*/ + __pyx_t_29 = __pyx_v_ix2; + __pyx_t_21 = 2; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_29 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l2; + + /* "cssm.pyx":3086 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + } + + /* "cssm.pyx":3085 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + } + } + + /* "cssm.pyx":3064 + * + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): +*/ + } + + /* "cssm.pyx":3090 + * + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3091 + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 # <<<<<<<<<<<<<< + * y_l = y_l1 + * ix_l = ix1 +*/ + __pyx_v_t_l = __pyx_v_t_l1; + + /* "cssm.pyx":3092 + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 + * y_l = y_l1 # <<<<<<<<<<<<<< + * ix_l = ix1 + * else: +*/ + __pyx_v_y_l = __pyx_v_y_l1; + + /* "cssm.pyx":3093 + * t_l = t_l1 + * y_l = y_l1 + * ix_l = ix1 # <<<<<<<<<<<<<< + * else: + * t_l = t_l2 +*/ + __pyx_v_ix_l = __pyx_v_ix1; + + /* "cssm.pyx":3090 + * + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + goto __pyx_L55; + } + + /* "cssm.pyx":3095 + * ix_l = ix1 + * else: + * t_l = t_l2 # <<<<<<<<<<<<<< + * y_l = y_l2 + * ix_l = ix2 +*/ + /*else*/ { + __pyx_v_t_l = __pyx_v_t_l2; + + /* "cssm.pyx":3096 + * else: + * t_l = t_l2 + * y_l = y_l2 # <<<<<<<<<<<<<< + * ix_l = ix2 + * +*/ + __pyx_v_y_l = __pyx_v_y_l2; + + /* "cssm.pyx":3097 + * t_l = t_l2 + * y_l = y_l2 + * ix_l = ix2 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_ix_l = __pyx_v_ix2; + } + __pyx_L55:; + + /* "cssm.pyx":3099 + * ix_l = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3099, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":3100 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_h == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":3101 + * if smooth_unif: + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3101, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":3100 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + goto __pyx_L57; + } + + /* "cssm.pyx":3102 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (fmax(__pyx_v_t_h, __pyx_v_t_l) < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":3103 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3103, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":3102 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L57; + } + + /* "cssm.pyx":3105 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L57:; + + /* "cssm.pyx":3099 + * ix_l = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L56; + } + + /* "cssm.pyx":3107 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L56:; + + /* "cssm.pyx":3109 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] # <<<<<<<<<<<<<< + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_29 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) )) = (fmax(__pyx_v_t_h, __pyx_v_t_l) + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":3110 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + * rts_high_view[n, k, 0] = t_h + t_view[k] # <<<<<<<<<<<<<< + * rts_low_view[n, k, 0] = t_l + t_view[k] + * +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_high_view.data + __pyx_t_27 * __pyx_v_rts_high_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_high_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_high_view.strides[2]) )) = (__pyx_v_t_h + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":3111 + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_low_view.data + __pyx_t_29 * __pyx_v_rts_low_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_low_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_low_view.strides[2]) )) = (__pyx_v_t_l + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":3118 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":3119 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3119, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":3120 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix_l]) / (2 * boundary_view[ix_l])): +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":3119 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + } + + /* "cssm.pyx":3118 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + goto __pyx_L58; + } + + /* "cssm.pyx":3122 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix_l]) / (2 * boundary_view[ix_l])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3122, __pyx_L1_error) + __pyx_t_21 = __pyx_v_ix_l; + __pyx_t_27 = __pyx_v_ix_l; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_l + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":3123 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix_l]) / (2 * boundary_view[ix_l])): + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":3122 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix_l]) / (2 * boundary_view[ix_l])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + } + __pyx_L58:; + + /* "cssm.pyx":3125 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_29 = __pyx_v_k; + __pyx_t_30 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_23 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_29 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_30 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":3126 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_30 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_30 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":3125 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":3128 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3128, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":3129 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, # <<<<<<<<<<<<<< + * 'metadata': {'vh': vh, + * 'vl1': vl1, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 3129, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 3129, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 3129, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 3129, __pyx_L1_error) + + /* "cssm.pyx":3130 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, # <<<<<<<<<<<<<< + * 'vl1': vl1, + * 'vl2': vl2, +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(12); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3130, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vh, ((PyObject *)__pyx_v_vh)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3131 + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, + * 'vl1': vl1, # <<<<<<<<<<<<<< + * 'vl2': vl2, + * 'a': a, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vl1, ((PyObject *)__pyx_v_vl1)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3132 + * 'metadata': {'vh': vh, + * 'vl1': vl1, + * 'vl2': vl2, # <<<<<<<<<<<<<< + * 'a': a, + * 'zh': zh, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vl2, ((PyObject *)__pyx_v_vl2)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3133 + * 'vl1': vl1, + * 'vl2': vl2, + * 'a': a, # <<<<<<<<<<<<<< + * 'zh': zh, + * 'zl1': zl1, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3134 + * 'vl2': vl2, + * 'a': a, + * 'zh': zh, # <<<<<<<<<<<<<< + * 'zl1': zl1, + * 'zl2': zl2, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zh, ((PyObject *)__pyx_v_zh)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3135 + * 'a': a, + * 'zh': zh, + * 'zl1': zl1, # <<<<<<<<<<<<<< + * 'zl2': zl2, + * 'd': d, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zl1, ((PyObject *)__pyx_v_zl1)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3136 + * 'zh': zh, + * 'zl1': zl1, + * 'zl2': zl2, # <<<<<<<<<<<<<< + * 'd': d, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zl2, ((PyObject *)__pyx_v_zl2)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3137 + * 'zl1': zl1, + * 'zl2': zl2, + * 'd': d, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_d, ((PyObject *)__pyx_v_d)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3138 + * 'zl2': zl2, + * 'd': d, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's_pre_high_level_choice': s_pre_high_level_choice, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3139 + * 'd': d, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's_pre_high_level_choice': s_pre_high_level_choice, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3140 + * 't': t, + * 'deadline': deadline, + * 's_pre_high_level_choice': s_pre_high_level_choice, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_s_pre_high_level_choice, ((PyObject *)__pyx_v_s_pre_high_level_choice)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + + /* "cssm.pyx":3141 + * 'deadline': deadline, + * 's_pre_high_level_choice': s_pre_high_level_choice, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 3130, __pyx_L1_error) + __pyx_t_12 = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":3142 + * 's_pre_high_level_choice': s_pre_high_level_choice, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 3142, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_12, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 3142, __pyx_L1_error) + } + + /* "cssm.pyx":3143 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3143, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_4) < (0)) __PYX_ERR(0, 3143, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3144 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_4) < (0)) __PYX_ERR(0, 3144, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3145 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 3145, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3146 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3146, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_4) < (0)) __PYX_ERR(0, 3146, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 3147, __pyx_L1_error) + + /* "cssm.pyx":3148 + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3148, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_4) < (0)) __PYX_ERR(0, 3148, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3149 + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3149, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 3149, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3149, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 3149, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 3149, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_4) < (0)) __PYX_ERR(0, 3149, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3150 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 3150, __pyx_L1_error) + + /* "cssm.pyx":3151 + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 3151, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 3129, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":3128 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, +*/ + } + + /* "cssm.pyx":3152 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3152, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":3153 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, # <<<<<<<<<<<<<< + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 3153, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 3153, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 3153, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 3153, __pyx_L1_error) + + /* "cssm.pyx":3154 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_12 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 3154, __pyx_L1_error) + + /* "cssm.pyx":3155 + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 3155, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3155, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 3155, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 3155, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_4) < (0)) __PYX_ERR(0, 3154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3156 + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3156, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_4) < (0)) __PYX_ERR(0, 3154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3157 + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3157, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 3154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3158 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3158, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_4) < (0)) __PYX_ERR(0, 3154, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 3153, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":3152 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', +*/ + } + + /* "cssm.pyx":3161 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * + * # Simulate (rt, choice) tuples from: DDM WITH FLEXIBLE BOUNDARIES ------------------------------------ +*/ + /*else*/ { + __pyx_t_12 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3161, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 3161, __pyx_L1_error) + } + + /* "cssm.pyx":2825 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s_pre_high_level_choice.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_flexbound_mic2_ornstein", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s_pre_high_level_choice.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_d_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_g_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_pre_high_level_choice_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __Pyx_XDECREF(__pyx_v_rts_low); + __Pyx_XDECREF(__pyx_v_rts_high); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_high_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_low_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __Pyx_XDECREF(__pyx_v_bias_trace_l1); + __Pyx_XDECREF(__pyx_v_bias_trace_l2); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_bias_trace_l1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_bias_trace_l2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_9genexpr12__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":3166 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + +static PyObject *__pyx_pf_4cssm_72__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":3177 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":3178 + * np.ndarray[float, ndim = 1] s, + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":3179 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * print_info = True, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":3180 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * print_info = True, + * boundary_fun = None, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3180, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":3166 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_5 = PyTuple_New(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, Py_None) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, Py_None) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 10, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 3166, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_29ddm_flexbound_mic2_multinoise(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_28ddm_flexbound_mic2_multinoise, "\n Simulates a multi-level decision-making process using a drift-diffusion model with flexible boundaries.\n\n Parameters:\n -----------\n vh, vl1, vl2 : np.ndarray, shape (n_trials,)\n Drift rates for high-level, low-level 1, and low-level 2 processes.\n a : np.ndarray, shape (n_trials,)\n Initial boundary separation.\n zh, zl1, zl2 : np.ndarray, shape (n_trials,)\n Starting points for high-level, low-level 1, and low-level 2 processes.\n d : np.ndarray, shape (n_trials,)\n Damping parameter (1: no drift on low level until high level done, 0: full drift on low level).\n t : np.ndarray, shape (n_trials,)\n Non-decision time.\n deadline : np.ndarray, shape (n_trials,)\n Response deadline.\n s : np.ndarray, shape (n_trials,)\n Noise level (standard deviation).\n delta_t : float, optional\n Size of time steps for simulation (default: 0.001).\n max_t : float, optional\n Maximum time for each trial (default: 20).\n n_samples : int, optional\n Number of samples to simulate (default: 20000).\n n_trials : int, optional\n Number of trials to simulate (default: 1).\n print_info : bool, optional\n Whether to print information during simulation (default: True).\n boundary_fun : callable, optional\n Function defining the decision boundary (default: None).\n boundary_multiplicative : bool, optional\n Whether the boundary function is multiplicative (default: True).\n boundary_params : dict, optional\n Parameters for the boundary function (default: {}).\n random_state : int or None, optional\n Seed for random number generator (default: None).\n return_option : str, optional\n Determines what to return, either 'full' or 'minimal' (default: 'full').\n smooth_unif : bool, optional\n Whether to use smooth uniform distribution for certain calculations (default: False).\n\n Returns:\n --------""\n dict\n A dictionary containing simulation results. The exact contents depend on the return_option:\n - 'full': Contains 'rts', 'choices', 'rts_high', 'rts_low', and detailed 'metadata'.\n - 'minimal': Contains 'rts', 'choices', 'rts_high', 'rts_low', and minimal 'metadata'.\n\n Raises:\n -------\n ValueError\n If an invalid return_option is provided.\n\n Notes:\n ------\n This function implements a complex drift-diffusion model for multi-level decision-making,\n incorporating flexible boundaries and multiple noise sources.\n "); +static PyMethodDef __pyx_mdef_4cssm_29ddm_flexbound_mic2_multinoise = {"ddm_flexbound_mic2_multinoise", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_29ddm_flexbound_mic2_multinoise, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_28ddm_flexbound_mic2_multinoise}; +static PyObject *__pyx_pw_4cssm_29ddm_flexbound_mic2_multinoise(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_vh = 0; + PyArrayObject *__pyx_v_vl1 = 0; + PyArrayObject *__pyx_v_vl2 = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_zh = 0; + PyArrayObject *__pyx_v_zl1 = 0; + PyArrayObject *__pyx_v_zl2 = 0; + PyArrayObject *__pyx_v_d = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + CYTHON_UNUSED PyObject *__pyx_v_print_info = 0; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_flexbound_mic2_multinoise (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_vh,&__pyx_mstate_global->__pyx_n_u_vl1,&__pyx_mstate_global->__pyx_n_u_vl2,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_zh,&__pyx_mstate_global->__pyx_n_u_zl1,&__pyx_mstate_global->__pyx_n_u_zl2,&__pyx_mstate_global->__pyx_n_u_d,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_print_info,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3166, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_flexbound_mic2_multinoise", 1) < (0)) __PYX_ERR(0, 3166, __pyx_L3_error) + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":3182 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[18]) values[18] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":3185 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 11; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_flexbound_mic2_multinoise", 0, 11, 22, i); __PYX_ERR(0, 3166, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 3166, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3166, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3166, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":3182 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[18]) values[18] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":3185 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_vh = ((PyArrayObject *)values[0]); + __pyx_v_vl1 = ((PyArrayObject *)values[1]); + __pyx_v_vl2 = ((PyArrayObject *)values[2]); + __pyx_v_a = ((PyArrayObject *)values[3]); + __pyx_v_zh = ((PyArrayObject *)values[4]); + __pyx_v_zl1 = ((PyArrayObject *)values[5]); + __pyx_v_zl2 = ((PyArrayObject *)values[6]); + __pyx_v_d = ((PyArrayObject *)values[7]); + __pyx_v_t = ((PyArrayObject *)values[8]); + __pyx_v_deadline = ((PyArrayObject *)values[9]); + __pyx_v_s = ((PyArrayObject *)values[10]); + if (values[11]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[11]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3177, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[12]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[12]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3178, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[13]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[13]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3179, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[14]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[14]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3180, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_print_info = values[15]; + __pyx_v_boundary_fun = values[16]; + __pyx_v_boundary_multiplicative = values[17]; + __pyx_v_boundary_params = values[18]; + __pyx_v_random_state = values[19]; + __pyx_v_return_option = values[20]; + __pyx_v_smooth_unif = values[21]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_flexbound_mic2_multinoise", 0, 11, 22, __pyx_nargs); __PYX_ERR(0, 3166, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_flexbound_mic2_multinoise", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vh", 0))) __PYX_ERR(0, 3166, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl1", 0))) __PYX_ERR(0, 3167, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl2", 0))) __PYX_ERR(0, 3168, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 3169, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zh", 0))) __PYX_ERR(0, 3170, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl1", 0))) __PYX_ERR(0, 3171, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl2", 0))) __PYX_ERR(0, 3172, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_d), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "d", 0))) __PYX_ERR(0, 3173, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 3174, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 3175, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 3176, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_28ddm_flexbound_mic2_multinoise(__pyx_self, __pyx_v_vh, __pyx_v_vl1, __pyx_v_vl2, __pyx_v_a, __pyx_v_zh, __pyx_v_zl1, __pyx_v_zl2, __pyx_v_d, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_print_info, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":3166 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_28ddm_flexbound_mic2_multinoise(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_vh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_d_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + PyObject *__pyx_v_rts_low = NULL; + PyObject *__pyx_v_rts_high = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_high_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_low_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_bias_trace_l1 = NULL; + PyObject *__pyx_v_bias_trace_l2 = NULL; + __Pyx_memviewslice __pyx_v_bias_trace_l1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_bias_trace_l2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y_h; + float __pyx_v_y_l; + float __pyx_v_y_l1; + float __pyx_v_y_l2; + float __pyx_v_t_h; + float __pyx_v_t_l; + float __pyx_v_t_l1; + float __pyx_v_t_l2; + CYTHON_UNUSED float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_ix1; + Py_ssize_t __pyx_v_ix2; + CYTHON_UNUSED Py_ssize_t __pyx_v_ix_l; + Py_ssize_t __pyx_v_ix1_tmp; + Py_ssize_t __pyx_v_ix2_tmp; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_9genexpr13__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_d; + __Pyx_Buffer __pyx_pybuffer_d; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vh; + __Pyx_Buffer __pyx_pybuffer_vh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl1; + __Pyx_Buffer __pyx_pybuffer_vl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl2; + __Pyx_Buffer __pyx_pybuffer_vl2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zh; + __Pyx_Buffer __pyx_pybuffer_zh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl1; + __Pyx_Buffer __pyx_pybuffer_zl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl2; + __Pyx_Buffer __pyx_pybuffer_zl2; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + Py_ssize_t __pyx_t_30; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_flexbound_mic2_multinoise", 0); + __pyx_pybuffer_vh.pybuffer.buf = NULL; + __pyx_pybuffer_vh.refcount = 0; + __pyx_pybuffernd_vh.data = NULL; + __pyx_pybuffernd_vh.rcbuffer = &__pyx_pybuffer_vh; + __pyx_pybuffer_vl1.pybuffer.buf = NULL; + __pyx_pybuffer_vl1.refcount = 0; + __pyx_pybuffernd_vl1.data = NULL; + __pyx_pybuffernd_vl1.rcbuffer = &__pyx_pybuffer_vl1; + __pyx_pybuffer_vl2.pybuffer.buf = NULL; + __pyx_pybuffer_vl2.refcount = 0; + __pyx_pybuffernd_vl2.data = NULL; + __pyx_pybuffernd_vl2.rcbuffer = &__pyx_pybuffer_vl2; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_zh.pybuffer.buf = NULL; + __pyx_pybuffer_zh.refcount = 0; + __pyx_pybuffernd_zh.data = NULL; + __pyx_pybuffernd_zh.rcbuffer = &__pyx_pybuffer_zh; + __pyx_pybuffer_zl1.pybuffer.buf = NULL; + __pyx_pybuffer_zl1.refcount = 0; + __pyx_pybuffernd_zl1.data = NULL; + __pyx_pybuffernd_zl1.rcbuffer = &__pyx_pybuffer_zl1; + __pyx_pybuffer_zl2.pybuffer.buf = NULL; + __pyx_pybuffer_zl2.refcount = 0; + __pyx_pybuffernd_zl2.data = NULL; + __pyx_pybuffernd_zl2.rcbuffer = &__pyx_pybuffer_zl2; + __pyx_pybuffer_d.pybuffer.buf = NULL; + __pyx_pybuffer_d.refcount = 0; + __pyx_pybuffernd_d.data = NULL; + __pyx_pybuffernd_d.rcbuffer = &__pyx_pybuffer_d; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vh.rcbuffer->pybuffer, (PyObject*)__pyx_v_vh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_vh.diminfo[0].strides = __pyx_pybuffernd_vh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vh.diminfo[0].shape = __pyx_pybuffernd_vh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_vl1.diminfo[0].strides = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl1.diminfo[0].shape = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_vl2.diminfo[0].strides = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl2.diminfo[0].shape = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zh.rcbuffer->pybuffer, (PyObject*)__pyx_v_zh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_zh.diminfo[0].strides = __pyx_pybuffernd_zh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zh.diminfo[0].shape = __pyx_pybuffernd_zh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_zl1.diminfo[0].strides = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl1.diminfo[0].shape = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_zl2.diminfo[0].strides = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl2.diminfo[0].shape = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_d.rcbuffer->pybuffer, (PyObject*)__pyx_v_d, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_d.diminfo[0].strides = __pyx_pybuffernd_d.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_d.diminfo[0].shape = __pyx_pybuffernd_d.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3166, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":3249 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:] vh_view = vh +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3249, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":3251 + * set_seed(random_state) + * # Param views + * cdef float[:] vh_view = vh # <<<<<<<<<<<<<< + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3251, __pyx_L1_error) + __pyx_v_vh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3252 + * # Param views + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 # <<<<<<<<<<<<<< + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3252, __pyx_L1_error) + __pyx_v_vl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3253 + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3253, __pyx_L1_error) + __pyx_v_vl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3254 + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3254, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3255 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh # <<<<<<<<<<<<<< + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3255, __pyx_L1_error) + __pyx_v_zh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3256 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 # <<<<<<<<<<<<<< + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3256, __pyx_L1_error) + __pyx_v_zl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3257 + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 # <<<<<<<<<<<<<< + * cdef float[:] d_view = d + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3257, __pyx_L1_error) + __pyx_v_zl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3258 + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_d), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3258, __pyx_L1_error) + __pyx_v_d_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3259 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3259, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3260 + * cdef float[:] d_view = d + * cdef float[:] t_view = t + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3260, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3261 + * cdef float[:] t_view = t + * cdef float[:] s_view = s + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3261, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3264 + * + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 3264, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 3264, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3264, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3264, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3264, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3265 + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 3265, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 3265, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3265, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3265, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3265, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3266 + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 3266, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 3266, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3266, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3266, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3266, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_low = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3267 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 3267, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 3267, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3267, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3267, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3267, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_high = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3269 + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 3269, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":3270 + * + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_high, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 3270, __pyx_L1_error) + __pyx_v_rts_high_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":3271 + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_low, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 3271, __pyx_L1_error) + __pyx_v_rts_low_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":3272 + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 3272, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":3274 + * cdef int[:, :, :] choices_view = choices + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 3274, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 3274, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3274, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3274, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3275 + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 3275, __pyx_L1_error) + + /* "cssm.pyx":3276 + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 3276, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":3278 + * cdef float[:, :] traj_view = traj + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":3282 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":3283 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_0, __pyx_t_7, __pyx_t_12}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3283, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3284 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3284, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3284, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3285 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * # Y particle trace +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3285, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3288 + * + * # Y particle trace + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) # <<<<<<<<<<<<<< + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_num_draws); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3288, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3288, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_bias_trace_l1 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3289 + * # Y particle trace + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] bias_trace_l1_view = bias_trace_l1 + * cdef float[:] bias_trace_l2_view = bias_trace_l2 +*/ + __pyx_t_12 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_num_draws); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_12, __pyx_t_4}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3289, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3289, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_bias_trace_l2 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3290 + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 # <<<<<<<<<<<<<< + * cdef float[:] bias_trace_l2_view = bias_trace_l2 + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_bias_trace_l1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3290, __pyx_L1_error) + __pyx_v_bias_trace_l1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3291 + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 + * cdef float[:] bias_trace_l2_view = bias_trace_l2 # <<<<<<<<<<<<<< + * + * cdef float y_h, y_l, y_l1, y_l2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_bias_trace_l2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3291, __pyx_L1_error) + __pyx_v_bias_trace_l2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3297 + * cdef float t_h, t_l, t_l1, t_l2, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, ix1, ix2, ix_l, ix_tmp, ix1_tmp, ix2_tmp, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3298 + * cdef Py_ssize_t n, ix, ix1, ix2, ix_l, ix_tmp, ix1_tmp, ix2_tmp, k + * cdef Py_ssize_t m = 0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3298, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3300 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":3302 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3302, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 3302, __pyx_L7_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3302, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_17, &__pyx_t_16, &__pyx_t_5, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 3302, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_9genexpr13__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_9genexpr13__pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3302, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3302, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_9genexpr13__pyx_v_key, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 3302, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_9genexpr13__pyx_v_key); __pyx_9genexpr13__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_9genexpr13__pyx_v_key); __pyx_9genexpr13__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":3305 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3305, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":3306 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_4 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 3306, __pyx_L1_error) + __pyx_t_6 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_6, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 3306, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_4, __pyx_t_22}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_3 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_12}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 3306, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":3305 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":3308 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 3308, __pyx_L1_error) + __pyx_t_5 = __pyx_t_6; + __pyx_t_6 = 0; + if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 3308, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_22, __pyx_t_6}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_7 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3308, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 3308, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":3310 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_20) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":3311 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":3313 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":3314 + * # Loop over samples + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice # <<<<<<<<<<<<<< + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) = 0; + + /* "cssm.pyx":3315 + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension # <<<<<<<<<<<<<< + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) +*/ + __pyx_v_t_h = 0.0; + + /* "cssm.pyx":3316 + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension # <<<<<<<<<<<<<< + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) +*/ + __pyx_v_t_l = 0.0; + + /* "cssm.pyx":3317 + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) # <<<<<<<<<<<<<< + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index +*/ + __pyx_v_t_l1 = 0.0; + + /* "cssm.pyx":3318 + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) +*/ + __pyx_v_t_l2 = 0.0; + + /* "cssm.pyx":3319 + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * ix1 = 0 # reset boundary index (1) + * ix2 = 0 # reset boundary index (2) +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":3320 + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) # <<<<<<<<<<<<<< + * ix2 = 0 # reset boundary index (2) + * +*/ + __pyx_v_ix1 = 0; + + /* "cssm.pyx":3321 + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) + * ix2 = 0 # reset boundary index (2) # <<<<<<<<<<<<<< + * + * # Initialize walkers +*/ + __pyx_v_ix2 = 0; + + /* "cssm.pyx":3325 + * # Initialize walkers + * # Particle + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) +*/ + __pyx_t_27 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_v_y_h = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zh_view.data + __pyx_t_21 * __pyx_v_zh_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3327 + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) # <<<<<<<<<<<<<< + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] + * +*/ + __pyx_t_23 = 0; + __pyx_t_21 = 0; + __pyx_t_27 = 0; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3328 + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_t_21 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) )) = (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )))); + + /* "cssm.pyx":3330 + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3331 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3332 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y_h # <<<<<<<<<<<<<< + * + * # Random walks until y_h hits bound +*/ + __pyx_t_21 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":3331 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + } + + /* "cssm.pyx":3330 + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + } + + /* "cssm.pyx":3335 + * + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): # <<<<<<<<<<<<<< + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) +*/ + while (1) { + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_h <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L18_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":3336 + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = __pyx_v_m; + __pyx_v_y_h = (__pyx_v_y_h + (((*((float *) ( /* dim=0 */ (__pyx_v_vh_view.data + __pyx_t_23 * __pyx_v_vh_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_21 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":3337 + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] + * t_h += delta_t +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_23 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_ix; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3338 + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] # <<<<<<<<<<<<<< + * t_h += delta_t + * ix += 1 +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_21 = __pyx_v_ix; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) )) = (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )))); + + /* "cssm.pyx":3339 + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] + * t_h += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_h = (__pyx_v_t_h + __pyx_v_delta_t); + + /* "cssm.pyx":3340 + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] + * t_h += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":3341 + * t_h += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":3342 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":3343 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3343, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3344 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3342 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":3346 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3347 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3348 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y_h # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_21 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_23 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_21 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":3347 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y_h + * +*/ + } + + /* "cssm.pyx":3346 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y_h +*/ + } + } + + /* "cssm.pyx":3355 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":3356 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3356, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":3357 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":3356 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above +*/ + } + + /* "cssm.pyx":3355 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + goto __pyx_L24; + } + + /* "cssm.pyx":3359 + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3359, __pyx_L1_error) + __pyx_t_27 = __pyx_v_ix; + __pyx_t_23 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":3360 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":3359 + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + } + __pyx_L24:; + + /* "cssm.pyx":3362 + * choices_view[n, k, 0] += 2 + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * +*/ + __pyx_t_21 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_v_y_l2 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl2_view.data + __pyx_t_27 * __pyx_v_zl2_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3363 + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * + * if choices_view[n, k, 0] == 0: +*/ + __pyx_t_23 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_v_y_l1 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl1_view.data + __pyx_t_27 * __pyx_v_zl1_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3365 + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3367 + * if choices_view[n, k, 0] == 0: + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 +*/ + __pyx_v_ix1_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":3368 + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 + * while ix1_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 +*/ + while (1) { + __pyx_t_20 = (__pyx_v_ix1_tmp < __pyx_v_num_draws); + if (!__pyx_t_20) break; + + /* "cssm.pyx":3369 + * ix1_tmp = ix + 1 + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix1_tmp] = 1.0 + * ix1_tmp += 1 +*/ + __pyx_t_23 = __pyx_v_ix1_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )) = 0.0; + + /* "cssm.pyx":3370 + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 # <<<<<<<<<<<<<< + * ix1_tmp += 1 + * +*/ + __pyx_t_23 = __pyx_v_ix1_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) )) = 1.0; + + /* "cssm.pyx":3371 + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 + * ix1_tmp += 1 # <<<<<<<<<<<<<< + * + * else: # Store intermediate choice +*/ + __pyx_v_ix1_tmp = (__pyx_v_ix1_tmp + 1); + } + + /* "cssm.pyx":3365 + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 +*/ + goto __pyx_L26; + } + + /* "cssm.pyx":3375 + * else: # Store intermediate choice + * # Fill bias tracea until max_rt reached + * ix2_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 +*/ + /*else*/ { + __pyx_v_ix2_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":3376 + * # Fill bias tracea until max_rt reached + * ix2_tmp = ix + 1 + * while ix2_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 +*/ + while (1) { + __pyx_t_20 = (__pyx_v_ix2_tmp < __pyx_v_num_draws); + if (!__pyx_t_20) break; + + /* "cssm.pyx":3377 + * ix2_tmp = ix + 1 + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix2_tmp] = 0.0 + * ix2_tmp += 1 +*/ + __pyx_t_23 = __pyx_v_ix2_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )) = 1.0; + + /* "cssm.pyx":3378 + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 # <<<<<<<<<<<<<< + * ix2_tmp += 1 + * +*/ + __pyx_t_23 = __pyx_v_ix2_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) )) = 0.0; + + /* "cssm.pyx":3379 + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 + * ix2_tmp += 1 # <<<<<<<<<<<<<< + * + * # lower level random walker (1) +*/ + __pyx_v_ix2_tmp = (__pyx_v_ix2_tmp + 1); + } + } + __pyx_L26:; + + /* "cssm.pyx":3382 + * + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) ))) == 0) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":3383 + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): # <<<<<<<<<<<<<< + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) +*/ + while (1) { + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L34_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L34_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l1 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L34_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":3384 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k]))) * delta_t) +*/ + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) ))) < 1.0); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L38_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) ))) > 0.0); + __pyx_t_20 = __pyx_t_28; + __pyx_L38_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":3386 + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k]))) * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * # we multiply by bias_trace_view to make low level variance depend on high level trace +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_23 = __pyx_v_k; + __pyx_v_y_l1 = (__pyx_v_y_l1 + ((((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_21 * __pyx_v_vl1_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_27 * __pyx_v_bias_trace_l1_view.strides[0]) )))) * (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_23 * __pyx_v_d_view.strides[0]) ))))) * __pyx_v_delta_t)); + + /* "cssm.pyx":3389 + * # add gaussian displacement + * # we multiply by bias_trace_view to make low level variance depend on high level trace + * y_l1 += (sqrt_st * gaussian_values[m]) * bias_trace_l1_view[ix1] # <<<<<<<<<<<<<< + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) +*/ + __pyx_t_23 = __pyx_v_m; + __pyx_t_27 = __pyx_v_ix1; + __pyx_v_y_l1 = (__pyx_v_y_l1 + ((__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) )))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_27 * __pyx_v_bias_trace_l1_view.strides[0]) ))))); + + /* "cssm.pyx":3384 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k]))) * delta_t) +*/ + goto __pyx_L37; + } + + /* "cssm.pyx":3392 + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) + * y_l1 += (vl1_view[k] * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) +*/ + /*else*/ { + __pyx_t_27 = __pyx_v_k; + __pyx_v_y_l1 = (__pyx_v_y_l1 + ((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_27 * __pyx_v_vl1_view.strides[0]) ))) * __pyx_v_delta_t)); + + /* "cssm.pyx":3394 + * y_l1 += (vl1_view[k] * delta_t) + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_27 = __pyx_v_m; + __pyx_v_y_l1 = (__pyx_v_y_l1 + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_27 * __pyx_v_gaussian_values.strides[0]) ))))); + } + __pyx_L37:; + + /* "cssm.pyx":3398 + * + * # propagate time and indices + * t_l1 += delta_t # <<<<<<<<<<<<<< + * ix1 += 1 + * m += 1 +*/ + __pyx_v_t_l1 = (__pyx_v_t_l1 + __pyx_v_delta_t); + + /* "cssm.pyx":3399 + * # propagate time and indices + * t_l1 += delta_t + * ix1 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix1 = (__pyx_v_ix1 + 1); + + /* "cssm.pyx":3400 + * t_l1 += delta_t + * ix1 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":3401 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":3402 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3402, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3403 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3401 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":3405 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3406 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3407 + * if n == 0: + * if k == 0: + * traj_view[ix1, 1] = y_l1 # <<<<<<<<<<<<<< + * + * # lower level random walker (2) +*/ + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_23 = 1; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l1; + + /* "cssm.pyx":3406 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + } + + /* "cssm.pyx":3405 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + } + } + + /* "cssm.pyx":3382 + * + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): +*/ + } + + /* "cssm.pyx":3410 + * + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) ))) == 2) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":3411 + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): # <<<<<<<<<<<<<< + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) +*/ + while (1) { + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L46_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L46_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l2 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L46_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":3412 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k]))) * delta_t) +*/ + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) ))) < 1.0); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L50_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) ))) > 0.0); + __pyx_t_20 = __pyx_t_28; + __pyx_L50_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":3414 + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k]))) * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * # we multiply by bias_trace_view to make low level variance depend on high level trace +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_23 = __pyx_v_k; + __pyx_v_y_l2 = (__pyx_v_y_l2 + ((((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_21 * __pyx_v_vl2_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) )))) * (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_23 * __pyx_v_d_view.strides[0]) ))))) * __pyx_v_delta_t)); + + /* "cssm.pyx":3417 + * # add gaussian displacement + * # we multiply by bias_trace_view to make low level variance depend on high level trace + * y_l2 += (sqrt_st * gaussian_values[m]) * bias_trace_l2_view[ix2] # <<<<<<<<<<<<<< + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) +*/ + __pyx_t_23 = __pyx_v_m; + __pyx_t_27 = __pyx_v_ix2; + __pyx_v_y_l2 = (__pyx_v_y_l2 + ((__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) )))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) ))))); + + /* "cssm.pyx":3412 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k]))) * delta_t) +*/ + goto __pyx_L49; + } + + /* "cssm.pyx":3420 + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) + * y_l2 += (vl2_view[k] * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) +*/ + /*else*/ { + __pyx_t_27 = __pyx_v_k; + __pyx_v_y_l2 = (__pyx_v_y_l2 + ((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_27 * __pyx_v_vl2_view.strides[0]) ))) * __pyx_v_delta_t)); + + /* "cssm.pyx":3422 + * y_l2 += (vl2_view[k] * delta_t) + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_27 = __pyx_v_m; + __pyx_v_y_l2 = (__pyx_v_y_l2 + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_27 * __pyx_v_gaussian_values.strides[0]) ))))); + } + __pyx_L49:; + + /* "cssm.pyx":3426 + * + * # propagate time and indices + * t_l2 += delta_t # <<<<<<<<<<<<<< + * ix2 += 1 + * m += 1 +*/ + __pyx_v_t_l2 = (__pyx_v_t_l2 + __pyx_v_delta_t); + + /* "cssm.pyx":3427 + * # propagate time and indices + * t_l2 += delta_t + * ix2 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix2 = (__pyx_v_ix2 + 1); + + /* "cssm.pyx":3428 + * t_l2 += delta_t + * ix2 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":3429 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":3430 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3430, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3431 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3429 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":3433 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3434 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3435 + * if n == 0: + * if k == 0: + * traj_view[ix2, 2] = y_l2 # <<<<<<<<<<<<<< + * + * # Get back to single y_l and t_l +*/ + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_23 = 2; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_27 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l2; + + /* "cssm.pyx":3434 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + } + + /* "cssm.pyx":3433 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + } + } + + /* "cssm.pyx":3410 + * + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): +*/ + } + + /* "cssm.pyx":3438 + * + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3439 + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 # <<<<<<<<<<<<<< + * y_l = y_l1 + * ix_l = ix1 +*/ + __pyx_v_t_l = __pyx_v_t_l1; + + /* "cssm.pyx":3440 + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 + * y_l = y_l1 # <<<<<<<<<<<<<< + * ix_l = ix1 + * else: +*/ + __pyx_v_y_l = __pyx_v_y_l1; + + /* "cssm.pyx":3441 + * t_l = t_l1 + * y_l = y_l1 + * ix_l = ix1 # <<<<<<<<<<<<<< + * else: + * t_l = t_l2 +*/ + __pyx_v_ix_l = __pyx_v_ix1; + + /* "cssm.pyx":3438 + * + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + goto __pyx_L55; + } + + /* "cssm.pyx":3443 + * ix_l = ix1 + * else: + * t_l = t_l2 # <<<<<<<<<<<<<< + * y_l = y_l2 + * ix_l = ix2 +*/ + /*else*/ { + __pyx_v_t_l = __pyx_v_t_l2; + + /* "cssm.pyx":3444 + * else: + * t_l = t_l2 + * y_l = y_l2 # <<<<<<<<<<<<<< + * ix_l = ix2 + * +*/ + __pyx_v_y_l = __pyx_v_y_l2; + + /* "cssm.pyx":3445 + * t_l = t_l2 + * y_l = y_l2 + * ix_l = ix2 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_ix_l = __pyx_v_ix2; + } + __pyx_L55:; + + /* "cssm.pyx":3447 + * ix_l = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3447, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":3448 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_h == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":3449 + * if smooth_unif: + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3449, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":3448 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + goto __pyx_L57; + } + + /* "cssm.pyx":3450 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (fmax(__pyx_v_t_h, __pyx_v_t_l) < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":3451 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3451, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":3450 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L57; + } + + /* "cssm.pyx":3453 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L57:; + + /* "cssm.pyx":3447 + * ix_l = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L56; + } + + /* "cssm.pyx":3455 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L56:; + + /* "cssm.pyx":3457 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] # <<<<<<<<<<<<<< + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_27 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = (fmax(__pyx_v_t_h, __pyx_v_t_l) + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_21 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":3458 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + * rts_high_view[n, k, 0] = t_h + t_view[k] # <<<<<<<<<<<<<< + * rts_low_view[n, k, 0] = t_l + t_view[k] + * +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_high_view.data + __pyx_t_29 * __pyx_v_rts_high_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_high_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_high_view.strides[2]) )) = (__pyx_v_t_h + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_21 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":3459 + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_low_view.data + __pyx_t_27 * __pyx_v_rts_low_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_low_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_low_view.strides[2]) )) = (__pyx_v_t_l + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_21 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":3466 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":3467 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3467, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":3468 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":3467 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + } + + /* "cssm.pyx":3466 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + goto __pyx_L58; + } + + /* "cssm.pyx":3470 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3470, __pyx_L1_error) + __pyx_t_23 = __pyx_v_ix; + __pyx_t_29 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_l + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_29 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":3471 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_29 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_29 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":3470 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + } + __pyx_L58:; + + /* "cssm.pyx":3473 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_30 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_21 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_27 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_30 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":3474 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_30 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_30 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":3473 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":3476 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3476, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":3477 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, # <<<<<<<<<<<<<< + * 'metadata': {'vh': vh, + * 'vl1': vl1, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3477, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 3477, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 3477, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 3477, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 3477, __pyx_L1_error) + + /* "cssm.pyx":3478 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, # <<<<<<<<<<<<<< + * 'vl1': vl1, + * 'vl2': vl2, +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3478, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vh, ((PyObject *)__pyx_v_vh)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3479 + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, + * 'vl1': vl1, # <<<<<<<<<<<<<< + * 'vl2': vl2, + * 'a': a, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vl1, ((PyObject *)__pyx_v_vl1)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3480 + * 'metadata': {'vh': vh, + * 'vl1': vl1, + * 'vl2': vl2, # <<<<<<<<<<<<<< + * 'a': a, + * 'zh': zh, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vl2, ((PyObject *)__pyx_v_vl2)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3481 + * 'vl1': vl1, + * 'vl2': vl2, + * 'a': a, # <<<<<<<<<<<<<< + * 'zh': zh, + * 'zl1': zl1, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3482 + * 'vl2': vl2, + * 'a': a, + * 'zh': zh, # <<<<<<<<<<<<<< + * 'zl1': zl1, + * 'zl2': zl2, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zh, ((PyObject *)__pyx_v_zh)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3483 + * 'a': a, + * 'zh': zh, + * 'zl1': zl1, # <<<<<<<<<<<<<< + * 'zl2': zl2, + * 'd': d, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zl1, ((PyObject *)__pyx_v_zl1)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3484 + * 'zh': zh, + * 'zl1': zl1, + * 'zl2': zl2, # <<<<<<<<<<<<<< + * 'd': d, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zl2, ((PyObject *)__pyx_v_zl2)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3485 + * 'zl1': zl1, + * 'zl2': zl2, + * 'd': d, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_d, ((PyObject *)__pyx_v_d)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3486 + * 'zl2': zl2, + * 'd': d, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3487 + * 'd': d, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + + /* "cssm.pyx":3488 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 3478, __pyx_L1_error) + __pyx_t_12 = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":3489 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 3489, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_12, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 3489, __pyx_L1_error) + } + + /* "cssm.pyx":3490 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3490, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_4) < (0)) __PYX_ERR(0, 3490, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3491 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3491, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_4) < (0)) __PYX_ERR(0, 3491, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3492 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3492, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 3492, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3493 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3493, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_4) < (0)) __PYX_ERR(0, 3493, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 3494, __pyx_L1_error) + + /* "cssm.pyx":3495 + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3495, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_4) < (0)) __PYX_ERR(0, 3495, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3496 + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3496, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 3496, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3496, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 3496, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 3496, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_4) < (0)) __PYX_ERR(0, 3496, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3497 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 3497, __pyx_L1_error) + + /* "cssm.pyx":3498 + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 3498, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 3477, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":3476 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, +*/ + } + + /* "cssm.pyx":3499 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3499, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":3500 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, # <<<<<<<<<<<<<< + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3500, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 3500, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 3500, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 3500, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 3500, __pyx_L1_error) + + /* "cssm.pyx":3501 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_12 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3501, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 3501, __pyx_L1_error) + + /* "cssm.pyx":3502 + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3502, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 3502, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3502, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 3502, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 3502, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_4) < (0)) __PYX_ERR(0, 3501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3503 + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3503, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_4) < (0)) __PYX_ERR(0, 3501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3504 + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3504, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 3501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3505 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3505, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_4) < (0)) __PYX_ERR(0, 3501, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 3500, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":3499 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', +*/ + } + + /* "cssm.pyx":3508 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # ---------------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_12 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3508, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 3508, __pyx_L1_error) + } + + /* "cssm.pyx":3166 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_flexbound_mic2_multinoise", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_d_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __Pyx_XDECREF(__pyx_v_rts_low); + __Pyx_XDECREF(__pyx_v_rts_high); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_high_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_low_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __Pyx_XDECREF(__pyx_v_bias_trace_l1); + __Pyx_XDECREF(__pyx_v_bias_trace_l2); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_bias_trace_l1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_bias_trace_l2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_9genexpr13__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":3514 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + +static PyObject *__pyx_pf_4cssm_74__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":3526 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3526, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":3527 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 3527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":3528 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * print_info = True, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3528, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":3529 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3529, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":3514 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_5 = PyTuple_New(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, Py_None) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, Py_None) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 10, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 3514, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_31ddm_flexbound_mic2_ornstein_multinoise(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_30ddm_flexbound_mic2_ornstein_multinoise, "\n Simulate reaction times and choices from a DDM with flexible boundaries and multiple noise sources.\n\n This function implements a drift diffusion model (DDM) with flexible boundaries, incorporating\n both high-dimensional and low-dimensional choice processes, and multiple noise sources.\n\n Parameters:\n -----------\n vh, vl1, vl2 : np.ndarray[float, ndim=1]\n Drift rates for high-dimensional and two low-dimensional processes.\n a : np.ndarray[float, ndim=1]\n Initial boundary separation.\n zh, zl1, zl2 : np.ndarray[float, ndim=1]\n Starting points for high-dimensional and two low-dimensional processes.\n d : np.ndarray[float, ndim=1]\n Damping parameter for low-dimensional drift.\n g : np.ndarray[float, ndim=1]\n Inhibition parameter for low-dimensional choice process.\n t : np.ndarray[float, ndim=1]\n Non-decision time.\n deadline : np.ndarray[float, ndim=1]\n Maximum allowed decision time.\n s : np.ndarray[float, ndim=1]\n Noise standard deviation.\n delta_t : float, optional\n Time step for simulation (default is 0.001).\n max_t : float, optional\n Maximum time to simulate (default is 20).\n n_samples : int, optional\n Number of samples to generate (default is 20000).\n n_trials : int, optional\n Number of trials to simulate (default is 1).\n print_info : bool, optional\n Whether to print simulation information (default is True).\n boundary_fun : callable, optional\n Function defining the decision boundary over time.\n boundary_multiplicative : bool, optional\n Whether the boundary function is multiplicative (default is True).\n boundary_params : dict, optional\n Parameters for the boundary function.\n random_state : int or None, optional\n Seed for random number generator.\n return_option : str, optional\n Determines the amount of data returned ('full' or 'minimal',"" default is 'full').\n smooth_unif : bool, optional\n Whether to use smooth uniform distribution for certain calculations (default is False).\n **kwargs : dict\n Additional keyword arguments.\n\n Returns:\n --------\n dict\n A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the 'return_option' parameter.\n\n Notes:\n ------\n This function implements a complex DDM with multiple interacting processes and flexible\n boundaries. It's designed for advanced cognitive modeling scenarios where both\n high-dimensional and low-dimensional choice processes are of interest.\n "); +static PyMethodDef __pyx_mdef_4cssm_31ddm_flexbound_mic2_ornstein_multinoise = {"ddm_flexbound_mic2_ornstein_multinoise", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_31ddm_flexbound_mic2_ornstein_multinoise, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_30ddm_flexbound_mic2_ornstein_multinoise}; +static PyObject *__pyx_pw_4cssm_31ddm_flexbound_mic2_ornstein_multinoise(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_vh = 0; + PyArrayObject *__pyx_v_vl1 = 0; + PyArrayObject *__pyx_v_vl2 = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_zh = 0; + PyArrayObject *__pyx_v_zl1 = 0; + PyArrayObject *__pyx_v_zl2 = 0; + PyArrayObject *__pyx_v_d = 0; + PyArrayObject *__pyx_v_g = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + CYTHON_UNUSED PyObject *__pyx_v_print_info = 0; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[23] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_flexbound_mic2_ornstein_multinoise (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_vh,&__pyx_mstate_global->__pyx_n_u_vl1,&__pyx_mstate_global->__pyx_n_u_vl2,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_zh,&__pyx_mstate_global->__pyx_n_u_zl1,&__pyx_mstate_global->__pyx_n_u_zl2,&__pyx_mstate_global->__pyx_n_u_d,&__pyx_mstate_global->__pyx_n_u_g,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_print_info,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3514, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 23: + values[22] = __Pyx_ArgRef_FASTCALL(__pyx_args, 22); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[22])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_flexbound_mic2_ornstein_multinoise", 1) < (0)) __PYX_ERR(0, 3514, __pyx_L3_error) + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":3531 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[19]) values[19] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":3534 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[22]) values[22] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 12; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_flexbound_mic2_ornstein_multinoise", 0, 12, 23, i); __PYX_ERR(0, 3514, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 23: + values[22] = __Pyx_ArgRef_FASTCALL(__pyx_args, 22); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[22])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 3514, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3514, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3514, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":3531 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[19]) values[19] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":3534 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[22]) values[22] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_vh = ((PyArrayObject *)values[0]); + __pyx_v_vl1 = ((PyArrayObject *)values[1]); + __pyx_v_vl2 = ((PyArrayObject *)values[2]); + __pyx_v_a = ((PyArrayObject *)values[3]); + __pyx_v_zh = ((PyArrayObject *)values[4]); + __pyx_v_zl1 = ((PyArrayObject *)values[5]); + __pyx_v_zl2 = ((PyArrayObject *)values[6]); + __pyx_v_d = ((PyArrayObject *)values[7]); + __pyx_v_g = ((PyArrayObject *)values[8]); + __pyx_v_t = ((PyArrayObject *)values[9]); + __pyx_v_deadline = ((PyArrayObject *)values[10]); + __pyx_v_s = ((PyArrayObject *)values[11]); + if (values[12]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[12]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3526, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[13]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[13]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3527, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[14]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[14]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3528, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[15]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[15]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3529, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_print_info = values[16]; + __pyx_v_boundary_fun = values[17]; + __pyx_v_boundary_multiplicative = values[18]; + __pyx_v_boundary_params = values[19]; + __pyx_v_random_state = values[20]; + __pyx_v_return_option = values[21]; + __pyx_v_smooth_unif = values[22]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_flexbound_mic2_ornstein_multinoise", 0, 12, 23, __pyx_nargs); __PYX_ERR(0, 3514, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_flexbound_mic2_ornstein_multinoise", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vh", 0))) __PYX_ERR(0, 3514, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl1", 0))) __PYX_ERR(0, 3515, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl2", 0))) __PYX_ERR(0, 3516, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 3517, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zh", 0))) __PYX_ERR(0, 3518, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl1", 0))) __PYX_ERR(0, 3519, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl2", 0))) __PYX_ERR(0, 3520, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_d), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "d", 0))) __PYX_ERR(0, 3521, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_g), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "g", 0))) __PYX_ERR(0, 3522, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 3523, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 3524, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 3525, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_30ddm_flexbound_mic2_ornstein_multinoise(__pyx_self, __pyx_v_vh, __pyx_v_vl1, __pyx_v_vl2, __pyx_v_a, __pyx_v_zh, __pyx_v_zl1, __pyx_v_zl2, __pyx_v_d, __pyx_v_g, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_print_info, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":3514 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_30ddm_flexbound_mic2_ornstein_multinoise(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_vh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_d_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_g_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + PyObject *__pyx_v_rts_low = NULL; + PyObject *__pyx_v_rts_high = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_high_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_low_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_bias_trace_l1 = NULL; + PyObject *__pyx_v_bias_trace_l2 = NULL; + __Pyx_memviewslice __pyx_v_bias_trace_l1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_bias_trace_l2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y_h; + float __pyx_v_y_l; + float __pyx_v_y_l1; + float __pyx_v_y_l2; + float __pyx_v_t_h; + float __pyx_v_t_l; + float __pyx_v_t_l1; + float __pyx_v_t_l2; + CYTHON_UNUSED float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_ix1; + Py_ssize_t __pyx_v_ix2; + CYTHON_UNUSED Py_ssize_t __pyx_v_ix_l; + Py_ssize_t __pyx_v_ix1_tmp; + Py_ssize_t __pyx_v_ix2_tmp; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_9genexpr14__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_d; + __Pyx_Buffer __pyx_pybuffer_d; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_g; + __Pyx_Buffer __pyx_pybuffer_g; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vh; + __Pyx_Buffer __pyx_pybuffer_vh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl1; + __Pyx_Buffer __pyx_pybuffer_vl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl2; + __Pyx_Buffer __pyx_pybuffer_vl2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zh; + __Pyx_Buffer __pyx_pybuffer_zh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl1; + __Pyx_Buffer __pyx_pybuffer_zl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl2; + __Pyx_Buffer __pyx_pybuffer_zl2; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + Py_ssize_t __pyx_t_30; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_flexbound_mic2_ornstein_multinoise", 0); + __pyx_pybuffer_vh.pybuffer.buf = NULL; + __pyx_pybuffer_vh.refcount = 0; + __pyx_pybuffernd_vh.data = NULL; + __pyx_pybuffernd_vh.rcbuffer = &__pyx_pybuffer_vh; + __pyx_pybuffer_vl1.pybuffer.buf = NULL; + __pyx_pybuffer_vl1.refcount = 0; + __pyx_pybuffernd_vl1.data = NULL; + __pyx_pybuffernd_vl1.rcbuffer = &__pyx_pybuffer_vl1; + __pyx_pybuffer_vl2.pybuffer.buf = NULL; + __pyx_pybuffer_vl2.refcount = 0; + __pyx_pybuffernd_vl2.data = NULL; + __pyx_pybuffernd_vl2.rcbuffer = &__pyx_pybuffer_vl2; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_zh.pybuffer.buf = NULL; + __pyx_pybuffer_zh.refcount = 0; + __pyx_pybuffernd_zh.data = NULL; + __pyx_pybuffernd_zh.rcbuffer = &__pyx_pybuffer_zh; + __pyx_pybuffer_zl1.pybuffer.buf = NULL; + __pyx_pybuffer_zl1.refcount = 0; + __pyx_pybuffernd_zl1.data = NULL; + __pyx_pybuffernd_zl1.rcbuffer = &__pyx_pybuffer_zl1; + __pyx_pybuffer_zl2.pybuffer.buf = NULL; + __pyx_pybuffer_zl2.refcount = 0; + __pyx_pybuffernd_zl2.data = NULL; + __pyx_pybuffernd_zl2.rcbuffer = &__pyx_pybuffer_zl2; + __pyx_pybuffer_d.pybuffer.buf = NULL; + __pyx_pybuffer_d.refcount = 0; + __pyx_pybuffernd_d.data = NULL; + __pyx_pybuffernd_d.rcbuffer = &__pyx_pybuffer_d; + __pyx_pybuffer_g.pybuffer.buf = NULL; + __pyx_pybuffer_g.refcount = 0; + __pyx_pybuffernd_g.data = NULL; + __pyx_pybuffernd_g.rcbuffer = &__pyx_pybuffer_g; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vh.rcbuffer->pybuffer, (PyObject*)__pyx_v_vh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_vh.diminfo[0].strides = __pyx_pybuffernd_vh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vh.diminfo[0].shape = __pyx_pybuffernd_vh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_vl1.diminfo[0].strides = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl1.diminfo[0].shape = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_vl2.diminfo[0].strides = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl2.diminfo[0].shape = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zh.rcbuffer->pybuffer, (PyObject*)__pyx_v_zh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_zh.diminfo[0].strides = __pyx_pybuffernd_zh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zh.diminfo[0].shape = __pyx_pybuffernd_zh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_zl1.diminfo[0].strides = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl1.diminfo[0].shape = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_zl2.diminfo[0].strides = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl2.diminfo[0].shape = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_d.rcbuffer->pybuffer, (PyObject*)__pyx_v_d, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_d.diminfo[0].strides = __pyx_pybuffernd_d.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_d.diminfo[0].shape = __pyx_pybuffernd_d.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_g.rcbuffer->pybuffer, (PyObject*)__pyx_v_g, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_g.diminfo[0].strides = __pyx_pybuffernd_g.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_g.diminfo[0].shape = __pyx_pybuffernd_g.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3514, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":3600 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:] vh_view = vh +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3600, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":3602 + * set_seed(random_state) + * # Param views + * cdef float[:] vh_view = vh # <<<<<<<<<<<<<< + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3602, __pyx_L1_error) + __pyx_v_vh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3603 + * # Param views + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 # <<<<<<<<<<<<<< + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3603, __pyx_L1_error) + __pyx_v_vl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3604 + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3604, __pyx_L1_error) + __pyx_v_vl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3605 + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3605, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3606 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh # <<<<<<<<<<<<<< + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3606, __pyx_L1_error) + __pyx_v_zh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3607 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 # <<<<<<<<<<<<<< + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3607, __pyx_L1_error) + __pyx_v_zl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3608 + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 # <<<<<<<<<<<<<< + * cdef float[:] d_view = d + * cdef float[:] g_view = g +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3608, __pyx_L1_error) + __pyx_v_zl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3609 + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d # <<<<<<<<<<<<<< + * cdef float[:] g_view = g + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_d), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3609, __pyx_L1_error) + __pyx_v_d_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3610 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d + * cdef float[:] g_view = g # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_g), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3610, __pyx_L1_error) + __pyx_v_g_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3611 + * cdef float[:] d_view = d + * cdef float[:] g_view = g + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3611, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3612 + * cdef float[:] g_view = g + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3612, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3613 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3613, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3615 + * cdef float[:] s_view = s + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 3615, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 3615, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3615, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3615, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3615, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3616 + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 3616, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 3616, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3616, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3616, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3616, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3617 + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 3617, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 3617, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3617, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3617, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_low = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3618 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 3618, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 3618, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3618, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3618, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_high = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3620 + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 3620, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":3621 + * + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_high, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 3621, __pyx_L1_error) + __pyx_v_rts_high_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":3622 + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_low, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 3622, __pyx_L1_error) + __pyx_v_rts_low_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":3623 + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 3623, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":3625 + * cdef int[:, :, :] choices_view = choices + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 3625, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 3625, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3625, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3625, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3626 + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 3626, __pyx_L1_error) + + /* "cssm.pyx":3627 + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 3627, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":3629 + * cdef float[:, :] traj_view = traj + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":3633 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":3634 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_0, __pyx_t_7, __pyx_t_12}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3634, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3635 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3635, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3635, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3636 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * # Y particle trace +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3636, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3639 + * + * # Y particle trace + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) # <<<<<<<<<<<<<< + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3639, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3639, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_num_draws); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3639, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3639, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3639, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3639, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3639, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_bias_trace_l1 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3640 + * # Y particle trace + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] bias_trace_l1_view = bias_trace_l1 + * cdef float[:] bias_trace_l2_view = bias_trace_l2 +*/ + __pyx_t_12 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3640, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3640, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_num_draws); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3640, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3640, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_12, __pyx_t_4}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3640, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3640, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3640, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_bias_trace_l2 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":3641 + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 # <<<<<<<<<<<<<< + * cdef float[:] bias_trace_l2_view = bias_trace_l2 + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_bias_trace_l1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3641, __pyx_L1_error) + __pyx_v_bias_trace_l1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3642 + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 + * cdef float[:] bias_trace_l2_view = bias_trace_l2 # <<<<<<<<<<<<<< + * + * cdef float y_h, y_l, y_l1, y_l2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_bias_trace_l2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3642, __pyx_L1_error) + __pyx_v_bias_trace_l2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3648 + * cdef float t_h, t_l, t_l1, t_l2, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, ix1, ix2, ix_l, ix_tmp, ix1_tmp, ix2_tmp, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3649 + * cdef Py_ssize_t n, ix, ix1, ix2, ix_l, ix_tmp, ix1_tmp, ix2_tmp, k + * cdef Py_ssize_t m = 0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3649, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3651 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":3653 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3653, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 3653, __pyx_L7_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3653, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_17, &__pyx_t_16, &__pyx_t_5, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 3653, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_9genexpr14__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_9genexpr14__pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3653, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3653, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_9genexpr14__pyx_v_key, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 3653, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_9genexpr14__pyx_v_key); __pyx_9genexpr14__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_9genexpr14__pyx_v_key); __pyx_9genexpr14__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":3656 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3656, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":3657 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_4 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 3657, __pyx_L1_error) + __pyx_t_6 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_6, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 3657, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_4, __pyx_t_22}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_3 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_12}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3657, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 3657, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":3656 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":3659 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 3659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 3659, __pyx_L1_error) + __pyx_t_5 = __pyx_t_6; + __pyx_t_6 = 0; + if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 3659, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_22, __pyx_t_6}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_7 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3659, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 3659, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":3661 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_20) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":3662 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":3664 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":3665 + * # Loop over samples + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice # <<<<<<<<<<<<<< + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) = 0; + + /* "cssm.pyx":3666 + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension # <<<<<<<<<<<<<< + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) +*/ + __pyx_v_t_h = 0.0; + + /* "cssm.pyx":3667 + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension # <<<<<<<<<<<<<< + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) +*/ + __pyx_v_t_l = 0.0; + + /* "cssm.pyx":3668 + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) # <<<<<<<<<<<<<< + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index +*/ + __pyx_v_t_l1 = 0.0; + + /* "cssm.pyx":3669 + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) +*/ + __pyx_v_t_l2 = 0.0; + + /* "cssm.pyx":3670 + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * ix1 = 0 # reset boundary index (1) + * ix2 = 0 # reset boundary index (2) +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":3671 + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) # <<<<<<<<<<<<<< + * ix2 = 0 # reset boundary index (2) + * +*/ + __pyx_v_ix1 = 0; + + /* "cssm.pyx":3672 + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) + * ix2 = 0 # reset boundary index (2) # <<<<<<<<<<<<<< + * + * # Initialize walkers +*/ + __pyx_v_ix2 = 0; + + /* "cssm.pyx":3676 + * # Initialize walkers + * # Particle + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) +*/ + __pyx_t_27 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_v_y_h = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zh_view.data + __pyx_t_21 * __pyx_v_zh_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3678 + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) # <<<<<<<<<<<<<< + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] + * +*/ + __pyx_t_23 = 0; + __pyx_t_21 = 0; + __pyx_t_27 = 0; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3679 + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_t_21 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) )) = (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )))); + + /* "cssm.pyx":3681 + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3682 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3683 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y_h # <<<<<<<<<<<<<< + * + * # Random walks until y_h hits bound +*/ + __pyx_t_21 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":3682 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + } + + /* "cssm.pyx":3681 + * bias_trace_l1_view[0] = 1.0 - bias_trace_l2_view[0] + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + } + + /* "cssm.pyx":3686 + * + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): # <<<<<<<<<<<<<< + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) +*/ + while (1) { + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_h <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L18_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":3687 + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = __pyx_v_m; + __pyx_v_y_h = (__pyx_v_y_h + (((*((float *) ( /* dim=0 */ (__pyx_v_vh_view.data + __pyx_t_23 * __pyx_v_vh_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_21 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":3688 + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] + * t_h += delta_t +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_23 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_ix; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3689 + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] # <<<<<<<<<<<<<< + * t_h += delta_t + * ix += 1 +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_21 = __pyx_v_ix; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) )) = (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )))); + + /* "cssm.pyx":3690 + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] + * t_h += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_h = (__pyx_v_t_h + __pyx_v_delta_t); + + /* "cssm.pyx":3691 + * bias_trace_l1_view[ix] = 1.0 - bias_trace_l2_view[ix] + * t_h += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":3692 + * t_h += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":3693 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":3694 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3694, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3695 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3693 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":3702 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":3703 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3703, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":3704 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":3703 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above +*/ + } + + /* "cssm.pyx":3702 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + goto __pyx_L22; + } + + /* "cssm.pyx":3706 + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3706, __pyx_L1_error) + __pyx_t_27 = __pyx_v_ix; + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":3707 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":3706 + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + } + __pyx_L22:; + + /* "cssm.pyx":3709 + * choices_view[n, k, 0] += 2 + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * +*/ + __pyx_t_23 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_v_y_l2 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl2_view.data + __pyx_t_27 * __pyx_v_zl2_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3710 + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * + * if choices_view[n, k, 0] == 0: +*/ + __pyx_t_21 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_v_y_l1 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl1_view.data + __pyx_t_27 * __pyx_v_zl1_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":3712 + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3714 + * if choices_view[n, k, 0] == 0: + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 +*/ + __pyx_v_ix1_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":3715 + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 + * while ix1_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 +*/ + while (1) { + __pyx_t_20 = (__pyx_v_ix1_tmp < __pyx_v_num_draws); + if (!__pyx_t_20) break; + + /* "cssm.pyx":3716 + * ix1_tmp = ix + 1 + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix1_tmp] = 1.0 + * ix1_tmp += 1 +*/ + __pyx_t_21 = __pyx_v_ix1_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )) = 0.0; + + /* "cssm.pyx":3717 + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 # <<<<<<<<<<<<<< + * ix1_tmp += 1 + * +*/ + __pyx_t_21 = __pyx_v_ix1_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) )) = 1.0; + + /* "cssm.pyx":3718 + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 + * ix1_tmp += 1 # <<<<<<<<<<<<<< + * + * else: # Store intermediate choice +*/ + __pyx_v_ix1_tmp = (__pyx_v_ix1_tmp + 1); + } + + /* "cssm.pyx":3712 + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # Fill bias tracea until max_rt reached + * ix1_tmp = ix + 1 +*/ + goto __pyx_L24; + } + + /* "cssm.pyx":3722 + * else: # Store intermediate choice + * # Fill bias tracea until max_rt reached + * ix2_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 +*/ + /*else*/ { + __pyx_v_ix2_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":3723 + * # Fill bias tracea until max_rt reached + * ix2_tmp = ix + 1 + * while ix2_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 +*/ + while (1) { + __pyx_t_20 = (__pyx_v_ix2_tmp < __pyx_v_num_draws); + if (!__pyx_t_20) break; + + /* "cssm.pyx":3724 + * ix2_tmp = ix + 1 + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix2_tmp] = 0.0 + * ix2_tmp += 1 +*/ + __pyx_t_21 = __pyx_v_ix2_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )) = 1.0; + + /* "cssm.pyx":3725 + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 # <<<<<<<<<<<<<< + * ix2_tmp += 1 + * +*/ + __pyx_t_21 = __pyx_v_ix2_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) )) = 0.0; + + /* "cssm.pyx":3726 + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 + * ix2_tmp += 1 # <<<<<<<<<<<<<< + * + * # lower level random walker (1) +*/ + __pyx_v_ix2_tmp = (__pyx_v_ix2_tmp + 1); + } + } + __pyx_L24:; + + /* "cssm.pyx":3729 + * + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) ))) == 0) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":3730 + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): # <<<<<<<<<<<<<< + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) +*/ + while (1) { + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L32_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L32_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l1 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L32_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":3731 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) +*/ + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) ))) < 1.0); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L36_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) ))) > 0.0); + __pyx_t_20 = __pyx_t_28; + __pyx_L36_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":3733 + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) * bias_trace_l1_view[ix1] +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = __pyx_v_k; + __pyx_v_y_l1 = (__pyx_v_y_l1 + (((((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_23 * __pyx_v_vl1_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_27 * __pyx_v_bias_trace_l1_view.strides[0]) )))) * (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_21 * __pyx_v_d_view.strides[0]) ))))) - ((*((float *) ( /* dim=0 */ (__pyx_v_g_view.data + __pyx_t_29 * __pyx_v_g_view.strides[0]) ))) * __pyx_v_y_l1)) * __pyx_v_delta_t)); + + /* "cssm.pyx":3735 + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) * bias_trace_l1_view[ix1] # <<<<<<<<<<<<<< + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) +*/ + __pyx_t_29 = __pyx_v_m; + __pyx_t_21 = __pyx_v_ix1; + __pyx_v_y_l1 = (__pyx_v_y_l1 + ((__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_29 * __pyx_v_gaussian_values.strides[0]) )))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) ))))); + + /* "cssm.pyx":3731 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) +*/ + goto __pyx_L35; + } + + /* "cssm.pyx":3738 + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) + * y_l1 += (vl1_view[k] * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) +*/ + /*else*/ { + __pyx_t_21 = __pyx_v_k; + __pyx_v_y_l1 = (__pyx_v_y_l1 + ((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_21 * __pyx_v_vl1_view.strides[0]) ))) * __pyx_v_delta_t)); + + /* "cssm.pyx":3740 + * y_l1 += (vl1_view[k] * delta_t) + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_21 = __pyx_v_m; + __pyx_v_y_l1 = (__pyx_v_y_l1 + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_21 * __pyx_v_gaussian_values.strides[0]) ))))); + } + __pyx_L35:; + + /* "cssm.pyx":3744 + * + * # propagate time and indices + * t_l1 += delta_t # <<<<<<<<<<<<<< + * ix1 += 1 + * m += 1 +*/ + __pyx_v_t_l1 = (__pyx_v_t_l1 + __pyx_v_delta_t); + + /* "cssm.pyx":3745 + * # propagate time and indices + * t_l1 += delta_t + * ix1 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix1 = (__pyx_v_ix1 + 1); + + /* "cssm.pyx":3746 + * t_l1 += delta_t + * ix1 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":3747 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":3748 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3748, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3749 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3747 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":3751 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3752 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3753 + * if n == 0: + * if k == 0: + * traj_view[ix1, 1] = y_l1 # <<<<<<<<<<<<<< + * + * # lower level random walker (2) +*/ + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_29 = 1; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_29 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l1; + + /* "cssm.pyx":3752 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + } + + /* "cssm.pyx":3751 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + } + } + + /* "cssm.pyx":3729 + * + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < 1) and (bias_trace_l1_view[ix1] > 0): +*/ + } + + /* "cssm.pyx":3756 + * + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): +*/ + __pyx_t_29 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_29 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) ))) == 2) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":3757 + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): # <<<<<<<<<<<<<< + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) +*/ + while (1) { + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L44_bool_binop_done; + } + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L44_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l2 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L44_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":3758 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) +*/ + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) ))) < 1.0); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L48_bool_binop_done; + } + __pyx_t_27 = __pyx_v_ix2; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_27 * __pyx_v_bias_trace_l2_view.strides[0]) ))) > 0.0); + __pyx_t_20 = __pyx_t_28; + __pyx_L48_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":3760 + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) * bias_trace_l2_view[ix2] +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_29 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_v_y_l2 = (__pyx_v_y_l2 + (((((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_27 * __pyx_v_vl2_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )))) * (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_29 * __pyx_v_d_view.strides[0]) ))))) - ((*((float *) ( /* dim=0 */ (__pyx_v_g_view.data + __pyx_t_23 * __pyx_v_g_view.strides[0]) ))) * __pyx_v_y_l2)) * __pyx_v_delta_t)); + + /* "cssm.pyx":3762 + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) * bias_trace_l2_view[ix2] # <<<<<<<<<<<<<< + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) +*/ + __pyx_t_23 = __pyx_v_m; + __pyx_t_29 = __pyx_v_ix2; + __pyx_v_y_l2 = (__pyx_v_y_l2 + ((__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_23 * __pyx_v_gaussian_values.strides[0]) )))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_29 * __pyx_v_bias_trace_l2_view.strides[0]) ))))); + + /* "cssm.pyx":3758 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) +*/ + goto __pyx_L47; + } + + /* "cssm.pyx":3765 + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) + * y_l2 += (vl2_view[k] * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) +*/ + /*else*/ { + __pyx_t_29 = __pyx_v_k; + __pyx_v_y_l2 = (__pyx_v_y_l2 + ((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_29 * __pyx_v_vl2_view.strides[0]) ))) * __pyx_v_delta_t)); + + /* "cssm.pyx":3767 + * y_l2 += (vl2_view[k] * delta_t) + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * + * # propagate time and indices +*/ + __pyx_t_29 = __pyx_v_m; + __pyx_v_y_l2 = (__pyx_v_y_l2 + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_29 * __pyx_v_gaussian_values.strides[0]) ))))); + } + __pyx_L47:; + + /* "cssm.pyx":3770 + * + * # propagate time and indices + * t_l2 += delta_t # <<<<<<<<<<<<<< + * ix2 += 1 + * m += 1 +*/ + __pyx_v_t_l2 = (__pyx_v_t_l2 + __pyx_v_delta_t); + + /* "cssm.pyx":3771 + * # propagate time and indices + * t_l2 += delta_t + * ix2 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix2 = (__pyx_v_ix2 + 1); + + /* "cssm.pyx":3772 + * t_l2 += delta_t + * ix2 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":3773 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":3774 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3774, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3775 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":3773 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":3777 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3778 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3779 + * if n == 0: + * if k == 0: + * traj_view[ix2, 2] = y_l2 # <<<<<<<<<<<<<< + * + * # Get back to single y_l and t_l +*/ + __pyx_t_29 = __pyx_v_ix2; + __pyx_t_23 = 2; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_29 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l2; + + /* "cssm.pyx":3778 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + } + + /* "cssm.pyx":3777 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + } + } + + /* "cssm.pyx":3756 + * + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < 1) and (bias_trace_l2_view[ix2] > 0): +*/ + } + + /* "cssm.pyx":3782 + * + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":3783 + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 # <<<<<<<<<<<<<< + * y_l = y_l1 + * ix_l = ix1 +*/ + __pyx_v_t_l = __pyx_v_t_l1; + + /* "cssm.pyx":3784 + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 + * y_l = y_l1 # <<<<<<<<<<<<<< + * ix_l = ix1 + * else: +*/ + __pyx_v_y_l = __pyx_v_y_l1; + + /* "cssm.pyx":3785 + * t_l = t_l1 + * y_l = y_l1 + * ix_l = ix1 # <<<<<<<<<<<<<< + * else: + * t_l = t_l2 +*/ + __pyx_v_ix_l = __pyx_v_ix1; + + /* "cssm.pyx":3782 + * + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + goto __pyx_L53; + } + + /* "cssm.pyx":3787 + * ix_l = ix1 + * else: + * t_l = t_l2 # <<<<<<<<<<<<<< + * y_l = y_l2 + * ix_l = ix2 +*/ + /*else*/ { + __pyx_v_t_l = __pyx_v_t_l2; + + /* "cssm.pyx":3788 + * else: + * t_l = t_l2 + * y_l = y_l2 # <<<<<<<<<<<<<< + * ix_l = ix2 + * +*/ + __pyx_v_y_l = __pyx_v_y_l2; + + /* "cssm.pyx":3789 + * t_l = t_l2 + * y_l = y_l2 + * ix_l = ix2 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_ix_l = __pyx_v_ix2; + } + __pyx_L53:; + + /* "cssm.pyx":3791 + * ix_l = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3791, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":3792 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_h == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":3793 + * if smooth_unif: + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3793, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":3792 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + goto __pyx_L55; + } + + /* "cssm.pyx":3794 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (fmax(__pyx_v_t_h, __pyx_v_t_l) < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":3795 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3795, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":3794 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L55; + } + + /* "cssm.pyx":3797 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L55:; + + /* "cssm.pyx":3791 + * ix_l = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L54; + } + + /* "cssm.pyx":3799 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L54:; + + /* "cssm.pyx":3801 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] # <<<<<<<<<<<<<< + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_29 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) )) = (fmax(__pyx_v_t_h, __pyx_v_t_l) + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_21 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":3802 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + * rts_high_view[n, k, 0] = t_h + t_view[k] # <<<<<<<<<<<<<< + * rts_low_view[n, k, 0] = t_l + t_view[k] + * +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_high_view.data + __pyx_t_27 * __pyx_v_rts_high_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_high_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_high_view.strides[2]) )) = (__pyx_v_t_h + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_21 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":3803 + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_low_view.data + __pyx_t_29 * __pyx_v_rts_low_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_low_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_low_view.strides[2]) )) = (__pyx_v_t_l + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_21 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":3810 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":3811 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3811, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":3812 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":3811 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + } + + /* "cssm.pyx":3810 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + goto __pyx_L56; + } + + /* "cssm.pyx":3814 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3814, __pyx_L1_error) + __pyx_t_23 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_l + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":3815 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":3814 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + } + __pyx_L56:; + + /* "cssm.pyx":3817 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_29 = __pyx_v_k; + __pyx_t_30 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_21 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_29 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_30 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":3818 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_30 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_30 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":3817 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":3820 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3820, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":3821 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, # <<<<<<<<<<<<<< + * 'metadata': {'vh': vh, + * 'vl1': vl1, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3821, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 3821, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 3821, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 3821, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 3821, __pyx_L1_error) + + /* "cssm.pyx":3822 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, # <<<<<<<<<<<<<< + * 'vl1': vl1, + * 'vl2': vl2, +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3822, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vh, ((PyObject *)__pyx_v_vh)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3823 + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, + * 'vl1': vl1, # <<<<<<<<<<<<<< + * 'vl2': vl2, + * 'a': a, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vl1, ((PyObject *)__pyx_v_vl1)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3824 + * 'metadata': {'vh': vh, + * 'vl1': vl1, + * 'vl2': vl2, # <<<<<<<<<<<<<< + * 'a': a, + * 'zh': zh, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vl2, ((PyObject *)__pyx_v_vl2)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3825 + * 'vl1': vl1, + * 'vl2': vl2, + * 'a': a, # <<<<<<<<<<<<<< + * 'zh': zh, + * 'zl1': zl1, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3826 + * 'vl2': vl2, + * 'a': a, + * 'zh': zh, # <<<<<<<<<<<<<< + * 'zl1': zl1, + * 'zl2': zl2, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zh, ((PyObject *)__pyx_v_zh)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3827 + * 'a': a, + * 'zh': zh, + * 'zl1': zl1, # <<<<<<<<<<<<<< + * 'zl2': zl2, + * 'd': d, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zl1, ((PyObject *)__pyx_v_zl1)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3828 + * 'zh': zh, + * 'zl1': zl1, + * 'zl2': zl2, # <<<<<<<<<<<<<< + * 'd': d, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zl2, ((PyObject *)__pyx_v_zl2)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3829 + * 'zl1': zl1, + * 'zl2': zl2, + * 'd': d, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_d, ((PyObject *)__pyx_v_d)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3830 + * 'zl2': zl2, + * 'd': d, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3831 + * 'd': d, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + + /* "cssm.pyx":3832 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 3822, __pyx_L1_error) + __pyx_t_12 = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":3833 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 3833, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_12, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 3833, __pyx_L1_error) + } + + /* "cssm.pyx":3834 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3834, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_4) < (0)) __PYX_ERR(0, 3834, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3835 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3835, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_4) < (0)) __PYX_ERR(0, 3835, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3836 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3836, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 3836, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3837 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3837, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_4) < (0)) __PYX_ERR(0, 3837, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 3838, __pyx_L1_error) + + /* "cssm.pyx":3839 + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3839, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_4) < (0)) __PYX_ERR(0, 3839, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3840 + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3840, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 3840, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3840, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 3840, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 3840, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_4) < (0)) __PYX_ERR(0, 3840, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3841 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 3841, __pyx_L1_error) + + /* "cssm.pyx":3842 + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 3842, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 3821, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":3820 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, +*/ + } + + /* "cssm.pyx":3843 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 3843, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":3844 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, # <<<<<<<<<<<<<< + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3844, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 3844, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 3844, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 3844, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 3844, __pyx_L1_error) + + /* "cssm.pyx":3845 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_12 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 3845, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 3845, __pyx_L1_error) + + /* "cssm.pyx":3846 + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3846, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 3846, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3846, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 3846, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 3846, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_4) < (0)) __PYX_ERR(0, 3845, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3847 + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3847, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_4) < (0)) __PYX_ERR(0, 3845, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3848 + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3848, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 3845, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":3849 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3849, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_4) < (0)) __PYX_ERR(0, 3845, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 3844, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":3843 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', +*/ + } + + /* "cssm.pyx":3852 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # ---------------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_12 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 3852, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 3852, __pyx_L1_error) + } + + /* "cssm.pyx":3514 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_flexbound_mic2_ornstein_multinoise", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_d_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_g_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __Pyx_XDECREF(__pyx_v_rts_low); + __Pyx_XDECREF(__pyx_v_rts_high); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_high_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_low_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __Pyx_XDECREF(__pyx_v_bias_trace_l1); + __Pyx_XDECREF(__pyx_v_bias_trace_l2); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_bias_trace_l1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_bias_trace_l2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_9genexpr14__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":3857 + * + * # Simulate (rt, choice) tuples from: Vanilla LBA Model without ndt ----------------------------- + * def lba_vanilla(np.ndarray[float, ndim = 2] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, + * np.ndarray[float, ndim = 2] z, +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_33lba_vanilla(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_32lba_vanilla, "\n Simulate reaction times and choices from a vanilla Linear Ballistic Accumulator (LBA) model.\n\n Parameters:\n -----------\n v : np.ndarray[float, ndim=2]\n Drift rate for each accumulator.\n a : np.ndarray[float, ndim=2]\n Starting point of the decision boundary.\n z : np.ndarray[float, ndim=2]\n Starting point distribution.\n deadline : np.ndarray[float, ndim=1]\n Maximum allowed decision time.\n sd : np.ndarray[float, ndim=1]\n Standard deviation of the drift rate distribution.\n t : np.ndarray[float, ndim=1]\n Non-decision time.\n nact : int, optional\n Number of accumulators (default is 3).\n n_samples : int, optional\n Number of samples to generate (default is 2000).\n n_trials : int, optional\n Number of trials to simulate (default is 1).\n max_t : float, optional\n Maximum time to simulate (default is 20).\n **kwargs : dict\n Additional keyword arguments.\n\n Returns:\n --------\n dict\n A dictionary containing:\n - 'rts': simulated reaction times\n - 'choices': simulated choices\n - 'metadata': dictionary with model parameters and simulation details\n "); +static PyMethodDef __pyx_mdef_4cssm_33lba_vanilla = {"lba_vanilla", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_33lba_vanilla, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_32lba_vanilla}; +static PyObject *__pyx_pw_4cssm_33lba_vanilla(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_sd = 0; + PyArrayObject *__pyx_v_t = 0; + int __pyx_v_nact; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + float __pyx_v_max_t; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[10] = {0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lba_vanilla (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_sd,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_nact,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_max_t,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3857, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "lba_vanilla", 1) < (0)) __PYX_ERR(0, 3857, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 6; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lba_vanilla", 0, 6, 10, i); __PYX_ERR(0, 3857, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3857, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3857, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3857, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3857, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3857, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3857, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3857, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_deadline = ((PyArrayObject *)values[3]); + __pyx_v_sd = ((PyArrayObject *)values[4]); + __pyx_v_t = ((PyArrayObject *)values[5]); + if (values[6]) { + __pyx_v_nact = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_nact == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3863, __pyx_L3_error) + } else { + __pyx_v_nact = ((int)((int)3)); + } + if (values[7]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3864, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x7D0)); + } + if (values[8]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[8]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3865, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + if (values[9]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[9]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3866, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lba_vanilla", 0, 6, 10, __pyx_nargs); __PYX_ERR(0, 3857, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.lba_vanilla", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 3857, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 3858, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 3859, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 3860, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sd), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sd", 0))) __PYX_ERR(0, 3861, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 3862, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_32lba_vanilla(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_deadline, __pyx_v_sd, __pyx_v_t, __pyx_v_nact, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_max_t, __pyx_v_kwargs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_32lba_vanilla(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_sd, PyArrayObject *__pyx_v_t, int __pyx_v_nact, int __pyx_v_n_samples, int __pyx_v_n_trials, float __pyx_v_max_t, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sd_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_zs = NULL; + PyObject *__pyx_v_vs = NULL; + PyObject *__pyx_v_x_t = NULL; + PyObject *__pyx_v_v_dict = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sd; + __Pyx_Buffer __pyx_pybuffer_sd; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_12; + int __pyx_t_13; + Py_ssize_t __pyx_t_14; + int __pyx_t_15; + int __pyx_t_16; + Py_ssize_t __pyx_t_17; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + Py_ssize_t __pyx_t_25; + int __pyx_t_26; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lba_vanilla", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_sd.pybuffer.buf = NULL; + __pyx_pybuffer_sd.refcount = 0; + __pyx_pybuffernd_sd.data = NULL; + __pyx_pybuffernd_sd.rcbuffer = &__pyx_pybuffer_sd; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3857, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_v.diminfo[1].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_v.diminfo[1].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3857, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_a.diminfo[1].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_a.diminfo[1].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3857, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_z.diminfo[1].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_z.diminfo[1].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3857, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sd.rcbuffer->pybuffer, (PyObject*)__pyx_v_sd, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3857, __pyx_L1_error) + } + __pyx_pybuffernd_sd.diminfo[0].strides = __pyx_pybuffernd_sd.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sd.diminfo[0].shape = __pyx_pybuffernd_sd.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sd.diminfo[1].strides = __pyx_pybuffernd_sd.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sd.diminfo[1].shape = __pyx_pybuffernd_sd.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3857, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":3907 + * + * # Param views + * cdef float[:, :] v_view = v # <<<<<<<<<<<<<< + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 3907, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":3908 + * # Param views + * cdef float[:, :] v_view = v + * cdef float[:, :] a_view = a # <<<<<<<<<<<<<< + * cdef float[:, :] z_view = z + * cdef float[:] t_view = t +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 3908, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":3909 + * cdef float[:, :] v_view = v + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 3909, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":3910 + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:, :] sd_view = sd +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3910, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3911 + * cdef float[:, :] z_view = z + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:, :] sd_view = sd + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 3911, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":3912 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:, :] sd_view = sd # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_sd), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 3912, __pyx_L1_error) + __pyx_v_sd_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":3914 + * cdef float[:, :] sd_view = sd + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_view = rts + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 3914, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 3914, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3914, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_8}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3914, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_v_rts = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":3915 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 3915, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":3917 + * cdef float[:, :, :] rts_view = rts + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 3917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 3917, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 3917, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 3917, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 3917, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3917, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_v_choices = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":3918 + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t n, k, i +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 3918, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":3922 + * cdef Py_ssize_t n, k, i + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * + * for n in range(n_samples): +*/ + __pyx_t_12 = __pyx_v_n_trials; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_k = __pyx_t_14; + + /* "cssm.pyx":3924 + * for k in range(n_trials): + * + * for n in range(n_samples): # <<<<<<<<<<<<<< + * zs = np.random.uniform(0, z_view[k], nact) + * +*/ + __pyx_t_15 = __pyx_v_n_samples; + __pyx_t_16 = __pyx_t_15; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":3925 + * + * for n in range(n_samples): + * zs = np.random.uniform(0, z_view[k], nact) # <<<<<<<<<<<<<< + * + * vs = np.abs(np.random.normal(v_view[k], sd_view[k])) # np.abs() to avoid negative vs +*/ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_7 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_2.data = __pyx_v_z_view.data; + __pyx_t_2.memview = __pyx_v_z_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_z_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_z_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_z_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_8 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_nact); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_mstate_global->__pyx_int_0, __pyx_t_8, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_uniform, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_zs, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":3927 + * zs = np.random.uniform(0, z_view[k], nact) + * + * vs = np.abs(np.random.normal(v_view[k], sd_view[k])) # np.abs() to avoid negative vs # <<<<<<<<<<<<<< + * + * x_t = ([a_view[k]]*nact - zs)/vs +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3927, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_abs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3927, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3927, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 3927, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = __pyx_t_18; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_2.data = __pyx_v_v_view.data; + __pyx_t_2.memview = __pyx_v_v_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_v_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_v_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_v_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_6 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 3927, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_2.data = __pyx_v_sd_view.data; + __pyx_t_2.memview = __pyx_v_sd_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_sd_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_sd_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_sd_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_19 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 3927, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_t_19}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_normal, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3927, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3927, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_vs, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":3929 + * vs = np.abs(np.random.normal(v_view[k], sd_view[k])) # np.abs() to avoid negative vs + * + * x_t = ([a_view[k]]*nact - zs)/vs # <<<<<<<<<<<<<< + * + * choices_view[n, k, 0] = np.argmin(x_t) # store choices for sample n +*/ + __pyx_t_2.data = __pyx_v_a_view.data; + __pyx_t_2.memview = __pyx_v_a_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_a_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_a_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_a_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_8 = PyList_New(1 * ((__pyx_v_nact<0) ? 0:__pyx_v_nact)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nact; __pyx_temp++) { + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_8, __pyx_temp, __pyx_t_3) != (0)) __PYX_ERR(0, 3929, __pyx_L1_error); + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Subtract(__pyx_t_8, __pyx_v_zs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_v_vs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3929, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF_SET(__pyx_v_x_t, __pyx_t_8); + __pyx_t_8 = 0; + + /* "cssm.pyx":3931 + * x_t = ([a_view[k]]*nact - zs)/vs + * + * choices_view[n, k, 0] = np.argmin(x_t) # store choices for sample n # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = np.min(x_t) + t_view[k] # store reaction time for sample n + * +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3931, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_argmin); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3931, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_x_t}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3931, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_20 = __Pyx_PyLong_As_int(__pyx_t_8); if (unlikely((__pyx_t_20 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3931, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_21 = __pyx_v_n; + __pyx_t_22 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_22 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_20; + + /* "cssm.pyx":3932 + * + * choices_view[n, k, 0] = np.argmin(x_t) # store choices for sample n + * rts_view[n, k, 0] = np.min(x_t) + t_view[k] # store reaction time for sample n # <<<<<<<<<<<<<< + * + * # If the rt exceeds the deadline, set rt to -999 +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 3932, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_min); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3932, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_x_t}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3932, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_23 = __pyx_v_k; + __pyx_t_4 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3932, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = PyNumber_Add(__pyx_t_8, __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3932, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_24 = __Pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_24 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3932, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_23 = __pyx_v_n; + __pyx_t_22 = __pyx_v_k; + __pyx_t_21 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_23 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_22 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) )) = __pyx_t_24; + + /* "cssm.pyx":3935 + * + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_22 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_25 = __pyx_v_k; + __pyx_t_26 = ((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_21 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_22 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_25 * __pyx_v_deadline_view.strides[0]) )))); + if (__pyx_t_26) { + + /* "cssm.pyx":3936 + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_25 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_22 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_25 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_22 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":3935 + * + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":3939 + * + * + * v_dict = {} # <<<<<<<<<<<<<< + * for i in range(nact): + * v_dict['v_' + str(i)] = v[:, i] +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3939, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_v_dict = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "cssm.pyx":3940 + * + * v_dict = {} + * for i in range(nact): # <<<<<<<<<<<<<< + * v_dict['v_' + str(i)] = v[:, i] + * +*/ + __pyx_t_12 = __pyx_v_nact; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_i = __pyx_t_14; + + /* "cssm.pyx":3941 + * v_dict = {} + * for i in range(nact): + * v_dict['v_' + str(i)] = v[:, i] # <<<<<<<<<<<<<< + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, +*/ + __pyx_t_5 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 3941, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 3941, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_v), __pyx_t_4); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyObject_Unicode(__pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_v_2, __pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_v_dict, __pyx_t_4, __pyx_t_5) < 0))) __PYX_ERR(0, 3941, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + + /* "cssm.pyx":3943 + * v_dict['v_' + str(i)] = v[:, i] + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 3943, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 3943, __pyx_L1_error) + __pyx_t_4 = PyDict_Copy(__pyx_v_v_dict); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3943, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":3944 + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 3944, __pyx_L1_error) + + /* "cssm.pyx":3945 + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 'sd': sd, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 3945, __pyx_L1_error) + + /* "cssm.pyx":3946 + * 'a': a, + * 'z': z, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 'sd': sd, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 3946, __pyx_L1_error) + + /* "cssm.pyx":3947 + * 'z': z, + * 'deadline': deadline, + * 'sd': sd, # <<<<<<<<<<<<<< + * 't': t, + * 'n_samples': n_samples, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_sd, ((PyObject *)__pyx_v_sd)) < (0)) __PYX_ERR(0, 3947, __pyx_L1_error) + + /* "cssm.pyx":3948 + * 'deadline': deadline, + * 'sd': sd, + * 't': t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'simulator' : 'lba_vanilla', +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 3948, __pyx_L1_error) + + /* "cssm.pyx":3949 + * 'sd': sd, + * 't': t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'simulator' : 'lba_vanilla', + * 'possible_choices': list(np.arange(0, nact, 1)), +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3949, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_8) < (0)) __PYX_ERR(0, 3949, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_lba_vanilla) < (0)) __PYX_ERR(0, 3950, __pyx_L1_error) + + /* "cssm.pyx":3951 + * 'n_samples': n_samples, + * 'simulator' : 'lba_vanilla', + * 'possible_choices': list(np.arange(0, nact, 1)), # <<<<<<<<<<<<<< + * 'max_t': max_t, + * }} +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 3951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 3951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_t_18 = __Pyx_PyLong_From_int(__pyx_v_nact); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 3951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_19))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_19); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_19); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_19, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_3, __pyx_mstate_global->__pyx_int_0, __pyx_t_18, __pyx_mstate_global->__pyx_int_1}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_19, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 3951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_19 = __Pyx_PySequence_ListKeepNew(__pyx_t_8); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 3951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_19) < (0)) __PYX_ERR(0, 3951, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + /* "cssm.pyx":3952 + * 'simulator' : 'lba_vanilla', + * 'possible_choices': list(np.arange(0, nact, 1)), + * 'max_t': max_t, # <<<<<<<<<<<<<< + * }} + * +*/ + __pyx_t_19 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 3952, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_19) < (0)) __PYX_ERR(0, 3952, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_4) < (0)) __PYX_ERR(0, 3943, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "cssm.pyx":3857 + * + * # Simulate (rt, choice) tuples from: Vanilla LBA Model without ndt ----------------------------- + * def lba_vanilla(np.ndarray[float, ndim = 2] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, + * np.ndarray[float, ndim = 2] z, +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sd.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.lba_vanilla", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sd.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sd_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_zs); + __Pyx_XDECREF(__pyx_v_vs); + __Pyx_XDECREF(__pyx_v_x_t); + __Pyx_XDECREF(__pyx_v_v_dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":3958 + * + * # Simulate (rt, choice) tuples from: Collapsing bound angle LBA Model ----------------------------- + * def lba_angle(np.ndarray[float, ndim = 2] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, + * np.ndarray[float, ndim = 2] z, +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_35lba_angle(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_34lba_angle, "\n Simulate reaction times and choices from a Linear Ballistic Accumulator (LBA) model with collapsing bounds.\n\n Parameters:\n -----------\n v : np.ndarray[float, ndim=2]\n Drift rate for each accumulator.\n a : np.ndarray[float, ndim=2]\n Starting point of the decision boundary.\n z : np.ndarray[float, ndim=2]\n Starting point distribution.\n theta : np.ndarray[float, ndim=2]\n Angle parameter for the collapsing bound.\n deadline : np.ndarray[float, ndim=1]\n Maximum allowed decision time.\n sd : np.ndarray[float, ndim=1]\n Standard deviation of the drift rate distribution.\n t : np.ndarray[float, ndim=1]\n Non-decision time.\n nact : int, optional\n Number of accumulators (default is 3).\n n_samples : int, optional\n Number of samples to generate (default is 2000).\n n_trials : int, optional\n Number of trials to simulate (default is 1).\n max_t : float, optional\n Maximum time to simulate (default is 20).\n\n Returns:\n --------\n dict\n A dictionary containing:\n - 'rts': simulated reaction times\n - 'choices': simulated choices\n - 'metadata': additional information about the simulation\n "); +static PyMethodDef __pyx_mdef_4cssm_35lba_angle = {"lba_angle", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_35lba_angle, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_34lba_angle}; +static PyObject *__pyx_pw_4cssm_35lba_angle(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_theta = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_sd = 0; + PyArrayObject *__pyx_v_t = 0; + int __pyx_v_nact; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + float __pyx_v_max_t; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[11] = {0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("lba_angle (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_theta,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_sd,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_nact,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_max_t,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 3958, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "lba_angle", 1) < (0)) __PYX_ERR(0, 3958, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 7; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("lba_angle", 0, 7, 11, i); __PYX_ERR(0, 3958, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 3958, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 3958, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 3958, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 3958, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 3958, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 3958, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 3958, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 3958, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_z = ((PyArrayObject *)values[2]); + __pyx_v_theta = ((PyArrayObject *)values[3]); + __pyx_v_deadline = ((PyArrayObject *)values[4]); + __pyx_v_sd = ((PyArrayObject *)values[5]); + __pyx_v_t = ((PyArrayObject *)values[6]); + if (values[7]) { + __pyx_v_nact = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_nact == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3965, __pyx_L3_error) + } else { + __pyx_v_nact = ((int)((int)3)); + } + if (values[8]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[8]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3966, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x7D0)); + } + if (values[9]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 3967, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + if (values[10]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[10]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 3968, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("lba_angle", 0, 7, 11, __pyx_nargs); __PYX_ERR(0, 3958, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.lba_angle", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 3958, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 3959, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 3960, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_theta), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "theta", 0))) __PYX_ERR(0, 3961, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 3962, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sd), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sd", 0))) __PYX_ERR(0, 3963, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 3964, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_34lba_angle(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_z, __pyx_v_theta, __pyx_v_deadline, __pyx_v_sd, __pyx_v_t, __pyx_v_nact, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_max_t, __pyx_v_kwargs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_34lba_angle(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_theta, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_sd, PyArrayObject *__pyx_v_t, int __pyx_v_nact, int __pyx_v_n_samples, int __pyx_v_n_trials, float __pyx_v_max_t, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_theta_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sd_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_zs = NULL; + PyObject *__pyx_v_vs = NULL; + PyObject *__pyx_v_x_t = NULL; + PyObject *__pyx_v_v_dict = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sd; + __Pyx_Buffer __pyx_pybuffer_sd; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_theta; + __Pyx_Buffer __pyx_pybuffer_theta; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_12; + int __pyx_t_13; + Py_ssize_t __pyx_t_14; + int __pyx_t_15; + int __pyx_t_16; + Py_ssize_t __pyx_t_17; + PyObject *__pyx_t_18 = NULL; + PyObject *__pyx_t_19 = NULL; + Py_ssize_t __pyx_t_20; + Py_ssize_t __pyx_t_21; + int __pyx_t_22; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + Py_ssize_t __pyx_t_25; + int __pyx_t_26; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("lba_angle", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_theta.pybuffer.buf = NULL; + __pyx_pybuffer_theta.refcount = 0; + __pyx_pybuffernd_theta.data = NULL; + __pyx_pybuffernd_theta.rcbuffer = &__pyx_pybuffer_theta; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_sd.pybuffer.buf = NULL; + __pyx_pybuffer_sd.refcount = 0; + __pyx_pybuffernd_sd.data = NULL; + __pyx_pybuffernd_sd.rcbuffer = &__pyx_pybuffer_sd; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3958, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_v.diminfo[1].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_v.diminfo[1].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3958, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_a.diminfo[1].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_a.diminfo[1].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3958, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_z.diminfo[1].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_z.diminfo[1].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_theta.rcbuffer->pybuffer, (PyObject*)__pyx_v_theta, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3958, __pyx_L1_error) + } + __pyx_pybuffernd_theta.diminfo[0].strides = __pyx_pybuffernd_theta.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_theta.diminfo[0].shape = __pyx_pybuffernd_theta.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_theta.diminfo[1].strides = __pyx_pybuffernd_theta.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_theta.diminfo[1].shape = __pyx_pybuffernd_theta.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3958, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sd.rcbuffer->pybuffer, (PyObject*)__pyx_v_sd, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3958, __pyx_L1_error) + } + __pyx_pybuffernd_sd.diminfo[0].strides = __pyx_pybuffernd_sd.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sd.diminfo[0].shape = __pyx_pybuffernd_sd.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sd.diminfo[1].strides = __pyx_pybuffernd_sd.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sd.diminfo[1].shape = __pyx_pybuffernd_sd.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 3958, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":4009 + * + * # Param views + * cdef float[:, :] v_view = v # <<<<<<<<<<<<<< + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4009, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4010 + * # Param views + * cdef float[:, :] v_view = v + * cdef float[:, :] a_view = a # <<<<<<<<<<<<<< + * cdef float[:, :] z_view = z + * cdef float[:, :] theta_view = theta +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4010, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4011 + * cdef float[:, :] v_view = v + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z # <<<<<<<<<<<<<< + * cdef float[:, :] theta_view = theta + * cdef float[:] t_view = t +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4011, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4012 + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z + * cdef float[:, :] theta_view = theta # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_theta), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4012, __pyx_L1_error) + __pyx_v_theta_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4013 + * cdef float[:, :] z_view = z + * cdef float[:, :] theta_view = theta + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4013, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4015 + * cdef float[:] t_view = t + * + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:, :] sd_view = sd + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4015, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4016 + * + * cdef float[:] deadline_view = deadline + * cdef float[:, :] sd_view = sd # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_sd), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4016, __pyx_L1_error) + __pyx_v_sd_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4018 + * cdef float[:, :] sd_view = sd + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_view = rts + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 4018, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 4018, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4018, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_8}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4018, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4018, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_v_rts = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":4019 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 4019, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":4021 + * cdef float[:, :, :] rts_view = rts + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 4021, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 4021, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4021, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4021, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4021, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_v_choices = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":4022 + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t n, k, i +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 4022, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":4026 + * cdef Py_ssize_t n, k, i + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * for n in range(n_samples): + * zs = np.random.uniform(0, z_view[k], nact) +*/ + __pyx_t_12 = __pyx_v_n_trials; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_k = __pyx_t_14; + + /* "cssm.pyx":4027 + * + * for k in range(n_trials): + * for n in range(n_samples): # <<<<<<<<<<<<<< + * zs = np.random.uniform(0, z_view[k], nact) + * +*/ + __pyx_t_15 = __pyx_v_n_samples; + __pyx_t_16 = __pyx_t_15; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":4028 + * for k in range(n_trials): + * for n in range(n_samples): + * zs = np.random.uniform(0, z_view[k], nact) # <<<<<<<<<<<<<< + * + * vs = np.abs(np.random.normal(v_view[k], sd_view[k])) # np.abs() to avoid negative vs +*/ + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_7 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_2.data = __pyx_v_z_view.data; + __pyx_t_2.memview = __pyx_v_z_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_z_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_z_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_z_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_8 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_nact); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_mstate_global->__pyx_int_0, __pyx_t_8, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_uniform, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_zs, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":4030 + * zs = np.random.uniform(0, z_view[k], nact) + * + * vs = np.abs(np.random.normal(v_view[k], sd_view[k])) # np.abs() to avoid negative vs # <<<<<<<<<<<<<< + * x_t = ([a_view[k]]*nact - zs)/(vs + np.tan(theta_view[k, 0])) + * +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_abs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_7 = __pyx_t_18; + __Pyx_INCREF(__pyx_t_7); + __pyx_t_2.data = __pyx_v_v_view.data; + __pyx_t_2.memview = __pyx_v_v_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_v_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_v_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_v_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_6 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_2.data = __pyx_v_sd_view.data; + __pyx_t_2.memview = __pyx_v_sd_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_sd_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_sd_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_sd_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_19 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_6, __pyx_t_19}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_normal, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_4}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_vs, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":4031 + * + * vs = np.abs(np.random.normal(v_view[k], sd_view[k])) # np.abs() to avoid negative vs + * x_t = ([a_view[k]]*nact - zs)/(vs + np.tan(theta_view[k, 0])) # <<<<<<<<<<<<<< + * + * choices_view[n, k, 0] = np.argmin(x_t) # store choices for sample n +*/ + __pyx_t_2.data = __pyx_v_a_view.data; + __pyx_t_2.memview = __pyx_v_a_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_a_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_a_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_a_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_8 = PyList_New(1 * ((__pyx_v_nact<0) ? 0:__pyx_v_nact)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nact; __pyx_temp++) { + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_8, __pyx_temp, __pyx_t_3) != (0)) __PYX_ERR(0, 4031, __pyx_L1_error); + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Subtract(__pyx_t_8, __pyx_v_zs); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_tan); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_5 = PyFloat_FromDouble((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_theta_view.data + __pyx_t_20 * __pyx_v_theta_view.strides[0]) ) + __pyx_t_21 * __pyx_v_theta_view.strides[1]) )))); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_18))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_18); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_18, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_18, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_18 = PyNumber_Add(__pyx_v_vs, __pyx_t_8); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyNumber_Divide(__pyx_t_3, __pyx_t_18); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4031, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_XDECREF_SET(__pyx_v_x_t, __pyx_t_8); + __pyx_t_8 = 0; + + /* "cssm.pyx":4033 + * x_t = ([a_view[k]]*nact - zs)/(vs + np.tan(theta_view[k, 0])) + * + * choices_view[n, k, 0] = np.argmin(x_t) # store choices for sample n # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = np.min(x_t) + t_view[k] # store reaction time for sample n + * +*/ + __pyx_t_18 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4033, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_argmin); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4033, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_18); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_18); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_18, __pyx_v_x_t}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4033, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_22 = __Pyx_PyLong_As_int(__pyx_t_8); if (unlikely((__pyx_t_22 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4033, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_21 = __pyx_v_n; + __pyx_t_20 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_20 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_22; + + /* "cssm.pyx":4034 + * + * choices_view[n, k, 0] = np.argmin(x_t) # store choices for sample n + * rts_view[n, k, 0] = np.min(x_t) + t_view[k] # store reaction time for sample n # <<<<<<<<<<<<<< + * + * # If the rt exceeds the deadline, set rt to -999 +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4034, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_18, __pyx_mstate_global->__pyx_n_u_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4034, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_v_x_t}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4034, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_23 = __pyx_v_k; + __pyx_t_3 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4034, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyNumber_Add(__pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4034, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_24 = __Pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_24 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4034, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_23 = __pyx_v_n; + __pyx_t_20 = __pyx_v_k; + __pyx_t_21 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_23 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_20 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) )) = __pyx_t_24; + + /* "cssm.pyx":4037 + * + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_20 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_25 = __pyx_v_k; + __pyx_t_26 = ((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_21 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_20 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_25 * __pyx_v_deadline_view.strides[0]) )))); + if (__pyx_t_26) { + + /* "cssm.pyx":4038 + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * # if np.min(x_t) <= 0: +*/ + __pyx_t_25 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_20 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_25 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_20 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":4037 + * + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":4043 + * # print("\n ssms sim error: ", a[k], zs, vs, np.tan(theta[k])) + * + * v_dict = {} # <<<<<<<<<<<<<< + * for i in range(nact): + * v_dict['v_' + str(i)] = v[:, i] +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4043, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_v_v_dict = ((PyObject*)__pyx_t_5); + __pyx_t_5 = 0; + + /* "cssm.pyx":4044 + * + * v_dict = {} + * for i in range(nact): # <<<<<<<<<<<<<< + * v_dict['v_' + str(i)] = v[:, i] + * +*/ + __pyx_t_12 = __pyx_v_nact; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_i = __pyx_t_14; + + /* "cssm.pyx":4045 + * v_dict = {} + * for i in range(nact): + * v_dict['v_' + str(i)] = v[:, i] # <<<<<<<<<<<<<< + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, +*/ + __pyx_t_5 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 4045, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 4045, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_v), __pyx_t_3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_Unicode(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_v_2, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4045, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_v_dict, __pyx_t_3, __pyx_t_5) < 0))) __PYX_ERR(0, 4045, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + + /* "cssm.pyx":4047 + * v_dict['v_' + str(i)] = v[:, i] + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4047, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4047, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4047, __pyx_L1_error) + __pyx_t_3 = PyDict_Copy(__pyx_v_v_dict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4047, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":4048 + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 'theta': theta, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 4048, __pyx_L1_error) + + /* "cssm.pyx":4049 + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 'theta': theta, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 4049, __pyx_L1_error) + + /* "cssm.pyx":4050 + * 'a': a, + * 'z': z, + * 'theta': theta, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 'sd': sd, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_theta, ((PyObject *)__pyx_v_theta)) < (0)) __PYX_ERR(0, 4050, __pyx_L1_error) + + /* "cssm.pyx":4051 + * 'z': z, + * 'theta': theta, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 'sd': sd, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 4051, __pyx_L1_error) + + /* "cssm.pyx":4052 + * 'theta': theta, + * 'deadline': deadline, + * 'sd': sd, # <<<<<<<<<<<<<< + * 't': t, + * 'n_samples': n_samples, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sd, ((PyObject *)__pyx_v_sd)) < (0)) __PYX_ERR(0, 4052, __pyx_L1_error) + + /* "cssm.pyx":4053 + * 'deadline': deadline, + * 'sd': sd, + * 't': t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'simulator' : 'lba_angle', +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 4053, __pyx_L1_error) + + /* "cssm.pyx":4054 + * 'sd': sd, + * 't': t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'simulator' : 'lba_angle', + * 'possible_choices': list(np.arange(0, nact, 1)), +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4054, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_8) < (0)) __PYX_ERR(0, 4054, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_lba_angle) < (0)) __PYX_ERR(0, 4055, __pyx_L1_error) + + /* "cssm.pyx":4056 + * 'n_samples': n_samples, + * 'simulator' : 'lba_angle', + * 'possible_choices': list(np.arange(0, nact, 1)), # <<<<<<<<<<<<<< + * 'max_t': max_t, + * }} +*/ + __pyx_t_18 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_19 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_nact); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_19))) { + __pyx_t_18 = PyMethod_GET_SELF(__pyx_t_19); + assert(__pyx_t_18); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_19); + __Pyx_INCREF(__pyx_t_18); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_19, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_18, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_mstate_global->__pyx_int_1}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_19, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_19 = __Pyx_PySequence_ListKeepNew(__pyx_t_8); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_19) < (0)) __PYX_ERR(0, 4056, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + + /* "cssm.pyx":4057 + * 'simulator' : 'lba_angle', + * 'possible_choices': list(np.arange(0, nact, 1)), + * 'max_t': max_t, # <<<<<<<<<<<<<< + * }} + * +*/ + __pyx_t_19 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_19)) __PYX_ERR(0, 4057, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_19); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_19) < (0)) __PYX_ERR(0, 4057, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_19); __pyx_t_19 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_3) < (0)) __PYX_ERR(0, 4047, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "cssm.pyx":3958 + * + * # Simulate (rt, choice) tuples from: Collapsing bound angle LBA Model ----------------------------- + * def lba_angle(np.ndarray[float, ndim = 2] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, + * np.ndarray[float, ndim = 2] z, +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_19); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sd.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_theta.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.lba_angle", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sd.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_theta.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_theta_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sd_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_zs); + __Pyx_XDECREF(__pyx_v_vs); + __Pyx_XDECREF(__pyx_v_x_t); + __Pyx_XDECREF(__pyx_v_v_dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":4062 + * + * # Simulate (rt, choice) tuples from LBA piece-wise model ----------------------------- + * def rlwm_lba_pw_v1(np.ndarray[float, ndim = 2] v_RL, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] v_WM, + * np.ndarray[float, ndim = 2] a, +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_37rlwm_lba_pw_v1(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +static PyMethodDef __pyx_mdef_4cssm_37rlwm_lba_pw_v1 = {"rlwm_lba_pw_v1", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_37rlwm_lba_pw_v1, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}; +static PyObject *__pyx_pw_4cssm_37rlwm_lba_pw_v1(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v_RL = 0; + PyArrayObject *__pyx_v_v_WM = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_t_WM = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_sd = 0; + PyArrayObject *__pyx_v_t = 0; + int __pyx_v_nact; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + float __pyx_v_max_t; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[12] = {0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("rlwm_lba_pw_v1 (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v_RL,&__pyx_mstate_global->__pyx_n_u_v_WM,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_t_WM,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_sd,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_nact,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_max_t,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4062, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "rlwm_lba_pw_v1", 1) < (0)) __PYX_ERR(0, 4062, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 8; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("rlwm_lba_pw_v1", 0, 8, 12, i); __PYX_ERR(0, 4062, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4062, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4062, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4062, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4062, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4062, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4062, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4062, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4062, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4062, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_v_RL = ((PyArrayObject *)values[0]); + __pyx_v_v_WM = ((PyArrayObject *)values[1]); + __pyx_v_a = ((PyArrayObject *)values[2]); + __pyx_v_z = ((PyArrayObject *)values[3]); + __pyx_v_t_WM = ((PyArrayObject *)values[4]); + __pyx_v_deadline = ((PyArrayObject *)values[5]); + __pyx_v_sd = ((PyArrayObject *)values[6]); + __pyx_v_t = ((PyArrayObject *)values[7]); + if (values[8]) { + __pyx_v_nact = __Pyx_PyLong_As_int(values[8]); if (unlikely((__pyx_v_nact == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4070, __pyx_L3_error) + } else { + __pyx_v_nact = ((int)((int)3)); + } + if (values[9]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4071, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x7D0)); + } + if (values[10]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[10]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4072, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + if (values[11]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[11]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4073, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("rlwm_lba_pw_v1", 0, 8, 12, __pyx_nargs); __PYX_ERR(0, 4062, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.rlwm_lba_pw_v1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v_RL), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v_RL", 0))) __PYX_ERR(0, 4062, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v_WM), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v_WM", 0))) __PYX_ERR(0, 4063, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 4064, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 4065, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t_WM), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t_WM", 0))) __PYX_ERR(0, 4066, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 4067, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sd), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sd", 0))) __PYX_ERR(0, 4068, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 4069, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_36rlwm_lba_pw_v1(__pyx_self, __pyx_v_v_RL, __pyx_v_v_WM, __pyx_v_a, __pyx_v_z, __pyx_v_t_WM, __pyx_v_deadline, __pyx_v_sd, __pyx_v_t, __pyx_v_nact, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_max_t, __pyx_v_kwargs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_36rlwm_lba_pw_v1(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v_RL, PyArrayObject *__pyx_v_v_WM, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_t_WM, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_sd, PyArrayObject *__pyx_v_t, int __pyx_v_nact, int __pyx_v_n_samples, int __pyx_v_n_trials, float __pyx_v_max_t, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_RL_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_v_WM_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_WM_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sd_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyArrayObject *__pyx_v_zs = 0; + PyArrayObject *__pyx_v_x_t_RL = 0; + PyArrayObject *__pyx_v_vs_RL = 0; + PyArrayObject *__pyx_v_vs_WM = 0; + PyObject *__pyx_v_rts = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_x_t = NULL; + PyObject *__pyx_v_v_dict = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sd; + __Pyx_Buffer __pyx_pybuffer_sd; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t_WM; + __Pyx_Buffer __pyx_pybuffer_t_WM; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v_RL; + __Pyx_Buffer __pyx_pybuffer_v_RL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v_WM; + __Pyx_Buffer __pyx_pybuffer_v_WM; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vs_RL; + __Pyx_Buffer __pyx_pybuffer_vs_RL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vs_WM; + __Pyx_Buffer __pyx_pybuffer_vs_WM; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x_t_RL; + __Pyx_Buffer __pyx_pybuffer_x_t_RL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zs; + __Pyx_Buffer __pyx_pybuffer_zs; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_12; + int __pyx_t_13; + Py_ssize_t __pyx_t_14; + int __pyx_t_15; + int __pyx_t_16; + Py_ssize_t __pyx_t_17; + PyObject *__pyx_t_18 = NULL; + int __pyx_t_19; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + PyObject *__pyx_t_23 = NULL; + int __pyx_t_24; + Py_ssize_t __pyx_t_25; + Py_ssize_t __pyx_t_26; + Py_ssize_t __pyx_t_27; + float __pyx_t_28; + Py_ssize_t __pyx_t_29; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("rlwm_lba_pw_v1", 0); + __pyx_pybuffer_zs.pybuffer.buf = NULL; + __pyx_pybuffer_zs.refcount = 0; + __pyx_pybuffernd_zs.data = NULL; + __pyx_pybuffernd_zs.rcbuffer = &__pyx_pybuffer_zs; + __pyx_pybuffer_x_t_RL.pybuffer.buf = NULL; + __pyx_pybuffer_x_t_RL.refcount = 0; + __pyx_pybuffernd_x_t_RL.data = NULL; + __pyx_pybuffernd_x_t_RL.rcbuffer = &__pyx_pybuffer_x_t_RL; + __pyx_pybuffer_vs_RL.pybuffer.buf = NULL; + __pyx_pybuffer_vs_RL.refcount = 0; + __pyx_pybuffernd_vs_RL.data = NULL; + __pyx_pybuffernd_vs_RL.rcbuffer = &__pyx_pybuffer_vs_RL; + __pyx_pybuffer_vs_WM.pybuffer.buf = NULL; + __pyx_pybuffer_vs_WM.refcount = 0; + __pyx_pybuffernd_vs_WM.data = NULL; + __pyx_pybuffernd_vs_WM.rcbuffer = &__pyx_pybuffer_vs_WM; + __pyx_pybuffer_v_RL.pybuffer.buf = NULL; + __pyx_pybuffer_v_RL.refcount = 0; + __pyx_pybuffernd_v_RL.data = NULL; + __pyx_pybuffernd_v_RL.rcbuffer = &__pyx_pybuffer_v_RL; + __pyx_pybuffer_v_WM.pybuffer.buf = NULL; + __pyx_pybuffer_v_WM.refcount = 0; + __pyx_pybuffernd_v_WM.data = NULL; + __pyx_pybuffernd_v_WM.rcbuffer = &__pyx_pybuffer_v_WM; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_t_WM.pybuffer.buf = NULL; + __pyx_pybuffer_t_WM.refcount = 0; + __pyx_pybuffernd_t_WM.data = NULL; + __pyx_pybuffernd_t_WM.rcbuffer = &__pyx_pybuffer_t_WM; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_sd.pybuffer.buf = NULL; + __pyx_pybuffer_sd.refcount = 0; + __pyx_pybuffernd_sd.data = NULL; + __pyx_pybuffernd_sd.rcbuffer = &__pyx_pybuffer_sd; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v_RL.rcbuffer->pybuffer, (PyObject*)__pyx_v_v_RL, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4062, __pyx_L1_error) + } + __pyx_pybuffernd_v_RL.diminfo[0].strides = __pyx_pybuffernd_v_RL.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v_RL.diminfo[0].shape = __pyx_pybuffernd_v_RL.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_v_RL.diminfo[1].strides = __pyx_pybuffernd_v_RL.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_v_RL.diminfo[1].shape = __pyx_pybuffernd_v_RL.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v_WM.rcbuffer->pybuffer, (PyObject*)__pyx_v_v_WM, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4062, __pyx_L1_error) + } + __pyx_pybuffernd_v_WM.diminfo[0].strides = __pyx_pybuffernd_v_WM.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v_WM.diminfo[0].shape = __pyx_pybuffernd_v_WM.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_v_WM.diminfo[1].strides = __pyx_pybuffernd_v_WM.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_v_WM.diminfo[1].shape = __pyx_pybuffernd_v_WM.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4062, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_a.diminfo[1].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_a.diminfo[1].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4062, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_z.diminfo[1].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_z.diminfo[1].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t_WM.rcbuffer->pybuffer, (PyObject*)__pyx_v_t_WM, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4062, __pyx_L1_error) + } + __pyx_pybuffernd_t_WM.diminfo[0].strides = __pyx_pybuffernd_t_WM.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t_WM.diminfo[0].shape = __pyx_pybuffernd_t_WM.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_t_WM.diminfo[1].strides = __pyx_pybuffernd_t_WM.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_t_WM.diminfo[1].shape = __pyx_pybuffernd_t_WM.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4062, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sd.rcbuffer->pybuffer, (PyObject*)__pyx_v_sd, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4062, __pyx_L1_error) + } + __pyx_pybuffernd_sd.diminfo[0].strides = __pyx_pybuffernd_sd.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sd.diminfo[0].shape = __pyx_pybuffernd_sd.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sd.diminfo[1].strides = __pyx_pybuffernd_sd.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sd.diminfo[1].shape = __pyx_pybuffernd_sd.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4062, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":4078 + * + * # Param views + * cdef float[:, :] v_RL_view = v_RL # <<<<<<<<<<<<<< + * cdef float[:, :] v_WM_view = v_WM + * cdef float[:, :] a_view = a +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_v_RL), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4078, __pyx_L1_error) + __pyx_v_v_RL_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4079 + * # Param views + * cdef float[:, :] v_RL_view = v_RL + * cdef float[:, :] v_WM_view = v_WM # <<<<<<<<<<<<<< + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_v_WM), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4079, __pyx_L1_error) + __pyx_v_v_WM_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4080 + * cdef float[:, :] v_RL_view = v_RL + * cdef float[:, :] v_WM_view = v_WM + * cdef float[:, :] a_view = a # <<<<<<<<<<<<<< + * cdef float[:, :] z_view = z + * cdef float[:, :] t_WM_view = t_WM +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4080, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4081 + * cdef float[:, :] v_WM_view = v_WM + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z # <<<<<<<<<<<<<< + * cdef float[:, :] t_WM_view = t_WM + * cdef float[:] t_view = t +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4081, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4082 + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z + * cdef float[:, :] t_WM_view = t_WM # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_t_WM), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4082, __pyx_L1_error) + __pyx_v_t_WM_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4083 + * cdef float[:, :] z_view = z + * cdef float[:, :] t_WM_view = t_WM + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4083, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4085 + * cdef float[:] t_view = t + * + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:, :] sd_view = sd + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4085, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4086 + * + * cdef float[:] deadline_view = deadline + * cdef float[:, :] sd_view = sd # <<<<<<<<<<<<<< + * + * cdef np.ndarray[float, ndim = 1] zs +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_sd), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4086, __pyx_L1_error) + __pyx_v_sd_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4094 + * cdef np.ndarray[double, ndim = 1] vs_WM + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_view = rts + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 4094, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 4094, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4094, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_8}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4094, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4094, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_v_rts = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":4095 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 4095, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":4097 + * cdef float[:, :, :] rts_view = rts + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 4097, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 4097, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4097, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4097, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4097, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_v_choices = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":4098 + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t n, k, i +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 4098, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":4102 + * cdef Py_ssize_t n, k, i + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * + * for n in range(n_samples): +*/ + __pyx_t_12 = __pyx_v_n_trials; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_k = __pyx_t_14; + + /* "cssm.pyx":4104 + * for k in range(n_trials): + * + * for n in range(n_samples): # <<<<<<<<<<<<<< + * zs = np.random.uniform(0, z_view[k], nact).astype(DTYPE) + * +*/ + __pyx_t_15 = __pyx_v_n_samples; + __pyx_t_16 = __pyx_t_15; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":4105 + * + * for n in range(n_samples): + * zs = np.random.uniform(0, z_view[k], nact).astype(DTYPE) # <<<<<<<<<<<<<< + * + * vs_RL = np.abs(np.random.normal(v_RL_view[k], sd_view[k])) # np.abs() to avoid negative vs +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_2.data = __pyx_v_z_view.data; + __pyx_t_2.memview = __pyx_v_z_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_z_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_z_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_z_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_4 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_18 = __Pyx_PyLong_From_int(__pyx_v_nact); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_t_18}; + __pyx_t_8 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_uniform, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_7 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4105, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4105, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zs.rcbuffer->pybuffer); + __pyx_t_19 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zs.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_3), &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_19 < 0)) { + PyErr_Fetch(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zs.rcbuffer->pybuffer, (PyObject*)__pyx_v_zs, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_20); Py_XDECREF(__pyx_t_21); Py_XDECREF(__pyx_t_22); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_20, __pyx_t_21, __pyx_t_22); + } + __pyx_t_20 = __pyx_t_21 = __pyx_t_22 = 0; + } + __pyx_pybuffernd_zs.diminfo[0].strides = __pyx_pybuffernd_zs.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zs.diminfo[0].shape = __pyx_pybuffernd_zs.rcbuffer->pybuffer.shape[0]; + if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4105, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_zs, ((PyArrayObject *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "cssm.pyx":4107 + * zs = np.random.uniform(0, z_view[k], nact).astype(DTYPE) + * + * vs_RL = np.abs(np.random.normal(v_RL_view[k], sd_view[k])) # np.abs() to avoid negative vs # <<<<<<<<<<<<<< + * vs_WM = np.abs(np.random.normal(v_WM_view[k], sd_view[k])) # np.abs() to avoid negative vs + * +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_abs); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_18 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_18); + __pyx_t_2.data = __pyx_v_v_RL_view.data; + __pyx_t_2.memview = __pyx_v_v_RL_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_v_RL_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_v_RL_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_v_RL_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_4 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_2.data = __pyx_v_sd_view.data; + __pyx_t_2.memview = __pyx_v_sd_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_sd_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_sd_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_sd_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_23 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_18, __pyx_t_4, __pyx_t_23}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_normal, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4107, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4107, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer); + __pyx_t_19 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_3), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_19 < 0)) { + PyErr_Fetch(&__pyx_t_22, &__pyx_t_21, &__pyx_t_20); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer, (PyObject*)__pyx_v_vs_RL, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_22); Py_XDECREF(__pyx_t_21); Py_XDECREF(__pyx_t_20); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_22, __pyx_t_21, __pyx_t_20); + } + __pyx_t_22 = __pyx_t_21 = __pyx_t_20 = 0; + } + __pyx_pybuffernd_vs_RL.diminfo[0].strides = __pyx_pybuffernd_vs_RL.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vs_RL.diminfo[0].shape = __pyx_pybuffernd_vs_RL.rcbuffer->pybuffer.shape[0]; + if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4107, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_vs_RL, ((PyArrayObject *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "cssm.pyx":4108 + * + * vs_RL = np.abs(np.random.normal(v_RL_view[k], sd_view[k])) # np.abs() to avoid negative vs + * vs_WM = np.abs(np.random.normal(v_WM_view[k], sd_view[k])) # np.abs() to avoid negative vs # <<<<<<<<<<<<<< + * + * x_t_RL = ([a_view[k]]*nact - zs)/vs_RL +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_abs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_2.data = __pyx_v_v_WM_view.data; + __pyx_t_2.memview = __pyx_v_v_WM_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_v_WM_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_v_WM_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_v_WM_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_23 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_2.data = __pyx_v_sd_view.data; + __pyx_t_2.memview = __pyx_v_sd_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_sd_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_sd_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_sd_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_18 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_23, __pyx_t_18}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_normal, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4108, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4108, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer); + __pyx_t_19 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_3), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_19 < 0)) { + PyErr_Fetch(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer, (PyObject*)__pyx_v_vs_WM, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_20); Py_XDECREF(__pyx_t_21); Py_XDECREF(__pyx_t_22); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_20, __pyx_t_21, __pyx_t_22); + } + __pyx_t_20 = __pyx_t_21 = __pyx_t_22 = 0; + } + __pyx_pybuffernd_vs_WM.diminfo[0].strides = __pyx_pybuffernd_vs_WM.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vs_WM.diminfo[0].shape = __pyx_pybuffernd_vs_WM.rcbuffer->pybuffer.shape[0]; + if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4108, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_vs_WM, ((PyArrayObject *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "cssm.pyx":4110 + * vs_WM = np.abs(np.random.normal(v_WM_view[k], sd_view[k])) # np.abs() to avoid negative vs + * + * x_t_RL = ([a_view[k]]*nact - zs)/vs_RL # <<<<<<<<<<<<<< + * # x_t_WM = ([a_view[k]]*nact - zs)/vs_WM + * +*/ + __pyx_t_2.data = __pyx_v_a_view.data; + __pyx_t_2.memview = __pyx_v_a_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_a_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_a_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_a_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_8 = PyList_New(1 * ((__pyx_v_nact<0) ? 0:__pyx_v_nact)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nact; __pyx_temp++) { + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_8, __pyx_temp, __pyx_t_3) != (0)) __PYX_ERR(0, 4110, __pyx_L1_error); + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Subtract(__pyx_t_8, ((PyObject *)__pyx_v_zs)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyNumber_Divide(__pyx_t_3, ((PyObject *)__pyx_v_vs_RL)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4110, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4110, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer); + __pyx_t_19 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_8), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_19 < 0)) { + PyErr_Fetch(&__pyx_t_22, &__pyx_t_21, &__pyx_t_20); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer, (PyObject*)__pyx_v_x_t_RL, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_22); Py_XDECREF(__pyx_t_21); Py_XDECREF(__pyx_t_20); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_22, __pyx_t_21, __pyx_t_20); + } + __pyx_t_22 = __pyx_t_21 = __pyx_t_20 = 0; + } + __pyx_pybuffernd_x_t_RL.diminfo[0].strides = __pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x_t_RL.diminfo[0].shape = __pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_x_t_RL.diminfo[1].strides = __pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_x_t_RL.diminfo[1].shape = __pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer.shape[1]; + if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4110, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_x_t_RL, ((PyArrayObject *)__pyx_t_8)); + __pyx_t_8 = 0; + + /* "cssm.pyx":4113 + * # x_t_WM = ([a_view[k]]*nact - zs)/vs_WM + * + * if np.min(x_t_RL) < t_WM_view[k]: # <<<<<<<<<<<<<< + * x_t = x_t_RL + * else: +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_x_t_RL)}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_2.data = __pyx_v_t_WM_view.data; + __pyx_t_2.memview = __pyx_v_t_WM_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_t_WM_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_t_WM_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_t_WM_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_7 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4113, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_3 = PyObject_RichCompare(__pyx_t_8, __pyx_t_7, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4113, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_24 < 0))) __PYX_ERR(0, 4113, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_24) { + + /* "cssm.pyx":4114 + * + * if np.min(x_t_RL) < t_WM_view[k]: + * x_t = x_t_RL # <<<<<<<<<<<<<< + * else: + * x_t = t_WM_view[k] + ( [a_view[k]]*nact - zs - ([t_WM_view[k]]*nact)*vs_RL ) / ( vs_RL + vs_WM ) +*/ + __Pyx_INCREF((PyObject *)__pyx_v_x_t_RL); + __Pyx_XDECREF_SET(__pyx_v_x_t, ((PyObject *)__pyx_v_x_t_RL)); + + /* "cssm.pyx":4113 + * # x_t_WM = ([a_view[k]]*nact - zs)/vs_WM + * + * if np.min(x_t_RL) < t_WM_view[k]: # <<<<<<<<<<<<<< + * x_t = x_t_RL + * else: +*/ + goto __pyx_L7; + } + + /* "cssm.pyx":4116 + * x_t = x_t_RL + * else: + * x_t = t_WM_view[k] + ( [a_view[k]]*nact - zs - ([t_WM_view[k]]*nact)*vs_RL ) / ( vs_RL + vs_WM ) # <<<<<<<<<<<<<< + * + * choices_view[n, k, 0] = np.argmin(x_t) # store choices for sample n +*/ + /*else*/ { + __pyx_t_2.data = __pyx_v_t_WM_view.data; + __pyx_t_2.memview = __pyx_v_t_WM_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_t_WM_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_t_WM_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_t_WM_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_2.data = __pyx_v_a_view.data; + __pyx_t_2.memview = __pyx_v_a_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_a_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_a_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_a_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_7 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_8 = PyList_New(1 * ((__pyx_v_nact<0) ? 0:__pyx_v_nact)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nact; __pyx_temp++) { + __Pyx_INCREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyList_SET_ITEM(__pyx_t_8, __pyx_temp, __pyx_t_7) != (0)) __PYX_ERR(0, 4116, __pyx_L1_error); + } + } + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyNumber_Subtract(__pyx_t_8, ((PyObject *)__pyx_v_zs)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_2.data = __pyx_v_t_WM_view.data; + __pyx_t_2.memview = __pyx_v_t_WM_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_t_WM_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_t_WM_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_t_WM_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_8 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_6 = PyList_New(1 * ((__pyx_v_nact<0) ? 0:__pyx_v_nact)); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nact; __pyx_temp++) { + __Pyx_INCREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyList_SET_ITEM(__pyx_t_6, __pyx_temp, __pyx_t_8) != (0)) __PYX_ERR(0, 4116, __pyx_L1_error); + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Multiply(__pyx_t_6, ((PyObject *)__pyx_v_vs_RL)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = PyNumber_Subtract(__pyx_t_7, __pyx_t_8); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(((PyObject *)__pyx_v_vs_RL), ((PyObject *)__pyx_v_vs_WM)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = __Pyx_PyNumber_Divide(__pyx_t_6, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Add(__pyx_t_3, __pyx_t_7); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4116, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_XDECREF_SET(__pyx_v_x_t, __pyx_t_8); + __pyx_t_8 = 0; + } + __pyx_L7:; + + /* "cssm.pyx":4118 + * x_t = t_WM_view[k] + ( [a_view[k]]*nact - zs - ([t_WM_view[k]]*nact)*vs_RL ) / ( vs_RL + vs_WM ) + * + * choices_view[n, k, 0] = np.argmin(x_t) # store choices for sample n # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = np.min(x_t) + t_view[k] # store reaction time for sample n + * +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_argmin); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_v_x_t}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4118, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_19 = __Pyx_PyLong_As_int(__pyx_t_8); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4118, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_25 = __pyx_v_n; + __pyx_t_26 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_25 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_26 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_19; + + /* "cssm.pyx":4119 + * + * choices_view[n, k, 0] = np.argmin(x_t) # store choices for sample n + * rts_view[n, k, 0] = np.min(x_t) + t_view[k] # store reaction time for sample n # <<<<<<<<<<<<<< + * + * # If the rt exceeds the deadline, set rt to -999 +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_min); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_v_x_t}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_27 = __pyx_v_k; + __pyx_t_3 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_27 * __pyx_v_t_view.strides[0]) )))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = PyNumber_Add(__pyx_t_8, __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_28 = __Pyx_PyFloat_AsFloat(__pyx_t_6); if (unlikely((__pyx_t_28 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_27 = __pyx_v_n; + __pyx_t_26 = __pyx_v_k; + __pyx_t_25 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_27 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_26 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_25 * __pyx_v_rts_view.strides[2]) )) = __pyx_t_28; + + /* "cssm.pyx":4122 + * + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_25 = __pyx_v_n; + __pyx_t_26 = __pyx_v_k; + __pyx_t_27 = 0; + __pyx_t_29 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_25 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_26 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_29 * __pyx_v_deadline_view.strides[0]) )))); + if (__pyx_t_24) { + + /* "cssm.pyx":4123 + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_29 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_26 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_29 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_26 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":4122 + * + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":4126 + * + * + * v_dict = {} # <<<<<<<<<<<<<< + * for i in range(nact): + * v_dict['v_RL_' + str(i)] = v_RL[:, i] +*/ + __pyx_t_6 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4126, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_v_v_dict = ((PyObject*)__pyx_t_6); + __pyx_t_6 = 0; + + /* "cssm.pyx":4127 + * + * v_dict = {} + * for i in range(nact): # <<<<<<<<<<<<<< + * v_dict['v_RL_' + str(i)] = v_RL[:, i] + * v_dict['v_WM_' + str(i)] = v_WM[:, i] +*/ + __pyx_t_12 = __pyx_v_nact; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_i = __pyx_t_14; + + /* "cssm.pyx":4128 + * v_dict = {} + * for i in range(nact): + * v_dict['v_RL_' + str(i)] = v_RL[:, i] # <<<<<<<<<<<<<< + * v_dict['v_WM_' + str(i)] = v_WM[:, i] + * +*/ + __pyx_t_6 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 4128, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 4128, __pyx_L1_error); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_v_RL), __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_Unicode(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_v_RL_2, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4128, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_v_dict, __pyx_t_3, __pyx_t_6) < 0))) __PYX_ERR(0, 4128, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + + /* "cssm.pyx":4129 + * for i in range(nact): + * v_dict['v_RL_' + str(i)] = v_RL[:, i] + * v_dict['v_WM_' + str(i)] = v_WM[:, i] # <<<<<<<<<<<<<< + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, +*/ + __pyx_t_6 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_3 = PyTuple_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 4129, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 4129, __pyx_L1_error); + __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_v_WM), __pyx_t_3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_Unicode(__pyx_t_3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_v_WM_2, __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4129, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_v_dict, __pyx_t_3, __pyx_t_6) < 0))) __PYX_ERR(0, 4129, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + } + + /* "cssm.pyx":4131 + * v_dict['v_WM_' + str(i)] = v_WM[:, i] + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_6 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4131, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4131, __pyx_L1_error) + __pyx_t_3 = PyDict_Copy(__pyx_v_v_dict); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4131, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":4132 + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't_WM': t_WM, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 4132, __pyx_L1_error) + + /* "cssm.pyx":4133 + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't_WM': t_WM, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 4133, __pyx_L1_error) + + /* "cssm.pyx":4134 + * 'a': a, + * 'z': z, + * 't_WM': t_WM, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t_WM, ((PyObject *)__pyx_v_t_WM)) < (0)) __PYX_ERR(0, 4134, __pyx_L1_error) + + /* "cssm.pyx":4135 + * 'z': z, + * 't_WM': t_WM, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 'sd': sd, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 4135, __pyx_L1_error) + + /* "cssm.pyx":4136 + * 't_WM': t_WM, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 'sd': sd, + * 'n_samples': n_samples, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 4136, __pyx_L1_error) + + /* "cssm.pyx":4137 + * 't': t, + * 'deadline': deadline, + * 'sd': sd, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'simulator' : 'rlwm_lba_pw_v1', +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_sd, ((PyObject *)__pyx_v_sd)) < (0)) __PYX_ERR(0, 4137, __pyx_L1_error) + + /* "cssm.pyx":4138 + * 'deadline': deadline, + * 'sd': sd, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'simulator' : 'rlwm_lba_pw_v1', + * 'possible_choices': list(np.arange(0, nact, 1)), +*/ + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4138, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_8) < (0)) __PYX_ERR(0, 4138, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_rlwm_lba_pw_v1) < (0)) __PYX_ERR(0, 4139, __pyx_L1_error) + + /* "cssm.pyx":4140 + * 'n_samples': n_samples, + * 'simulator' : 'rlwm_lba_pw_v1', + * 'possible_choices': list(np.arange(0, nact, 1)), # <<<<<<<<<<<<<< + * 'max_t': max_t, + * }} +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_nact); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_18))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_18); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_18, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_mstate_global->__pyx_int_1}; + __pyx_t_8 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_18, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_18 = __Pyx_PySequence_ListKeepNew(__pyx_t_8); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4140, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_18) < (0)) __PYX_ERR(0, 4140, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + + /* "cssm.pyx":4141 + * 'simulator' : 'rlwm_lba_pw_v1', + * 'possible_choices': list(np.arange(0, nact, 1)), + * 'max_t': max_t, # <<<<<<<<<<<<<< + * }} + * +*/ + __pyx_t_18 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4141, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_18) < (0)) __PYX_ERR(0, 4141, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_3) < (0)) __PYX_ERR(0, 4131, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_r = __pyx_t_6; + __pyx_t_6 = 0; + goto __pyx_L0; + + /* "cssm.pyx":4062 + * + * # Simulate (rt, choice) tuples from LBA piece-wise model ----------------------------- + * def rlwm_lba_pw_v1(np.ndarray[float, ndim = 2] v_RL, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] v_WM, + * np.ndarray[float, ndim = 2] a, +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_23); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sd.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zs.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.rlwm_lba_pw_v1", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sd.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zs.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_RL_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_WM_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_WM_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sd_view, 1); + __Pyx_XDECREF((PyObject *)__pyx_v_zs); + __Pyx_XDECREF((PyObject *)__pyx_v_x_t_RL); + __Pyx_XDECREF((PyObject *)__pyx_v_vs_RL); + __Pyx_XDECREF((PyObject *)__pyx_v_vs_WM); + __Pyx_XDECREF(__pyx_v_rts); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_x_t); + __Pyx_XDECREF(__pyx_v_v_dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":4145 + * + * # Simulate (rt, choice) tuples from: RLWM LBA Race Model without ndt ----------------------------- + * def rlwm_lba_race(np.ndarray[float, ndim = 2] v_RL, # RL drift parameters (np.array expect: one column of floats) # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] v_WM, # WM drift parameters (np.array expect: one column of floats) + * np.ndarray[float, ndim = 2] a, # criterion height +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_39rlwm_lba_race(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_38rlwm_lba_race, "\n Simulate reaction times and choices from a Reinforcement Learning Working Memory (RLWM) Linear Ballistic Accumulator (LBA) race model.\n\n Parameters:\n -----------\n v_RL : np.ndarray[float, ndim=2]\n Drift rate for the Reinforcement Learning (RL) component.\n v_WM : np.ndarray[float, ndim=2]\n Drift rate for the Working Memory (WM) component.\n a : np.ndarray[float, ndim=2]\n Decision threshold (criterion height).\n z : np.ndarray[float, ndim=2]\n Starting point distribution.\n deadline : np.ndarray[float, ndim=1]\n Maximum allowed decision time.\n sd : np.ndarray[float, ndim=1]\n Standard deviation of the drift rate distribution.\n t : np.ndarray[float, ndim=1]\n Non-decision time.\n nact : int, optional\n Number of accumulators (default is 3).\n n_samples : int, optional\n Number of samples to generate (default is 2000).\n n_trials : int, optional\n Number of trials to simulate (default is 1).\n max_t : float, optional\n Maximum time to simulate (default is 20).\n\n Returns:\n --------\n dict\n A dictionary containing:\n - 'rts': simulated reaction times\n - 'choices': simulated choices\n - 'metadata': additional information about the simulation\n "); +static PyMethodDef __pyx_mdef_4cssm_39rlwm_lba_race = {"rlwm_lba_race", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_39rlwm_lba_race, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_38rlwm_lba_race}; +static PyObject *__pyx_pw_4cssm_39rlwm_lba_race(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v_RL = 0; + PyArrayObject *__pyx_v_v_WM = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_z = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_sd = 0; + PyArrayObject *__pyx_v_t = 0; + int __pyx_v_nact; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + float __pyx_v_max_t; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[11] = {0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("rlwm_lba_race (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v_RL,&__pyx_mstate_global->__pyx_n_u_v_WM,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_z,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_sd,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_nact,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_max_t,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4145, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "rlwm_lba_race", 1) < (0)) __PYX_ERR(0, 4145, __pyx_L3_error) + for (Py_ssize_t i = __pyx_nargs; i < 7; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("rlwm_lba_race", 0, 7, 11, i); __PYX_ERR(0, 4145, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4145, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4145, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4145, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4145, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4145, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4145, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4145, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4145, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + } + __pyx_v_v_RL = ((PyArrayObject *)values[0]); + __pyx_v_v_WM = ((PyArrayObject *)values[1]); + __pyx_v_a = ((PyArrayObject *)values[2]); + __pyx_v_z = ((PyArrayObject *)values[3]); + __pyx_v_deadline = ((PyArrayObject *)values[4]); + __pyx_v_sd = ((PyArrayObject *)values[5]); + __pyx_v_t = ((PyArrayObject *)values[6]); + if (values[7]) { + __pyx_v_nact = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_nact == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4152, __pyx_L3_error) + } else { + __pyx_v_nact = ((int)((int)3)); + } + if (values[8]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[8]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4153, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x7D0)); + } + if (values[9]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[9]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4154, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + if (values[10]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[10]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4155, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("rlwm_lba_race", 0, 7, 11, __pyx_nargs); __PYX_ERR(0, 4145, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.rlwm_lba_race", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v_RL), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v_RL", 0))) __PYX_ERR(0, 4145, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v_WM), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v_WM", 0))) __PYX_ERR(0, 4146, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 4147, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_z), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "z", 0))) __PYX_ERR(0, 4148, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 4149, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sd), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sd", 0))) __PYX_ERR(0, 4150, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 4151, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_38rlwm_lba_race(__pyx_self, __pyx_v_v_RL, __pyx_v_v_WM, __pyx_v_a, __pyx_v_z, __pyx_v_deadline, __pyx_v_sd, __pyx_v_t, __pyx_v_nact, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_max_t, __pyx_v_kwargs); + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_38rlwm_lba_race(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v_RL, PyArrayObject *__pyx_v_v_WM, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_z, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_sd, PyArrayObject *__pyx_v_t, int __pyx_v_nact, int __pyx_v_n_samples, int __pyx_v_n_trials, float __pyx_v_max_t, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_RL_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_v_WM_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_z_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_sd_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyArrayObject *__pyx_v_zs = 0; + PyArrayObject *__pyx_v_x_t_RL = 0; + PyArrayObject *__pyx_v_x_t_WM = 0; + PyArrayObject *__pyx_v_vs_RL = 0; + PyArrayObject *__pyx_v_vs_WM = 0; + PyObject *__pyx_v_rts = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_i; + PyObject *__pyx_v_v_dict = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sd; + __Pyx_Buffer __pyx_pybuffer_sd; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v_RL; + __Pyx_Buffer __pyx_pybuffer_v_RL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v_WM; + __Pyx_Buffer __pyx_pybuffer_v_WM; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vs_RL; + __Pyx_Buffer __pyx_pybuffer_vs_RL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vs_WM; + __Pyx_Buffer __pyx_pybuffer_vs_WM; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x_t_RL; + __Pyx_Buffer __pyx_pybuffer_x_t_RL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_x_t_WM; + __Pyx_Buffer __pyx_pybuffer_x_t_WM; + __Pyx_LocalBuf_ND __pyx_pybuffernd_z; + __Pyx_Buffer __pyx_pybuffer_z; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zs; + __Pyx_Buffer __pyx_pybuffer_zs; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + __Pyx_memviewslice __pyx_t_1 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + PyObject *__pyx_t_8 = NULL; + size_t __pyx_t_9; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_12; + int __pyx_t_13; + Py_ssize_t __pyx_t_14; + int __pyx_t_15; + int __pyx_t_16; + Py_ssize_t __pyx_t_17; + PyObject *__pyx_t_18 = NULL; + int __pyx_t_19; + PyObject *__pyx_t_20 = NULL; + PyObject *__pyx_t_21 = NULL; + PyObject *__pyx_t_22 = NULL; + PyObject *__pyx_t_23 = NULL; + int __pyx_t_24; + Py_ssize_t __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + Py_ssize_t __pyx_t_28; + Py_ssize_t __pyx_t_29; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("rlwm_lba_race", 0); + __pyx_pybuffer_zs.pybuffer.buf = NULL; + __pyx_pybuffer_zs.refcount = 0; + __pyx_pybuffernd_zs.data = NULL; + __pyx_pybuffernd_zs.rcbuffer = &__pyx_pybuffer_zs; + __pyx_pybuffer_x_t_RL.pybuffer.buf = NULL; + __pyx_pybuffer_x_t_RL.refcount = 0; + __pyx_pybuffernd_x_t_RL.data = NULL; + __pyx_pybuffernd_x_t_RL.rcbuffer = &__pyx_pybuffer_x_t_RL; + __pyx_pybuffer_x_t_WM.pybuffer.buf = NULL; + __pyx_pybuffer_x_t_WM.refcount = 0; + __pyx_pybuffernd_x_t_WM.data = NULL; + __pyx_pybuffernd_x_t_WM.rcbuffer = &__pyx_pybuffer_x_t_WM; + __pyx_pybuffer_vs_RL.pybuffer.buf = NULL; + __pyx_pybuffer_vs_RL.refcount = 0; + __pyx_pybuffernd_vs_RL.data = NULL; + __pyx_pybuffernd_vs_RL.rcbuffer = &__pyx_pybuffer_vs_RL; + __pyx_pybuffer_vs_WM.pybuffer.buf = NULL; + __pyx_pybuffer_vs_WM.refcount = 0; + __pyx_pybuffernd_vs_WM.data = NULL; + __pyx_pybuffernd_vs_WM.rcbuffer = &__pyx_pybuffer_vs_WM; + __pyx_pybuffer_v_RL.pybuffer.buf = NULL; + __pyx_pybuffer_v_RL.refcount = 0; + __pyx_pybuffernd_v_RL.data = NULL; + __pyx_pybuffernd_v_RL.rcbuffer = &__pyx_pybuffer_v_RL; + __pyx_pybuffer_v_WM.pybuffer.buf = NULL; + __pyx_pybuffer_v_WM.refcount = 0; + __pyx_pybuffernd_v_WM.data = NULL; + __pyx_pybuffernd_v_WM.rcbuffer = &__pyx_pybuffer_v_WM; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_z.pybuffer.buf = NULL; + __pyx_pybuffer_z.refcount = 0; + __pyx_pybuffernd_z.data = NULL; + __pyx_pybuffernd_z.rcbuffer = &__pyx_pybuffer_z; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_sd.pybuffer.buf = NULL; + __pyx_pybuffer_sd.refcount = 0; + __pyx_pybuffernd_sd.data = NULL; + __pyx_pybuffernd_sd.rcbuffer = &__pyx_pybuffer_sd; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v_RL.rcbuffer->pybuffer, (PyObject*)__pyx_v_v_RL, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4145, __pyx_L1_error) + } + __pyx_pybuffernd_v_RL.diminfo[0].strides = __pyx_pybuffernd_v_RL.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v_RL.diminfo[0].shape = __pyx_pybuffernd_v_RL.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_v_RL.diminfo[1].strides = __pyx_pybuffernd_v_RL.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_v_RL.diminfo[1].shape = __pyx_pybuffernd_v_RL.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v_WM.rcbuffer->pybuffer, (PyObject*)__pyx_v_v_WM, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4145, __pyx_L1_error) + } + __pyx_pybuffernd_v_WM.diminfo[0].strides = __pyx_pybuffernd_v_WM.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v_WM.diminfo[0].shape = __pyx_pybuffernd_v_WM.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_v_WM.diminfo[1].strides = __pyx_pybuffernd_v_WM.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_v_WM.diminfo[1].shape = __pyx_pybuffernd_v_WM.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4145, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_a.diminfo[1].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_a.diminfo[1].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_z.rcbuffer->pybuffer, (PyObject*)__pyx_v_z, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4145, __pyx_L1_error) + } + __pyx_pybuffernd_z.diminfo[0].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_z.diminfo[0].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_z.diminfo[1].strides = __pyx_pybuffernd_z.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_z.diminfo[1].shape = __pyx_pybuffernd_z.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4145, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sd.rcbuffer->pybuffer, (PyObject*)__pyx_v_sd, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4145, __pyx_L1_error) + } + __pyx_pybuffernd_sd.diminfo[0].strides = __pyx_pybuffernd_sd.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sd.diminfo[0].shape = __pyx_pybuffernd_sd.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sd.diminfo[1].strides = __pyx_pybuffernd_sd.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sd.diminfo[1].shape = __pyx_pybuffernd_sd.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4145, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":4196 + * + * # Param views + * cdef float[:, :] v_RL_view = v_RL # <<<<<<<<<<<<<< + * cdef float[:, :] v_WM_view = v_WM + * cdef float[:, :] a_view = a +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_v_RL), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4196, __pyx_L1_error) + __pyx_v_v_RL_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4197 + * # Param views + * cdef float[:, :] v_RL_view = v_RL + * cdef float[:, :] v_WM_view = v_WM # <<<<<<<<<<<<<< + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_v_WM), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4197, __pyx_L1_error) + __pyx_v_v_WM_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4198 + * cdef float[:, :] v_RL_view = v_RL + * cdef float[:, :] v_WM_view = v_WM + * cdef float[:, :] a_view = a # <<<<<<<<<<<<<< + * cdef float[:, :] z_view = z + * cdef float[:] t_view = t +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4198, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4199 + * cdef float[:, :] v_WM_view = v_WM + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_z), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4199, __pyx_L1_error) + __pyx_v_z_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4200 + * cdef float[:, :] a_view = a + * cdef float[:, :] z_view = z + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4200, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4202 + * cdef float[:] t_view = t + * + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:, :] sd_view = sd + * cdef np.ndarray[float, ndim = 1] zs +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4202, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4203 + * + * cdef float[:] deadline_view = deadline + * cdef float[:, :] sd_view = sd # <<<<<<<<<<<<<< + * cdef np.ndarray[float, ndim = 1] zs + * cdef np.ndarray[double, ndim = 2] x_t_RL +*/ + __pyx_t_1 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_sd), PyBUF_WRITABLE); if (unlikely(!__pyx_t_1.memview)) __PYX_ERR(0, 4203, __pyx_L1_error) + __pyx_v_sd_view = __pyx_t_1; + __pyx_t_1.memview = NULL; + __pyx_t_1.data = NULL; + + /* "cssm.pyx":4210 + * cdef np.ndarray[double, ndim = 1] vs_WM + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_view = rts + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = PyTuple_New(3); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 4210, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 4210, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4210, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_8}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4210, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_v_rts = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":4211 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 4211, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":4213 + * cdef float[:, :, :] rts_view = rts + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 4213, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_8) != (0)) __PYX_ERR(0, 4213, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4213, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_t_8 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_4}; + __pyx_t_8 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_8, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4213, __pyx_L1_error) + __pyx_t_3 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_8); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4213, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_v_choices = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":4214 + * + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef Py_ssize_t n, k, i +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 4214, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":4218 + * cdef Py_ssize_t n, k, i + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * + * for n in range(n_samples): +*/ + __pyx_t_12 = __pyx_v_n_trials; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_k = __pyx_t_14; + + /* "cssm.pyx":4220 + * for k in range(n_trials): + * + * for n in range(n_samples): # <<<<<<<<<<<<<< + * zs = np.random.uniform(0, z_view[k], nact).astype(DTYPE) + * +*/ + __pyx_t_15 = __pyx_v_n_samples; + __pyx_t_16 = __pyx_t_15; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":4221 + * + * for n in range(n_samples): + * zs = np.random.uniform(0, z_view[k], nact).astype(DTYPE) # <<<<<<<<<<<<<< + * + * vs_RL = np.abs(np.random.normal(v_RL_view[k], sd_view[k])) # np.abs() to avoid negative vs +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_2.data = __pyx_v_z_view.data; + __pyx_t_2.memview = __pyx_v_z_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_z_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_z_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_z_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_4 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_18 = __Pyx_PyLong_From_int(__pyx_v_nact); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_mstate_global->__pyx_int_0, __pyx_t_4, __pyx_t_18}; + __pyx_t_8 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_uniform, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + } + __pyx_t_7 = __pyx_t_8; + __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4221, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4221, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zs.rcbuffer->pybuffer); + __pyx_t_19 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zs.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_3), &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_19 < 0)) { + PyErr_Fetch(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zs.rcbuffer->pybuffer, (PyObject*)__pyx_v_zs, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_20); Py_XDECREF(__pyx_t_21); Py_XDECREF(__pyx_t_22); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_20, __pyx_t_21, __pyx_t_22); + } + __pyx_t_20 = __pyx_t_21 = __pyx_t_22 = 0; + } + __pyx_pybuffernd_zs.diminfo[0].strides = __pyx_pybuffernd_zs.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zs.diminfo[0].shape = __pyx_pybuffernd_zs.rcbuffer->pybuffer.shape[0]; + if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4221, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_zs, ((PyArrayObject *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "cssm.pyx":4223 + * zs = np.random.uniform(0, z_view[k], nact).astype(DTYPE) + * + * vs_RL = np.abs(np.random.normal(v_RL_view[k], sd_view[k])) # np.abs() to avoid negative vs # <<<<<<<<<<<<<< + * vs_WM = np.abs(np.random.normal(v_WM_view[k], sd_view[k])) # np.abs() to avoid negative vs + * +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_abs); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_18 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_18); + __pyx_t_2.data = __pyx_v_v_RL_view.data; + __pyx_t_2.memview = __pyx_v_v_RL_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_v_RL_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_v_RL_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_v_RL_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_4 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_2.data = __pyx_v_sd_view.data; + __pyx_t_2.memview = __pyx_v_sd_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_sd_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_sd_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_sd_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_23 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_18, __pyx_t_4, __pyx_t_23}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_normal, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4223, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4223, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer); + __pyx_t_19 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_3), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_19 < 0)) { + PyErr_Fetch(&__pyx_t_22, &__pyx_t_21, &__pyx_t_20); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer, (PyObject*)__pyx_v_vs_RL, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_22); Py_XDECREF(__pyx_t_21); Py_XDECREF(__pyx_t_20); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_22, __pyx_t_21, __pyx_t_20); + } + __pyx_t_22 = __pyx_t_21 = __pyx_t_20 = 0; + } + __pyx_pybuffernd_vs_RL.diminfo[0].strides = __pyx_pybuffernd_vs_RL.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vs_RL.diminfo[0].shape = __pyx_pybuffernd_vs_RL.rcbuffer->pybuffer.shape[0]; + if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4223, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_vs_RL, ((PyArrayObject *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "cssm.pyx":4224 + * + * vs_RL = np.abs(np.random.normal(v_RL_view[k], sd_view[k])) # np.abs() to avoid negative vs + * vs_WM = np.abs(np.random.normal(v_WM_view[k], sd_view[k])) # np.abs() to avoid negative vs # <<<<<<<<<<<<<< + * + * x_t_RL = ([a_view[k]]*nact - zs)/vs_RL +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_abs); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_23, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_2.data = __pyx_v_v_WM_view.data; + __pyx_t_2.memview = __pyx_v_v_WM_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_v_WM_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_v_WM_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_v_WM_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_23 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_23)) __PYX_ERR(0, 4224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_23); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_2.data = __pyx_v_sd_view.data; + __pyx_t_2.memview = __pyx_v_sd_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_sd_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_sd_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_sd_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_18 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_9 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_23, __pyx_t_18}; + __pyx_t_6 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_normal, __pyx_callargs+__pyx_t_9, (3-__pyx_t_9) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_23); __pyx_t_23 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4224, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4224, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer); + __pyx_t_19 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_3), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_19 < 0)) { + PyErr_Fetch(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer, (PyObject*)__pyx_v_vs_WM, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_20); Py_XDECREF(__pyx_t_21); Py_XDECREF(__pyx_t_22); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_20, __pyx_t_21, __pyx_t_22); + } + __pyx_t_20 = __pyx_t_21 = __pyx_t_22 = 0; + } + __pyx_pybuffernd_vs_WM.diminfo[0].strides = __pyx_pybuffernd_vs_WM.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vs_WM.diminfo[0].shape = __pyx_pybuffernd_vs_WM.rcbuffer->pybuffer.shape[0]; + if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4224, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_vs_WM, ((PyArrayObject *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "cssm.pyx":4226 + * vs_WM = np.abs(np.random.normal(v_WM_view[k], sd_view[k])) # np.abs() to avoid negative vs + * + * x_t_RL = ([a_view[k]]*nact - zs)/vs_RL # <<<<<<<<<<<<<< + * x_t_WM = ([a_view[k]]*nact - zs)/vs_WM + * +*/ + __pyx_t_2.data = __pyx_v_a_view.data; + __pyx_t_2.memview = __pyx_v_a_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_a_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_a_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_a_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_3 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_8 = PyList_New(1 * ((__pyx_v_nact<0) ? 0:__pyx_v_nact)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nact; __pyx_temp++) { + __Pyx_INCREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_8, __pyx_temp, __pyx_t_3) != (0)) __PYX_ERR(0, 4226, __pyx_L1_error); + } + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyNumber_Subtract(__pyx_t_8, ((PyObject *)__pyx_v_zs)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyNumber_Divide(__pyx_t_3, ((PyObject *)__pyx_v_vs_RL)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4226, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (!(likely(((__pyx_t_8) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_8, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4226, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer); + __pyx_t_19 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_8), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_19 < 0)) { + PyErr_Fetch(&__pyx_t_22, &__pyx_t_21, &__pyx_t_20); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer, (PyObject*)__pyx_v_x_t_RL, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_22); Py_XDECREF(__pyx_t_21); Py_XDECREF(__pyx_t_20); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_22, __pyx_t_21, __pyx_t_20); + } + __pyx_t_22 = __pyx_t_21 = __pyx_t_20 = 0; + } + __pyx_pybuffernd_x_t_RL.diminfo[0].strides = __pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x_t_RL.diminfo[0].shape = __pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_x_t_RL.diminfo[1].strides = __pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_x_t_RL.diminfo[1].shape = __pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer.shape[1]; + if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4226, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_x_t_RL, ((PyArrayObject *)__pyx_t_8)); + __pyx_t_8 = 0; + + /* "cssm.pyx":4227 + * + * x_t_RL = ([a_view[k]]*nact - zs)/vs_RL + * x_t_WM = ([a_view[k]]*nact - zs)/vs_WM # <<<<<<<<<<<<<< + * + * if np.min(x_t_RL) <= np.min(x_t_WM): +*/ + __pyx_t_2.data = __pyx_v_a_view.data; + __pyx_t_2.memview = __pyx_v_a_view.memview; + __PYX_INC_MEMVIEW(&__pyx_t_2, 1); + { + Py_ssize_t __pyx_tmp_idx = __pyx_v_k; + Py_ssize_t __pyx_tmp_stride = __pyx_v_a_view.strides[0]; + __pyx_t_2.data += __pyx_tmp_idx * __pyx_tmp_stride; +} + +__pyx_t_2.shape[0] = __pyx_v_a_view.shape[1]; +__pyx_t_2.strides[0] = __pyx_v_a_view.strides[1]; + __pyx_t_2.suboffsets[0] = -1; + +__pyx_t_8 = __pyx_memoryview_fromslice(__pyx_t_2, 1, (PyObject *(*)(char *)) __pyx_memview_get_float, (int (*)(char *, PyObject *)) __pyx_memview_set_float, 0);; if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __pyx_t_2.memview = NULL; __pyx_t_2.data = NULL; + __pyx_t_3 = PyList_New(1 * ((__pyx_v_nact<0) ? 0:__pyx_v_nact)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + { Py_ssize_t __pyx_temp; + for (__pyx_temp=0; __pyx_temp < __pyx_v_nact; __pyx_temp++) { + __Pyx_INCREF(__pyx_t_8); + __Pyx_GIVEREF(__pyx_t_8); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, __pyx_temp, __pyx_t_8) != (0)) __PYX_ERR(0, 4227, __pyx_L1_error); + } + } + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyNumber_Subtract(__pyx_t_3, ((PyObject *)__pyx_v_zs)); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyNumber_Divide(__pyx_t_8, ((PyObject *)__pyx_v_vs_WM)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4227, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (!(likely(((__pyx_t_3) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_3, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4227, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_t_WM.rcbuffer->pybuffer); + __pyx_t_19 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_t_WM.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_3), &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_19 < 0)) { + PyErr_Fetch(&__pyx_t_20, &__pyx_t_21, &__pyx_t_22); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_x_t_WM.rcbuffer->pybuffer, (PyObject*)__pyx_v_x_t_WM, &__Pyx_TypeInfo_double, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_20); Py_XDECREF(__pyx_t_21); Py_XDECREF(__pyx_t_22); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_20, __pyx_t_21, __pyx_t_22); + } + __pyx_t_20 = __pyx_t_21 = __pyx_t_22 = 0; + } + __pyx_pybuffernd_x_t_WM.diminfo[0].strides = __pyx_pybuffernd_x_t_WM.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_x_t_WM.diminfo[0].shape = __pyx_pybuffernd_x_t_WM.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_x_t_WM.diminfo[1].strides = __pyx_pybuffernd_x_t_WM.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_x_t_WM.diminfo[1].shape = __pyx_pybuffernd_x_t_WM.rcbuffer->pybuffer.shape[1]; + if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4227, __pyx_L1_error) + } + __Pyx_XDECREF_SET(__pyx_v_x_t_WM, ((PyArrayObject *)__pyx_t_3)); + __pyx_t_3 = 0; + + /* "cssm.pyx":4229 + * x_t_WM = ([a_view[k]]*nact - zs)/vs_WM + * + * if np.min(x_t_RL) <= np.min(x_t_WM): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = np.min(x_t_RL) + t_view[k] # store reaction time for sample n + * choices_view[n, k, 0] = np.argmin(x_t_RL) # store choices for sample n +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_min); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, ((PyObject *)__pyx_v_x_t_RL)}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_min); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, ((PyObject *)__pyx_v_x_t_WM)}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_4 = PyObject_RichCompare(__pyx_t_3, __pyx_t_7, Py_LE); __Pyx_XGOTREF(__pyx_t_4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_24 = __Pyx_PyObject_IsTrue(__pyx_t_4); if (unlikely((__pyx_t_24 < 0))) __PYX_ERR(0, 4229, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (__pyx_t_24) { + + /* "cssm.pyx":4230 + * + * if np.min(x_t_RL) <= np.min(x_t_WM): + * rts_view[n, k, 0] = np.min(x_t_RL) + t_view[k] # store reaction time for sample n # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = np.argmin(x_t_RL) # store choices for sample n + * else: +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_min); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, ((PyObject *)__pyx_v_x_t_RL)}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_25 = __pyx_v_k; + __pyx_t_8 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_25 * __pyx_v_t_view.strides[0]) )))); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_7 = PyNumber_Add(__pyx_t_4, __pyx_t_8); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4230, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_26 = __Pyx_PyFloat_AsFloat(__pyx_t_7); if (unlikely((__pyx_t_26 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4230, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_25 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_28 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_25 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_28 * __pyx_v_rts_view.strides[2]) )) = __pyx_t_26; + + /* "cssm.pyx":4231 + * if np.min(x_t_RL) <= np.min(x_t_WM): + * rts_view[n, k, 0] = np.min(x_t_RL) + t_view[k] # store reaction time for sample n + * choices_view[n, k, 0] = np.argmin(x_t_RL) # store choices for sample n # <<<<<<<<<<<<<< + * else: + * rts_view[n, k, 0] = np.min(x_t_WM) + t_view[k] # store reaction time for sample n +*/ + __pyx_t_8 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_argmin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_8 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_8); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_8); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_8, ((PyObject *)__pyx_v_x_t_RL)}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4231, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_19 = __Pyx_PyLong_As_int(__pyx_t_7); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4231, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_28 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_25 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_28 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_25 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_19; + + /* "cssm.pyx":4229 + * x_t_WM = ([a_view[k]]*nact - zs)/vs_WM + * + * if np.min(x_t_RL) <= np.min(x_t_WM): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = np.min(x_t_RL) + t_view[k] # store reaction time for sample n + * choices_view[n, k, 0] = np.argmin(x_t_RL) # store choices for sample n +*/ + goto __pyx_L7; + } + + /* "cssm.pyx":4233 + * choices_view[n, k, 0] = np.argmin(x_t_RL) # store choices for sample n + * else: + * rts_view[n, k, 0] = np.min(x_t_WM) + t_view[k] # store reaction time for sample n # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = np.argmin(x_t_WM) # store choices for sample n + * +*/ + /*else*/ { + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_min); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, ((PyObject *)__pyx_v_x_t_WM)}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_25 = __pyx_v_k; + __pyx_t_4 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_25 * __pyx_v_t_view.strides[0]) )))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = PyNumber_Add(__pyx_t_7, __pyx_t_4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_26 = __Pyx_PyFloat_AsFloat(__pyx_t_3); if (unlikely((__pyx_t_26 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4233, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_25 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_28 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_25 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_28 * __pyx_v_rts_view.strides[2]) )) = __pyx_t_26; + + /* "cssm.pyx":4234 + * else: + * rts_view[n, k, 0] = np.min(x_t_WM) + t_view[k] # store reaction time for sample n + * choices_view[n, k, 0] = np.argmin(x_t_WM) # store choices for sample n # <<<<<<<<<<<<<< + * + * # If the rt exceeds the deadline, set rt to -999 +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_argmin); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_8))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_8); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_8); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_8, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_4, ((PyObject *)__pyx_v_x_t_WM)}; + __pyx_t_3 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_8, __pyx_callargs+__pyx_t_9, (2-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4234, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __pyx_t_19 = __Pyx_PyLong_As_int(__pyx_t_3); if (unlikely((__pyx_t_19 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4234, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_28 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_25 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_28 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_25 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_19; + } + __pyx_L7:; + + /* "cssm.pyx":4237 + * + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_25 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_28 = 0; + __pyx_t_29 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_25 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_28 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_29 * __pyx_v_deadline_view.strides[0]) )))); + if (__pyx_t_24) { + + /* "cssm.pyx":4238 + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_29 = __pyx_v_n; + __pyx_t_28 = __pyx_v_k; + __pyx_t_27 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_29 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_28 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":4237 + * + * # If the rt exceeds the deadline, set rt to -999 + * if rts_view[n, k, 0] >= deadline_view[k]: # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":4241 + * + * + * v_dict = {} # <<<<<<<<<<<<<< + * for i in range(nact): + * v_dict['v_RL_' + str(i)] = v_RL[:, i] +*/ + __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4241, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_v_v_dict = ((PyObject*)__pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":4242 + * + * v_dict = {} + * for i in range(nact): # <<<<<<<<<<<<<< + * v_dict['v_RL_' + str(i)] = v_RL[:, i] + * v_dict['v_WM_' + str(i)] = v_WM[:, i] +*/ + __pyx_t_12 = __pyx_v_nact; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_i = __pyx_t_14; + + /* "cssm.pyx":4243 + * v_dict = {} + * for i in range(nact): + * v_dict['v_RL_' + str(i)] = v_RL[:, i] # <<<<<<<<<<<<<< + * v_dict['v_WM_' + str(i)] = v_WM[:, i] + * +*/ + __pyx_t_3 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 4243, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 4243, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_v_RL), __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_Unicode(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_v_RL_2, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4243, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_v_dict, __pyx_t_8, __pyx_t_3) < 0))) __PYX_ERR(0, 4243, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4244 + * for i in range(nact): + * v_dict['v_RL_' + str(i)] = v_RL[:, i] + * v_dict['v_WM_' + str(i)] = v_WM[:, i] # <<<<<<<<<<<<<< + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, +*/ + __pyx_t_3 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = PyTuple_New(2); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_INCREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 0, __pyx_mstate_global->__pyx_slice[0]) != (0)) __PYX_ERR(0, 4244, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_8, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 4244, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_v_WM), __pyx_t_8); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = PyLong_FromSsize_t(__pyx_v_i); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __pyx_t_4 = __Pyx_PyObject_Unicode(__pyx_t_8); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_t_8 = __Pyx_PyUnicode_Concat(__pyx_mstate_global->__pyx_n_u_v_WM_2, __pyx_t_4); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4244, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely((PyDict_SetItem(__pyx_v_v_dict, __pyx_t_8, __pyx_t_3) < 0))) __PYX_ERR(0, 4244, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + + /* "cssm.pyx":4246 + * v_dict['v_WM_' + str(i)] = v_WM[:, i] + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, # <<<<<<<<<<<<<< + * 'a': a, + * 'z': z, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_3 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4246, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4246, __pyx_L1_error) + __pyx_t_8 = PyDict_Copy(__pyx_v_v_dict); if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 4246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_8); + + /* "cssm.pyx":4247 + * + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, # <<<<<<<<<<<<<< + * 'z': z, + * 't': 0, +*/ + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 4247, __pyx_L1_error) + + /* "cssm.pyx":4248 + * return {'rts': rts, 'choices': choices, 'metadata': {**v_dict, + * 'a': a, + * 'z': z, # <<<<<<<<<<<<<< + * 't': 0, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_z, ((PyObject *)__pyx_v_z)) < (0)) __PYX_ERR(0, 4248, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_t, __pyx_mstate_global->__pyx_int_0) < (0)) __PYX_ERR(0, 4249, __pyx_L1_error) + + /* "cssm.pyx":4250 + * 'z': z, + * 't': 0, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 'sd': sd, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 4250, __pyx_L1_error) + + /* "cssm.pyx":4251 + * 't': 0, + * 'deadline': deadline, + * 'sd': sd, # <<<<<<<<<<<<<< + * 't': t, + * 'n_samples': n_samples, +*/ + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_sd, ((PyObject *)__pyx_v_sd)) < (0)) __PYX_ERR(0, 4251, __pyx_L1_error) + + /* "cssm.pyx":4252 + * 'deadline': deadline, + * 'sd': sd, + * 't': t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'simulator' : 'rlwm_lba_race', +*/ + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 4252, __pyx_L1_error) + + /* "cssm.pyx":4253 + * 'sd': sd, + * 't': t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'simulator' : 'rlwm_lba_race', + * 'possible_choices': list(np.arange(0, nact, 1)), +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4253, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 4253, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_rlwm_lba_race) < (0)) __PYX_ERR(0, 4254, __pyx_L1_error) + + /* "cssm.pyx":4255 + * 'n_samples': n_samples, + * 'simulator' : 'rlwm_lba_race', + * 'possible_choices': list(np.arange(0, nact, 1)), # <<<<<<<<<<<<<< + * 'max_t': max_t, + * }} +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_18 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_nact); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_9 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_18))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_18); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_18); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_18, __pyx__function); + __pyx_t_9 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_7, __pyx_mstate_global->__pyx_int_0, __pyx_t_6, __pyx_mstate_global->__pyx_int_1}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_18, __pyx_callargs+__pyx_t_9, (4-__pyx_t_9) | (__pyx_t_9*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_18 = __Pyx_PySequence_ListKeepNew(__pyx_t_4); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4255, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_18) < (0)) __PYX_ERR(0, 4255, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + + /* "cssm.pyx":4256 + * 'simulator' : 'rlwm_lba_race', + * 'possible_choices': list(np.arange(0, nact, 1)), + * 'max_t': max_t, # <<<<<<<<<<<<<< + * }} + * # ---------------------------------------------------------------------------------------------------- +*/ + __pyx_t_18 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_18)) __PYX_ERR(0, 4256, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_18); + if (PyDict_SetItem(__pyx_t_8, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_18) < (0)) __PYX_ERR(0, 4256, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_18); __pyx_t_18 = 0; + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_8) < (0)) __PYX_ERR(0, 4246, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_8); __pyx_t_8 = 0; + __pyx_r = __pyx_t_3; + __pyx_t_3 = 0; + goto __pyx_L0; + + /* "cssm.pyx":4145 + * + * # Simulate (rt, choice) tuples from: RLWM LBA Race Model without ndt ----------------------------- + * def rlwm_lba_race(np.ndarray[float, ndim = 2] v_RL, # RL drift parameters (np.array expect: one column of floats) # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] v_WM, # WM drift parameters (np.array expect: one column of floats) + * np.ndarray[float, ndim = 2] a, # criterion height +*/ + + /* function exit code */ + __pyx_L1_error:; + __PYX_XCLEAR_MEMVIEW(&__pyx_t_1, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_8); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_18); + __Pyx_XDECREF(__pyx_t_23); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sd.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_t_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zs.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.rlwm_lba_race", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sd.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vs_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_t_RL.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_x_t_WM.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_z.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zs.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_RL_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_WM_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_z_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_sd_view, 1); + __Pyx_XDECREF((PyObject *)__pyx_v_zs); + __Pyx_XDECREF((PyObject *)__pyx_v_x_t_RL); + __Pyx_XDECREF((PyObject *)__pyx_v_x_t_WM); + __Pyx_XDECREF((PyObject *)__pyx_v_vs_RL); + __Pyx_XDECREF((PyObject *)__pyx_v_vs_WM); + __Pyx_XDECREF(__pyx_v_rts); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_v_dict); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":4263 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_unnormalized_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + +static PyObject *__pyx_pf_4cssm_76__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":4275 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4275, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":4276 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4276, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":4277 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * print_info = True, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4277, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":4278 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4278, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":4263 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_unnormalized_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_5 = PyTuple_New(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, Py_None) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, Py_None) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 10, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 4263, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_41ddm_flexbound_mic2_unnormalized_ornstein_multinoise(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_40ddm_flexbound_mic2_unnormalized_ornstein_multinoise, "\n Simulate a Drift Diffusion Model (DDM) with flexible boundaries for a multi-level decision process.\n\n This function simulates a two-stage decision process where a high-dimensional choice influences\n two low-dimensional choices through a bias trace. The process incorporates an Ornstein-Uhlenbeck\n process and multiple noise parameters.\n\n Parameters:\n -----------\n vh, vl1, vl2 : np.ndarray[float, ndim=1]\n Drift rates for high-dimensional and two low-dimensional choices.\n a : np.ndarray[float, ndim=1]\n Initial boundary separation.\n zh, zl1, zl2 : np.ndarray[float, ndim=1]\n Starting points for high-dimensional and two low-dimensional choices.\n d : np.ndarray[float, ndim=1]\n Damping factor for drift rate on low-level choices.\n g : np.ndarray[float, ndim=1]\n Inhibition parameter for low-dimensional choices while high-dimensional is running.\n t : np.ndarray[float, ndim=1]\n Non-decision time.\n deadline : np.ndarray[float, ndim=1]\n Time limit for each trial.\n s : np.ndarray[float, ndim=1]\n Noise standard deviation.\n delta_t : float, optional\n Time step for simulation (default: 0.001).\n max_t : float, optional\n Maximum time for simulation (default: 20).\n n_samples : int, optional\n Number of samples per trial (default: 20000).\n n_trials : int, optional\n Number of trials to simulate (default: 1).\n print_info : bool, optional\n Whether to print simulation information (default: True).\n boundary_fun : callable, optional\n Function defining the decision boundary over time.\n boundary_multiplicative : bool, optional\n If True, boundary function is multiplicative; if False, additive (default: True).\n boundary_params : dict, optional\n Parameters for the boundary function.\n random_state : int or None, optional\n Seed for random number generator (default: None).""\n return_option : str, optional\n Determines the amount of data returned ('full' or 'minimal', default: 'full').\n smooth_unif : bool, optional\n If True, applies uniform smoothing to reaction times (default: False).\n\n Returns:\n --------\n dict\n A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the 'return_option' parameter.\n\n Notes:\n ------\n This function implements a complex DDM with multiple interacting decision processes,\n flexible boundaries, and Ornstein-Uhlenbeck dynamics. It's particularly suited for\n modeling hierarchical decision-making scenarios.\n "); +static PyMethodDef __pyx_mdef_4cssm_41ddm_flexbound_mic2_unnormalized_ornstein_multinoise = {"ddm_flexbound_mic2_unnormalized_ornstein_multinoise", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_41ddm_flexbound_mic2_unnormalized_ornstein_multinoise, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_40ddm_flexbound_mic2_unnormalized_ornstein_multinoise}; +static PyObject *__pyx_pw_4cssm_41ddm_flexbound_mic2_unnormalized_ornstein_multinoise(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_vh = 0; + PyArrayObject *__pyx_v_vl1 = 0; + PyArrayObject *__pyx_v_vl2 = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_zh = 0; + PyArrayObject *__pyx_v_zl1 = 0; + PyArrayObject *__pyx_v_zl2 = 0; + PyArrayObject *__pyx_v_d = 0; + PyArrayObject *__pyx_v_g = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + CYTHON_UNUSED PyObject *__pyx_v_print_info = 0; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[23] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_flexbound_mic2_unnormalized_ornstein_multinoise (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_vh,&__pyx_mstate_global->__pyx_n_u_vl1,&__pyx_mstate_global->__pyx_n_u_vl2,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_zh,&__pyx_mstate_global->__pyx_n_u_zl1,&__pyx_mstate_global->__pyx_n_u_zl2,&__pyx_mstate_global->__pyx_n_u_d,&__pyx_mstate_global->__pyx_n_u_g,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_print_info,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4263, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 23: + values[22] = __Pyx_ArgRef_FASTCALL(__pyx_args, 22); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[22])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_flexbound_mic2_unnormalized_ornstein_multinoise", 1) < (0)) __PYX_ERR(0, 4263, __pyx_L3_error) + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":4280 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[19]) values[19] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":4283 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[22]) values[22] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 12; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_flexbound_mic2_unnormalized_ornstein_multinoise", 0, 12, 23, i); __PYX_ERR(0, 4263, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 23: + values[22] = __Pyx_ArgRef_FASTCALL(__pyx_args, 22); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[22])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 4263, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4263, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4263, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":4280 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[18]) values[18] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[19]) values[19] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":4283 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[22]) values[22] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_vh = ((PyArrayObject *)values[0]); + __pyx_v_vl1 = ((PyArrayObject *)values[1]); + __pyx_v_vl2 = ((PyArrayObject *)values[2]); + __pyx_v_a = ((PyArrayObject *)values[3]); + __pyx_v_zh = ((PyArrayObject *)values[4]); + __pyx_v_zl1 = ((PyArrayObject *)values[5]); + __pyx_v_zl2 = ((PyArrayObject *)values[6]); + __pyx_v_d = ((PyArrayObject *)values[7]); + __pyx_v_g = ((PyArrayObject *)values[8]); + __pyx_v_t = ((PyArrayObject *)values[9]); + __pyx_v_deadline = ((PyArrayObject *)values[10]); + __pyx_v_s = ((PyArrayObject *)values[11]); + if (values[12]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[12]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4275, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[13]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[13]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4276, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[14]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[14]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4277, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[15]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[15]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4278, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_print_info = values[16]; + __pyx_v_boundary_fun = values[17]; + __pyx_v_boundary_multiplicative = values[18]; + __pyx_v_boundary_params = values[19]; + __pyx_v_random_state = values[20]; + __pyx_v_return_option = values[21]; + __pyx_v_smooth_unif = values[22]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_flexbound_mic2_unnormalized_ornstein_multinoise", 0, 12, 23, __pyx_nargs); __PYX_ERR(0, 4263, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_flexbound_mic2_unnormalized_ornstein_multinoise", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vh", 0))) __PYX_ERR(0, 4263, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl1", 0))) __PYX_ERR(0, 4264, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl2", 0))) __PYX_ERR(0, 4265, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 4266, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zh", 0))) __PYX_ERR(0, 4267, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl1", 0))) __PYX_ERR(0, 4268, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl2", 0))) __PYX_ERR(0, 4269, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_d), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "d", 0))) __PYX_ERR(0, 4270, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_g), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "g", 0))) __PYX_ERR(0, 4271, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 4272, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 4273, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 4274, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_40ddm_flexbound_mic2_unnormalized_ornstein_multinoise(__pyx_self, __pyx_v_vh, __pyx_v_vl1, __pyx_v_vl2, __pyx_v_a, __pyx_v_zh, __pyx_v_zl1, __pyx_v_zl2, __pyx_v_d, __pyx_v_g, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_print_info, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":4263 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_unnormalized_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_40ddm_flexbound_mic2_unnormalized_ornstein_multinoise(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_g, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_vh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_d_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_g_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + PyObject *__pyx_v_rts_low = NULL; + PyObject *__pyx_v_rts_high = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_high_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_rts_low_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_bias_trace_l1 = NULL; + PyObject *__pyx_v_bias_trace_l2 = NULL; + __Pyx_memviewslice __pyx_v_bias_trace_l1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_bias_trace_l2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y_h; + float __pyx_v_y_l; + float __pyx_v_y_l1; + float __pyx_v_y_l2; + float __pyx_v_t_h; + float __pyx_v_t_l; + float __pyx_v_t_l1; + float __pyx_v_t_l2; + CYTHON_UNUSED float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_ix1; + Py_ssize_t __pyx_v_ix2; + CYTHON_UNUSED Py_ssize_t __pyx_v_ix_l; + Py_ssize_t __pyx_v_ix1_tmp; + Py_ssize_t __pyx_v_ix2_tmp; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + PyObject *__pyx_9genexpr15__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_d; + __Pyx_Buffer __pyx_pybuffer_d; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_g; + __Pyx_Buffer __pyx_pybuffer_g; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vh; + __Pyx_Buffer __pyx_pybuffer_vh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl1; + __Pyx_Buffer __pyx_pybuffer_vl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl2; + __Pyx_Buffer __pyx_pybuffer_vl2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zh; + __Pyx_Buffer __pyx_pybuffer_zh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl1; + __Pyx_Buffer __pyx_pybuffer_zl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl2; + __Pyx_Buffer __pyx_pybuffer_zl2; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + Py_ssize_t __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + int __pyx_t_20; + Py_ssize_t __pyx_t_21; + PyObject *__pyx_t_22 = NULL; + Py_ssize_t __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + float __pyx_t_26; + Py_ssize_t __pyx_t_27; + int __pyx_t_28; + Py_ssize_t __pyx_t_29; + Py_ssize_t __pyx_t_30; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_flexbound_mic2_unnormalized_ornstein_multinoise", 0); + __pyx_pybuffer_vh.pybuffer.buf = NULL; + __pyx_pybuffer_vh.refcount = 0; + __pyx_pybuffernd_vh.data = NULL; + __pyx_pybuffernd_vh.rcbuffer = &__pyx_pybuffer_vh; + __pyx_pybuffer_vl1.pybuffer.buf = NULL; + __pyx_pybuffer_vl1.refcount = 0; + __pyx_pybuffernd_vl1.data = NULL; + __pyx_pybuffernd_vl1.rcbuffer = &__pyx_pybuffer_vl1; + __pyx_pybuffer_vl2.pybuffer.buf = NULL; + __pyx_pybuffer_vl2.refcount = 0; + __pyx_pybuffernd_vl2.data = NULL; + __pyx_pybuffernd_vl2.rcbuffer = &__pyx_pybuffer_vl2; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_zh.pybuffer.buf = NULL; + __pyx_pybuffer_zh.refcount = 0; + __pyx_pybuffernd_zh.data = NULL; + __pyx_pybuffernd_zh.rcbuffer = &__pyx_pybuffer_zh; + __pyx_pybuffer_zl1.pybuffer.buf = NULL; + __pyx_pybuffer_zl1.refcount = 0; + __pyx_pybuffernd_zl1.data = NULL; + __pyx_pybuffernd_zl1.rcbuffer = &__pyx_pybuffer_zl1; + __pyx_pybuffer_zl2.pybuffer.buf = NULL; + __pyx_pybuffer_zl2.refcount = 0; + __pyx_pybuffernd_zl2.data = NULL; + __pyx_pybuffernd_zl2.rcbuffer = &__pyx_pybuffer_zl2; + __pyx_pybuffer_d.pybuffer.buf = NULL; + __pyx_pybuffer_d.refcount = 0; + __pyx_pybuffernd_d.data = NULL; + __pyx_pybuffernd_d.rcbuffer = &__pyx_pybuffer_d; + __pyx_pybuffer_g.pybuffer.buf = NULL; + __pyx_pybuffer_g.refcount = 0; + __pyx_pybuffernd_g.data = NULL; + __pyx_pybuffernd_g.rcbuffer = &__pyx_pybuffer_g; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vh.rcbuffer->pybuffer, (PyObject*)__pyx_v_vh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_vh.diminfo[0].strides = __pyx_pybuffernd_vh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vh.diminfo[0].shape = __pyx_pybuffernd_vh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_vl1.diminfo[0].strides = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl1.diminfo[0].shape = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_vl2.diminfo[0].strides = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl2.diminfo[0].shape = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zh.rcbuffer->pybuffer, (PyObject*)__pyx_v_zh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_zh.diminfo[0].strides = __pyx_pybuffernd_zh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zh.diminfo[0].shape = __pyx_pybuffernd_zh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_zl1.diminfo[0].strides = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl1.diminfo[0].shape = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_zl2.diminfo[0].strides = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl2.diminfo[0].shape = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_d.rcbuffer->pybuffer, (PyObject*)__pyx_v_d, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_d.diminfo[0].strides = __pyx_pybuffernd_d.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_d.diminfo[0].shape = __pyx_pybuffernd_d.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_g.rcbuffer->pybuffer, (PyObject*)__pyx_v_g, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_g.diminfo[0].strides = __pyx_pybuffernd_g.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_g.diminfo[0].shape = __pyx_pybuffernd_g.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4263, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":4348 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:] vh_view = vh +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4348, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":4350 + * set_seed(random_state) + * # Param views + * cdef float[:] vh_view = vh # <<<<<<<<<<<<<< + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4350, __pyx_L1_error) + __pyx_v_vh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4351 + * # Param views + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 # <<<<<<<<<<<<<< + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4351, __pyx_L1_error) + __pyx_v_vl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4352 + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4352, __pyx_L1_error) + __pyx_v_vl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4353 + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4353, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4354 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh # <<<<<<<<<<<<<< + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4354, __pyx_L1_error) + __pyx_v_zh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4355 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 # <<<<<<<<<<<<<< + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4355, __pyx_L1_error) + __pyx_v_zl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4356 + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 # <<<<<<<<<<<<<< + * cdef float[:] d_view = d + * cdef float[:] g_view = g +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4356, __pyx_L1_error) + __pyx_v_zl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4357 + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d # <<<<<<<<<<<<<< + * cdef float[:] g_view = g + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_d), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4357, __pyx_L1_error) + __pyx_v_d_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4358 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d + * cdef float[:] g_view = g # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_g), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4358, __pyx_L1_error) + __pyx_v_g_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4359 + * cdef float[:] d_view = d + * cdef float[:] g_view = g + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4359, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4360 + * cdef float[:] g_view = g + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4360, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4361 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4361, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4363 + * cdef float[:] s_view = s + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 4363, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 4363, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4363, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4363, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4363, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4364 + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 4364, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 4364, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4364, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4364, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4364, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4365 + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = PyTuple_New(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 4365, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_3) != (0)) __PYX_ERR(0, 4365, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4365, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4365, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4365, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_low = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4366 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * rts_low = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 4366, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 4366, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4366, __pyx_L1_error); + __pyx_t_7 = 0; + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_6}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4366, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4366, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts_high = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4368 + * rts_high = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 4368, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":4369 + * + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_high, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 4369, __pyx_L1_error) + __pyx_v_rts_high_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":4370 + * cdef float[:, :, :] rts_view = rts + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts_low, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 4370, __pyx_L1_error) + __pyx_v_rts_low_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":4371 + * cdef float[:, :, :] rts_high_view = rts_high + * cdef float[:, :, :] rts_low_view = rts_low + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 4371, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":4373 + * cdef int[:, :, :] choices_view = choices + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyLong_AddObjC(__pyx_t_7, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyTuple_New(2); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_6) != (0)) __PYX_ERR(0, 4373, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 4373, __pyx_L1_error); + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4373, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4373, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4374 + * + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 4374, __pyx_L1_error) + + /* "cssm.pyx":4375 + * traj = np.zeros((int(max_t / delta_t) + 1, 3), dtype = DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 4375, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":4377 + * cdef float[:, :] traj_view = traj + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":4381 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":4382 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_6, __pyx_mstate_global->__pyx_int_0, __pyx_t_7, __pyx_t_12}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_5 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4382, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4383 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_12, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4383, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4383, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4384 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * # Y particle trace +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4384, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4387 + * + * # Y particle trace + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) # <<<<<<<<<<<<<< + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_num_draws); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4387, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4387, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_bias_trace_l1 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4388 + * # Y particle trace + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] bias_trace_l1_view = bias_trace_l1 + * cdef float[:] bias_trace_l2_view = bias_trace_l2 +*/ + __pyx_t_12 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_num_draws); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_12 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_12); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_12); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_12, __pyx_t_4}; + __pyx_t_5 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_5, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4388, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_5); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4388, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_bias_trace_l2 = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4389 + * bias_trace_l1 = np.zeros(num_draws, dtype = DTYPE) + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 # <<<<<<<<<<<<<< + * cdef float[:] bias_trace_l2_view = bias_trace_l2 + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_bias_trace_l1, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4389, __pyx_L1_error) + __pyx_v_bias_trace_l1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4390 + * bias_trace_l2 = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_l1_view = bias_trace_l1 + * cdef float[:] bias_trace_l2_view = bias_trace_l2 # <<<<<<<<<<<<<< + * + * cdef float y_h, y_l, y_l1, y_l2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_bias_trace_l2, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4390, __pyx_L1_error) + __pyx_v_bias_trace_l2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4396 + * cdef float t_h, t_l, t_l1, t_l2, smooth_u, deadline_tmp, sqrt_st + * cdef Py_ssize_t n, ix, ix1, ix2, ix_l, ix_tmp, ix1_tmp, ix2_tmp, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":4397 + * cdef Py_ssize_t n, ix, ix1, ix2, ix_l, ix_tmp, ix1_tmp, ix2_tmp, k + * cdef Py_ssize_t m = 0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4397, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4399 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_13 = __pyx_v_n_trials; + __pyx_t_14 = __pyx_t_13; + for (__pyx_t_15 = 0; __pyx_t_15 < __pyx_t_14; __pyx_t_15+=1) { + __pyx_v_k = __pyx_t_15; + + /* "cssm.pyx":4401 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4401, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_16 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 4401, __pyx_L7_error) + } + __pyx_t_5 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_17), (&__pyx_t_18)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4401, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_3); + __pyx_t_3 = __pyx_t_5; + __pyx_t_5 = 0; + while (1) { + __pyx_t_19 = __Pyx_dict_iter_next(__pyx_t_3, __pyx_t_17, &__pyx_t_16, &__pyx_t_5, NULL, NULL, __pyx_t_18); + if (unlikely(__pyx_t_19 == 0)) break; + if (unlikely(__pyx_t_19 == -1)) __PYX_ERR(0, 4401, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_XDECREF_SET(__pyx_9genexpr15__pyx_v_key, __pyx_t_5); + __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_9genexpr15__pyx_v_key); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4401, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_GetItemInt(__pyx_t_5, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4401, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_9genexpr15__pyx_v_key, (PyObject*)__pyx_t_7))) __PYX_ERR(0, 4401, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + } + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_9genexpr15__pyx_v_key); __pyx_9genexpr15__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_9genexpr15__pyx_v_key); __pyx_9genexpr15__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":4404 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 4404, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":4405 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_12 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_4 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_22 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + if (PyDict_SetItem(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 4405, __pyx_L1_error) + __pyx_t_6 = __pyx_t_22; + __pyx_t_22 = 0; + if (__Pyx_MergeKeywords(__pyx_t_6, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 4405, __pyx_L1_error) + __pyx_t_22 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_6); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_12))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_12); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_12); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_12, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_5, __pyx_t_4, __pyx_t_22}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_12, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_3 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_t_12}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4405, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 4405, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":4404 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":4407 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_22, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_21 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_22)) __PYX_ERR(0, 4407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_22); + __pyx_t_6 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 4407, __pyx_L1_error) + __pyx_t_5 = __pyx_t_6; + __pyx_t_6 = 0; + if (__Pyx_MergeKeywords(__pyx_t_5, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 4407, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, __pyx_t_22, __pyx_t_6}; + __pyx_t_12 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_22); __pyx_t_22 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + } + __pyx_t_7 = __pyx_t_12; + __Pyx_INCREF(__pyx_t_7); + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_7, __pyx_t_4}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4407, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 4407, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":4409 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_k; + __pyx_t_24 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_21 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_25 = __pyx_v_max_t; + __pyx_t_20 = (__pyx_t_24 < __pyx_t_25); + if (__pyx_t_20) { + __pyx_t_26 = __pyx_t_24; + } else { + __pyx_t_26 = __pyx_t_25; + } + __pyx_v_deadline_tmp = __pyx_t_26; + + /* "cssm.pyx":4410 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_23 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":4412 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension +*/ + __pyx_t_18 = __pyx_v_n_samples; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_19; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":4413 + * # Loop over samples + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice # <<<<<<<<<<<<<< + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) = 0; + + /* "cssm.pyx":4414 + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension # <<<<<<<<<<<<<< + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) +*/ + __pyx_v_t_h = 0.0; + + /* "cssm.pyx":4415 + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension # <<<<<<<<<<<<<< + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) +*/ + __pyx_v_t_l = 0.0; + + /* "cssm.pyx":4416 + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) # <<<<<<<<<<<<<< + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index +*/ + __pyx_v_t_l1 = 0.0; + + /* "cssm.pyx":4417 + * t_l = 0 # reset time low dimension + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) +*/ + __pyx_v_t_l2 = 0.0; + + /* "cssm.pyx":4418 + * t_l1 = 0 # reset time low dimension (1) + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * ix1 = 0 # reset boundary index (1) + * ix2 = 0 # reset boundary index (2) +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":4419 + * t_l2 = 0 # reset time low dimension (2) + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) # <<<<<<<<<<<<<< + * ix2 = 0 # reset boundary index (2) + * +*/ + __pyx_v_ix1 = 0; + + /* "cssm.pyx":4420 + * ix = 0 # reset boundary index + * ix1 = 0 # reset boundary index (1) + * ix2 = 0 # reset boundary index (2) # <<<<<<<<<<<<<< + * + * # Initialize walkers +*/ + __pyx_v_ix2 = 0; + + /* "cssm.pyx":4424 + * # Initialize walkers + * # Particle + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2)) +*/ + __pyx_t_27 = 0; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_v_y_h = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zh_view.data + __pyx_t_21 * __pyx_v_zh_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":4426 + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2)) # <<<<<<<<<<<<<< + * bias_trace_l1_view[0] = boundary_view[0] - bias_trace_l2_view[0] + * +*/ + __pyx_t_23 = 0; + __pyx_t_21 = 0; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) / 2.0); + + /* "cssm.pyx":4427 + * # Relative particle position (used as resource allocator for low dim choice) + * bias_trace_l2_view[0] = ((y_h + boundary_view[0]) / (2)) + * bias_trace_l1_view[0] = boundary_view[0] - bias_trace_l2_view[0] # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_t_23 = 0; + __pyx_t_21 = 0; + __pyx_t_27 = 0; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_27 * __pyx_v_bias_trace_l1_view.strides[0]) )) = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )))); + + /* "cssm.pyx":4429 + * bias_trace_l1_view[0] = boundary_view[0] - bias_trace_l2_view[0] + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":4430 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":4431 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y_h # <<<<<<<<<<<<<< + * + * # Random walks until y_h hits bound +*/ + __pyx_t_21 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_h; + + /* "cssm.pyx":4430 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y_h + * +*/ + } + + /* "cssm.pyx":4429 + * bias_trace_l1_view[0] = boundary_view[0] - bias_trace_l2_view[0] + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y_h +*/ + } + + /* "cssm.pyx":4434 + * + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): # <<<<<<<<<<<<<< + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2)) +*/ + while (1) { + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix; + __pyx_t_28 = (__pyx_v_y_h <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L18_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_h <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L18_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":4435 + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2)) + * bias_trace_l1_view[ix] = boundary_view[ix] - bias_trace_l2_view[ix] +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = __pyx_v_m; + __pyx_v_y_h = (__pyx_v_y_h + (((*((float *) ( /* dim=0 */ (__pyx_v_vh_view.data + __pyx_t_23 * __pyx_v_vh_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_21 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":4436 + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2)) # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix] = boundary_view[ix] - bias_trace_l2_view[ix] + * t_h += delta_t +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_23 = __pyx_v_ix; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) / 2.0); + + /* "cssm.pyx":4437 + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2)) + * bias_trace_l1_view[ix] = boundary_view[ix] - bias_trace_l2_view[ix] # <<<<<<<<<<<<<< + * t_h += delta_t + * ix += 1 +*/ + __pyx_t_21 = __pyx_v_ix; + __pyx_t_23 = __pyx_v_ix; + __pyx_t_27 = __pyx_v_ix; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_27 * __pyx_v_bias_trace_l1_view.strides[0]) )) = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )))); + + /* "cssm.pyx":4438 + * bias_trace_l2_view[ix] = ((y_h + boundary_view[ix]) / (2)) + * bias_trace_l1_view[ix] = boundary_view[ix] - bias_trace_l2_view[ix] + * t_h += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_h = (__pyx_v_t_h + __pyx_v_delta_t); + + /* "cssm.pyx":4439 + * bias_trace_l1_view[ix] = boundary_view[ix] - bias_trace_l2_view[ix] + * t_h += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":4440 + * t_h += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":4441 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":4442 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4442, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4443 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":4441 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":4450 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":4451 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4451, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":4452 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":4451 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above +*/ + } + + /* "cssm.pyx":4450 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 2 +*/ + goto __pyx_L22; + } + + /* "cssm.pyx":4454 + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4454, __pyx_L1_error) + __pyx_t_27 = __pyx_v_ix; + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":4455 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":4454 + * choices_view[n, k, 0] += 2 + * # Otherwise, apply rule from above + * elif random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + } + __pyx_L22:; + + /* "cssm.pyx":4457 + * choices_view[n, k, 0] += 2 + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * +*/ + __pyx_t_23 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_v_y_l2 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl2_view.data + __pyx_t_27 * __pyx_v_zl2_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":4458 + * + * y_l2 = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * + * if choices_view[n, k, 0] == 0: +*/ + __pyx_t_21 = 0; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_v_y_l1 = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl1_view.data + __pyx_t_27 * __pyx_v_zl1_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":4460 + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # Fill bias trace a until max_rt reached + * ix1_tmp = ix + 1 +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":4462 + * if choices_view[n, k, 0] == 0: + * # Fill bias trace a until max_rt reached + * ix1_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 +*/ + __pyx_v_ix1_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":4463 + * # Fill bias trace a until max_rt reached + * ix1_tmp = ix + 1 + * while ix1_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 +*/ + while (1) { + __pyx_t_20 = (__pyx_v_ix1_tmp < __pyx_v_num_draws); + if (!__pyx_t_20) break; + + /* "cssm.pyx":4464 + * ix1_tmp = ix + 1 + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix1_tmp] = 1.0 + * ix1_tmp += 1 +*/ + __pyx_t_21 = __pyx_v_ix1_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )) = 0.0; + + /* "cssm.pyx":4465 + * while ix1_tmp < num_draws: + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 # <<<<<<<<<<<<<< + * ix1_tmp += 1 + * +*/ + __pyx_t_21 = __pyx_v_ix1_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) )) = 1.0; + + /* "cssm.pyx":4466 + * bias_trace_l2_view[ix1_tmp] = 0.0 + * bias_trace_l1_view[ix1_tmp] = 1.0 + * ix1_tmp += 1 # <<<<<<<<<<<<<< + * + * else: # Store intermediate choice +*/ + __pyx_v_ix1_tmp = (__pyx_v_ix1_tmp + 1); + } + + /* "cssm.pyx":4460 + * y_l1 = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * + * if choices_view[n, k, 0] == 0: # <<<<<<<<<<<<<< + * # Fill bias trace a until max_rt reached + * ix1_tmp = ix + 1 +*/ + goto __pyx_L24; + } + + /* "cssm.pyx":4470 + * else: # Store intermediate choice + * # Fill bias tracea until max_rt reached + * ix2_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 +*/ + /*else*/ { + __pyx_v_ix2_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":4471 + * # Fill bias tracea until max_rt reached + * ix2_tmp = ix + 1 + * while ix2_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 +*/ + while (1) { + __pyx_t_20 = (__pyx_v_ix2_tmp < __pyx_v_num_draws); + if (!__pyx_t_20) break; + + /* "cssm.pyx":4472 + * ix2_tmp = ix + 1 + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 # <<<<<<<<<<<<<< + * bias_trace_l1_view[ix2_tmp] = 0.0 + * ix2_tmp += 1 +*/ + __pyx_t_21 = __pyx_v_ix2_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) )) = 1.0; + + /* "cssm.pyx":4473 + * while ix2_tmp < num_draws: + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 # <<<<<<<<<<<<<< + * ix2_tmp += 1 + * +*/ + __pyx_t_21 = __pyx_v_ix2_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) )) = 0.0; + + /* "cssm.pyx":4474 + * bias_trace_l2_view[ix2_tmp] = 1.0 + * bias_trace_l1_view[ix2_tmp] = 0.0 + * ix2_tmp += 1 # <<<<<<<<<<<<<< + * + * # lower level random walker (1) +*/ + __pyx_v_ix2_tmp = (__pyx_v_ix2_tmp + 1); + } + } + __pyx_L24:; + + /* "cssm.pyx":4477 + * + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < boundary_view[ix1]) and (bias_trace_l1_view[ix1] > 0): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) ))) == 0) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":4478 + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): # <<<<<<<<<<<<<< + * if (bias_trace_l1_view[ix1] < boundary_view[ix1]) and (bias_trace_l1_view[ix1] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) +*/ + while (1) { + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L32_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_28 = (__pyx_v_y_l1 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L32_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l1 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L32_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":4479 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < boundary_view[ix1]) and (bias_trace_l1_view[ix1] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) +*/ + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) ))) < (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L36_bool_binop_done; + } + __pyx_t_27 = __pyx_v_ix1; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_27 * __pyx_v_bias_trace_l1_view.strides[0]) ))) > 0.0); + __pyx_t_20 = __pyx_t_28; + __pyx_L36_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":4481 + * if (bias_trace_l1_view[ix1] < boundary_view[ix1]) and (bias_trace_l1_view[ix1] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) * bias_trace_l1_view[ix1] +*/ + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = __pyx_v_ix1; + __pyx_t_21 = __pyx_v_k; + __pyx_t_29 = __pyx_v_k; + __pyx_v_y_l1 = (__pyx_v_y_l1 + (((((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_27 * __pyx_v_vl1_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_23 * __pyx_v_bias_trace_l1_view.strides[0]) )))) * (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_21 * __pyx_v_d_view.strides[0]) ))))) - ((*((float *) ( /* dim=0 */ (__pyx_v_g_view.data + __pyx_t_29 * __pyx_v_g_view.strides[0]) ))) * __pyx_v_y_l1)) * __pyx_v_delta_t)); + + /* "cssm.pyx":4483 + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) * bias_trace_l1_view[ix1] # <<<<<<<<<<<<<< + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) +*/ + __pyx_t_29 = __pyx_v_m; + __pyx_t_21 = __pyx_v_ix1; + __pyx_v_y_l1 = (__pyx_v_y_l1 + ((__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_29 * __pyx_v_gaussian_values.strides[0]) )))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l1_view.data + __pyx_t_21 * __pyx_v_bias_trace_l1_view.strides[0]) ))))); + + /* "cssm.pyx":4479 + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < boundary_view[ix1]) and (bias_trace_l1_view[ix1] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l1 += (((vl1_view[k] * bias_trace_l1_view[ix1] * (1 - d_view[k])) - (g_view[k] * y_l1)) * delta_t) +*/ + goto __pyx_L35; + } + + /* "cssm.pyx":4486 + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) + * y_l1 += (vl1_view[k] * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) +*/ + /*else*/ { + __pyx_t_21 = __pyx_v_k; + __pyx_v_y_l1 = (__pyx_v_y_l1 + ((*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_21 * __pyx_v_vl1_view.strides[0]) ))) * __pyx_v_delta_t)); + + /* "cssm.pyx":4488 + * y_l1 += (vl1_view[k] * delta_t) + * # add gaussian displacement + * y_l1 += (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * + * # propagate time and indices +*/ + __pyx_t_21 = __pyx_v_m; + __pyx_v_y_l1 = (__pyx_v_y_l1 + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_21 * __pyx_v_gaussian_values.strides[0]) ))))); + } + __pyx_L35:; + + /* "cssm.pyx":4491 + * + * # propagate time and indices + * t_l1 += delta_t # <<<<<<<<<<<<<< + * ix1 += 1 + * m += 1 +*/ + __pyx_v_t_l1 = (__pyx_v_t_l1 + __pyx_v_delta_t); + + /* "cssm.pyx":4492 + * # propagate time and indices + * t_l1 += delta_t + * ix1 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix1 = (__pyx_v_ix1 + 1); + + /* "cssm.pyx":4493 + * t_l1 += delta_t + * ix1 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":4494 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":4495 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4495, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4496 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":4494 + * ix1 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":4498 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":4499 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":4500 + * if n == 0: + * if k == 0: + * traj_view[ix1, 1] = y_l1 # <<<<<<<<<<<<<< + * + * # lower level random walker (2) +*/ + __pyx_t_21 = __pyx_v_ix1; + __pyx_t_29 = 1; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_21 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_29 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l1; + + /* "cssm.pyx":4499 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix1, 1] = y_l1 + * +*/ + } + + /* "cssm.pyx":4498 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix1, 1] = y_l1 +*/ + } + } + + /* "cssm.pyx":4477 + * + * # lower level random walker (1) + * if (choices_view[n, k, 0] == 0) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l1 >= ((-1) * boundary_view[ix1])) and (y_l1 <= boundary_view[ix1]) and (t_l1 <= deadline_tmp): + * if (bias_trace_l1_view[ix1] < boundary_view[ix1]) and (bias_trace_l1_view[ix1] > 0): +*/ + } + + /* "cssm.pyx":4503 + * + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < boundary_view[ix2]) and (bias_trace_l2_view[ix2] > 0): +*/ + __pyx_t_29 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_20 = (((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_29 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) ))) == 2) | ((__pyx_v_n == 0) & (__pyx_v_k == 0))); + if (__pyx_t_20) { + + /* "cssm.pyx":4504 + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): # <<<<<<<<<<<<<< + * if (bias_trace_l2_view[ix2] < boundary_view[ix2]) and (bias_trace_l2_view[ix2] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) +*/ + while (1) { + __pyx_t_23 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L44_bool_binop_done; + } + __pyx_t_23 = __pyx_v_ix2; + __pyx_t_28 = (__pyx_v_y_l2 <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L44_bool_binop_done; + } + __pyx_t_28 = (__pyx_v_t_l2 <= __pyx_v_deadline_tmp); + __pyx_t_20 = __pyx_t_28; + __pyx_L44_bool_binop_done:; + if (!__pyx_t_20) break; + + /* "cssm.pyx":4505 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < boundary_view[ix2]) and (bias_trace_l2_view[ix2] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) +*/ + __pyx_t_23 = __pyx_v_ix2; + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) ))) < (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_28) { + } else { + __pyx_t_20 = __pyx_t_28; + goto __pyx_L48_bool_binop_done; + } + __pyx_t_21 = __pyx_v_ix2; + __pyx_t_28 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_21 * __pyx_v_bias_trace_l2_view.strides[0]) ))) > 0.0); + __pyx_t_20 = __pyx_t_28; + __pyx_L48_bool_binop_done:; + if (__pyx_t_20) { + + /* "cssm.pyx":4507 + * if (bias_trace_l2_view[ix2] < boundary_view[ix2]) and (bias_trace_l2_view[ix2] > 0): + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) * bias_trace_l2_view[ix2] +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_23 = __pyx_v_ix2; + __pyx_t_29 = __pyx_v_k; + __pyx_t_27 = __pyx_v_k; + __pyx_v_y_l2 = (__pyx_v_y_l2 + (((((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_21 * __pyx_v_vl2_view.strides[0]) ))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_23 * __pyx_v_bias_trace_l2_view.strides[0]) )))) * (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_29 * __pyx_v_d_view.strides[0]) ))))) - ((*((float *) ( /* dim=0 */ (__pyx_v_g_view.data + __pyx_t_27 * __pyx_v_g_view.strides[0]) ))) * __pyx_v_y_l2)) * __pyx_v_delta_t)); + + /* "cssm.pyx":4509 + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) * bias_trace_l2_view[ix2] # <<<<<<<<<<<<<< + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) +*/ + __pyx_t_27 = __pyx_v_m; + __pyx_t_29 = __pyx_v_ix2; + __pyx_v_y_l2 = (__pyx_v_y_l2 + ((__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_27 * __pyx_v_gaussian_values.strides[0]) )))) * (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_l2_view.data + __pyx_t_29 * __pyx_v_bias_trace_l2_view.strides[0]) ))))); + + /* "cssm.pyx":4505 + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < boundary_view[ix2]) and (bias_trace_l2_view[ix2] > 0): # <<<<<<<<<<<<<< + * # main propagation if bias_trace is between 0 and 1 (high level choice is not yet made) + * y_l2 += (((vl2_view[k] * bias_trace_l2_view[ix2] * (1 - d_view[k])) - (g_view[k] * y_l2)) * delta_t) +*/ + goto __pyx_L47; + } + + /* "cssm.pyx":4512 + * else: + * # main propagation if bias_trace is not between 0 and 1 (high level choice is already made) + * y_l2 += (vl2_view[k] * delta_t) # <<<<<<<<<<<<<< + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) +*/ + /*else*/ { + __pyx_t_29 = __pyx_v_k; + __pyx_v_y_l2 = (__pyx_v_y_l2 + ((*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_29 * __pyx_v_vl2_view.strides[0]) ))) * __pyx_v_delta_t)); + + /* "cssm.pyx":4514 + * y_l2 += (vl2_view[k] * delta_t) + * # add gaussian displacement + * y_l2 += (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * + * # propagate time and indices +*/ + __pyx_t_29 = __pyx_v_m; + __pyx_v_y_l2 = (__pyx_v_y_l2 + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_29 * __pyx_v_gaussian_values.strides[0]) ))))); + } + __pyx_L47:; + + /* "cssm.pyx":4517 + * + * # propagate time and indices + * t_l2 += delta_t # <<<<<<<<<<<<<< + * ix2 += 1 + * m += 1 +*/ + __pyx_v_t_l2 = (__pyx_v_t_l2 + __pyx_v_delta_t); + + /* "cssm.pyx":4518 + * # propagate time and indices + * t_l2 += delta_t + * ix2 += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix2 = (__pyx_v_ix2 + 1); + + /* "cssm.pyx":4519 + * t_l2 += delta_t + * ix2 += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":4520 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_20 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_20) { + + /* "cssm.pyx":4521 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4521, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4522 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":4520 + * ix2 += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":4524 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + __pyx_t_20 = (__pyx_v_n == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":4525 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + __pyx_t_20 = (__pyx_v_k == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":4526 + * if n == 0: + * if k == 0: + * traj_view[ix2, 2] = y_l2 # <<<<<<<<<<<<<< + * + * # Get back to single y_l and t_l +*/ + __pyx_t_29 = __pyx_v_ix2; + __pyx_t_27 = 2; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_29 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_27 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y_l2; + + /* "cssm.pyx":4525 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix2, 2] = y_l2 + * +*/ + } + + /* "cssm.pyx":4524 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix2, 2] = y_l2 +*/ + } + } + + /* "cssm.pyx":4503 + * + * # lower level random walker (2) + * if (choices_view[n, k, 0] == 2) | ((n == 0) & (k == 0)): # <<<<<<<<<<<<<< + * while (y_l2 >= ((-1) * boundary_view[ix2])) and (y_l2 <= boundary_view[ix2]) and (t_l2 <= deadline_tmp): + * if (bias_trace_l2_view[ix2] < boundary_view[ix2]) and (bias_trace_l2_view[ix2] > 0): +*/ + } + + /* "cssm.pyx":4529 + * + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + __pyx_t_27 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_23 = 0; + __pyx_t_20 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_27 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_29 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) ))) == 0); + if (__pyx_t_20) { + + /* "cssm.pyx":4530 + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 # <<<<<<<<<<<<<< + * y_l = y_l1 + * ix_l = ix1 +*/ + __pyx_v_t_l = __pyx_v_t_l1; + + /* "cssm.pyx":4531 + * if (choices_view[n, k, 0] == 0): + * t_l = t_l1 + * y_l = y_l1 # <<<<<<<<<<<<<< + * ix_l = ix1 + * else: +*/ + __pyx_v_y_l = __pyx_v_y_l1; + + /* "cssm.pyx":4532 + * t_l = t_l1 + * y_l = y_l1 + * ix_l = ix1 # <<<<<<<<<<<<<< + * else: + * t_l = t_l2 +*/ + __pyx_v_ix_l = __pyx_v_ix1; + + /* "cssm.pyx":4529 + * + * # Get back to single y_l and t_l + * if (choices_view[n, k, 0] == 0): # <<<<<<<<<<<<<< + * t_l = t_l1 + * y_l = y_l1 +*/ + goto __pyx_L53; + } + + /* "cssm.pyx":4534 + * ix_l = ix1 + * else: + * t_l = t_l2 # <<<<<<<<<<<<<< + * y_l = y_l2 + * ix_l = ix2 +*/ + /*else*/ { + __pyx_v_t_l = __pyx_v_t_l2; + + /* "cssm.pyx":4535 + * else: + * t_l = t_l2 + * y_l = y_l2 # <<<<<<<<<<<<<< + * ix_l = ix2 + * +*/ + __pyx_v_y_l = __pyx_v_y_l2; + + /* "cssm.pyx":4536 + * t_l = t_l2 + * y_l = y_l2 + * ix_l = ix2 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_ix_l = __pyx_v_ix2; + } + __pyx_L53:; + + /* "cssm.pyx":4538 + * ix_l = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_20 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 4538, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":4539 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + __pyx_t_20 = (__pyx_v_t_h == 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":4540 + * if smooth_unif: + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4540, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":4539 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + goto __pyx_L55; + } + + /* "cssm.pyx":4541 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_20 = (fmax(__pyx_v_t_h, __pyx_v_t_l) < __pyx_v_deadline_tmp); + if (__pyx_t_20) { + + /* "cssm.pyx":4542 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4542, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":4541 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L55; + } + + /* "cssm.pyx":4544 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L55:; + + /* "cssm.pyx":4538 + * ix_l = ix2 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L54; + } + + /* "cssm.pyx":4546 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L54:; + + /* "cssm.pyx":4548 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] # <<<<<<<<<<<<<< + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_29 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) )) = (fmax(__pyx_v_t_h, __pyx_v_t_l) + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":4549 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + * rts_high_view[n, k, 0] = t_h + t_view[k] # <<<<<<<<<<<<<< + * rts_low_view[n, k, 0] = t_l + t_view[k] + * +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_high_view.data + __pyx_t_21 * __pyx_v_rts_high_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_high_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_high_view.strides[2]) )) = (__pyx_v_t_h + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":4550 + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] + * rts_high_view[n, k, 0] = t_h + t_view[k] + * rts_low_view[n, k, 0] = t_l + t_view[k] # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_29 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_low_view.data + __pyx_t_29 * __pyx_v_rts_low_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_low_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_low_view.strides[2]) )) = (__pyx_v_t_l + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":4557 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + __pyx_t_23 = __pyx_v_ix; + __pyx_t_20 = ((*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_23 * __pyx_v_boundary_view.strides[0]) ))) <= 0.0); + if (__pyx_t_20) { + + /* "cssm.pyx":4558 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4558, __pyx_L1_error) + __pyx_t_20 = (__pyx_t_26 <= 0.5); + if (__pyx_t_20) { + + /* "cssm.pyx":4559 + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_21 = __pyx_v_k; + __pyx_t_27 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_21 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":4558 + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: + * if random_uniform() <= 0.5: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above +*/ + } + + /* "cssm.pyx":4557 + * + * # If boundary is negative (or 0) already, we flip a coin + * if boundary_view[ix] <= 0: # <<<<<<<<<<<<<< + * if random_uniform() <= 0.5: + * choices_view[n, k, 0] += 1 +*/ + goto __pyx_L56; + } + + /* "cssm.pyx":4561 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4561, __pyx_L1_error) + __pyx_t_27 = __pyx_v_ix; + __pyx_t_21 = __pyx_v_ix; + __pyx_t_20 = (__pyx_t_26 <= ((__pyx_v_y_l + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_27 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_21 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_20) { + + /* "cssm.pyx":4562 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_21 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_21 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_27 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":4561 + * choices_view[n, k, 0] += 1 + * # Otherwise apply rule from above + * elif random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + } + __pyx_L56:; + + /* "cssm.pyx":4564 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_27 = __pyx_v_k; + __pyx_t_21 = 0; + __pyx_t_29 = __pyx_v_k; + __pyx_t_30 = __pyx_v_k; + __pyx_t_20 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_23 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_27 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_29 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_30 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_20) { + + /* "cssm.pyx":4565 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_30 = __pyx_v_n; + __pyx_t_29 = __pyx_v_k; + __pyx_t_21 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_30 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_21 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":4564 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":4567 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 4567, __pyx_L1_error) + if (__pyx_t_20) { + + /* "cssm.pyx":4568 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, # <<<<<<<<<<<<<< + * 'metadata': {'vh': vh, + * 'vl1': vl1, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4568, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4568, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4568, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 4568, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 4568, __pyx_L1_error) + + /* "cssm.pyx":4569 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, # <<<<<<<<<<<<<< + * 'vl1': vl1, + * 'vl2': vl2, +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4569, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vh, ((PyObject *)__pyx_v_vh)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4570 + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, + * 'vl1': vl1, # <<<<<<<<<<<<<< + * 'vl2': vl2, + * 'a': a, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vl1, ((PyObject *)__pyx_v_vl1)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4571 + * 'metadata': {'vh': vh, + * 'vl1': vl1, + * 'vl2': vl2, # <<<<<<<<<<<<<< + * 'a': a, + * 'zh': zh, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_vl2, ((PyObject *)__pyx_v_vl2)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4572 + * 'vl1': vl1, + * 'vl2': vl2, + * 'a': a, # <<<<<<<<<<<<<< + * 'zh': zh, + * 'zl1': zl1, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4573 + * 'vl2': vl2, + * 'a': a, + * 'zh': zh, # <<<<<<<<<<<<<< + * 'zl1': zl1, + * 'zl2': zl2, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zh, ((PyObject *)__pyx_v_zh)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4574 + * 'a': a, + * 'zh': zh, + * 'zl1': zl1, # <<<<<<<<<<<<<< + * 'zl2': zl2, + * 'd': d, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zl1, ((PyObject *)__pyx_v_zl1)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4575 + * 'zh': zh, + * 'zl1': zl1, + * 'zl2': zl2, # <<<<<<<<<<<<<< + * 'd': d, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zl2, ((PyObject *)__pyx_v_zl2)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4576 + * 'zl1': zl1, + * 'zl2': zl2, + * 'd': d, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_d, ((PyObject *)__pyx_v_d)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4577 + * 'zl2': zl2, + * 'd': d, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4578 + * 'd': d, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + + /* "cssm.pyx":4579 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 4569, __pyx_L1_error) + __pyx_t_12 = __pyx_t_4; + __pyx_t_4 = 0; + + /* "cssm.pyx":4580 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 4580, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_12, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 4580, __pyx_L1_error) + } + + /* "cssm.pyx":4581 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4581, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_4) < (0)) __PYX_ERR(0, 4581, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":4582 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_4 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4582, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_4) < (0)) __PYX_ERR(0, 4582, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":4583 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 4583, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":4584 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4584, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_4) < (0)) __PYX_ERR(0, 4584, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 4585, __pyx_L1_error) + + /* "cssm.pyx":4586 + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4586, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_4) < (0)) __PYX_ERR(0, 4586, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":4587 + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'trajectory': traj, + * 'boundary': boundary}} +*/ + __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4587, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 4587, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4587, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 4587, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 4587, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_4) < (0)) __PYX_ERR(0, 4587, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":4588 + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, # <<<<<<<<<<<<<< + * 'boundary': boundary}} + * elif return_option == 'minimal': +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 4588, __pyx_L1_error) + + /* "cssm.pyx":4589 + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': traj, + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, +*/ + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 4589, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 4568, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":4567 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'vh': vh, +*/ + } + + /* "cssm.pyx":4590 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', +*/ + __pyx_t_20 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_20 < 0))) __PYX_ERR(0, 4590, __pyx_L1_error) + if (likely(__pyx_t_20)) { + + /* "cssm.pyx":4591 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, # <<<<<<<<<<<<<< + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4591, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4591, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4591, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_high, __pyx_v_rts_high) < (0)) __PYX_ERR(0, 4591, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts_low, __pyx_v_rts_low) < (0)) __PYX_ERR(0, 4591, __pyx_L1_error) + + /* "cssm.pyx":4592 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_12 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4592, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 4592, __pyx_L1_error) + + /* "cssm.pyx":4593 + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_4 = PyList_New(4); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4593, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 4593, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4593, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 4593, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_4, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 4593, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_4) < (0)) __PYX_ERR(0, 4592, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":4594 + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4594, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_4) < (0)) __PYX_ERR(0, 4592, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":4595 + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4595, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_4) < (0)) __PYX_ERR(0, 4592, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":4596 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4596, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_4) < (0)) __PYX_ERR(0, 4592, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_12) < (0)) __PYX_ERR(0, 4591, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":4590 + * 'trajectory': traj, + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'rts_high': rts_high, 'rts_low': rts_low, + * 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', +*/ + } + + /* "cssm.pyx":4599 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # ---------------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_12 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_12, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_12); __pyx_t_12 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4599, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 4599, __pyx_L1_error) + } + + /* "cssm.pyx":4263 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_unnormalized_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + __Pyx_XDECREF(__pyx_t_12); + __Pyx_XDECREF(__pyx_t_22); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_flexbound_mic2_unnormalized_ornstein_multinoise", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_g.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_d_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_g_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __Pyx_XDECREF(__pyx_v_rts_low); + __Pyx_XDECREF(__pyx_v_rts_high); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_high_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_low_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __Pyx_XDECREF(__pyx_v_bias_trace_l1); + __Pyx_XDECREF(__pyx_v_bias_trace_l2); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_bias_trace_l1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_bias_trace_l2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_9genexpr15__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":4606 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_tradeoff(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + +static PyObject *__pyx_pf_4cssm_78__defaults__(CYTHON_UNUSED PyObject *__pyx_self) { + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__defaults__", 0); + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":4617 + * np.ndarray[float, ndim = 1] deadline, + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_1 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4617, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + + /* "cssm.pyx":4618 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_2 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4618, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + + /* "cssm.pyx":4619 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * print_info = True, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4619, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + + /* "cssm.pyx":4620 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4620, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":4606 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_tradeoff(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_5 = PyTuple_New(11); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_1) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 2, __pyx_t_3) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 3, __pyx_t_4) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 4, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 5, Py_None) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_True)); + __Pyx_GIVEREF(((PyObject*)Py_True)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 6, ((PyObject*)Py_True)) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_INCREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + __Pyx_GIVEREF(__Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 7, __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self)->arg0) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 8, Py_None) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + __Pyx_GIVEREF(((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 9, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_INCREF(((PyObject*)Py_False)); + __Pyx_GIVEREF(((PyObject*)Py_False)); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 10, ((PyObject*)Py_False)) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __pyx_t_1 = 0; + __pyx_t_2 = 0; + __pyx_t_3 = 0; + __pyx_t_4 = 0; + __pyx_t_4 = PyTuple_New(2); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_5) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __Pyx_INCREF(Py_None); + __Pyx_GIVEREF(Py_None); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, Py_None) != (0)) __PYX_ERR(0, 4606, __pyx_L1_error); + __pyx_t_5 = 0; + __pyx_r = __pyx_t_4; + __pyx_t_4 = 0; + goto __pyx_L0; + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_AddTraceback("cssm.__defaults__", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + __pyx_L0:; + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_43ddm_flexbound_tradeoff(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_42ddm_flexbound_tradeoff, "\n Simulate a Drift Diffusion Model (DDM) with flexible boundaries for a tradeoff scenario.\n\n This function simulates a two-stage decision process where the first stage (high-dimensional)\n influences the second stage (low-dimensional) through a bias trace.\n\n Parameters:\n -----------\n vh, vl1, vl2 : np.ndarray[float, ndim=1]\n Drift rates for high-dimensional and two low-dimensional choices.\n a : np.ndarray[float, ndim=1]\n Initial boundary separation.\n zh, zl1, zl2 : np.ndarray[float, ndim=1]\n Starting points for high-dimensional and two low-dimensional choices.\n d : np.ndarray[float, ndim=1]\n Damping factor for drift rate.\n t : np.ndarray[float, ndim=1]\n Non-decision time.\n deadline : np.ndarray[float, ndim=1]\n Time limit for each trial.\n s : np.ndarray[float, ndim=1]\n Noise standard deviation.\n delta_t : float, optional\n Size of time steps (default: 0.001).\n max_t : float, optional\n Maximum time for a trial (default: 20).\n n_samples : int, optional\n Number of samples to simulate (default: 20000).\n n_trials : int, optional\n Number of trials to simulate (default: 1).\n print_info : bool, optional\n Whether to print simulation information (default: True).\n boundary_fun : callable, optional\n Function defining the decision boundary over time.\n boundary_multiplicative : bool, optional\n Whether the boundary function is multiplicative (default: True).\n boundary_params : dict, optional\n Parameters for the boundary function.\n random_state : int or None, optional\n Seed for random number generation (default: None).\n return_option : str, optional\n Determines the format of returned data ('full' or 'minimal', default: 'full').\n smooth_unif : bool, optional\n Whether to use smooth uniform distribution for small time increments (default: False).\n\n ""Returns:\n --------\n dict\n A dictionary containing simulated reaction times, choices, and metadata.\n The exact contents depend on the 'return_option' parameter.\n\n Raises:\n -------\n ValueError\n If an invalid 'return_option' is provided.\n\n Notes:\n ------\n This function implements a complex DDM with flexible boundaries and a two-stage\n decision process, suitable for modeling tradeoff scenarios in decision-making.\n "); +static PyMethodDef __pyx_mdef_4cssm_43ddm_flexbound_tradeoff = {"ddm_flexbound_tradeoff", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_43ddm_flexbound_tradeoff, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_42ddm_flexbound_tradeoff}; +static PyObject *__pyx_pw_4cssm_43ddm_flexbound_tradeoff(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_vh = 0; + PyArrayObject *__pyx_v_vl1 = 0; + PyArrayObject *__pyx_v_vl2 = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_zh = 0; + PyArrayObject *__pyx_v_zl1 = 0; + PyArrayObject *__pyx_v_zl2 = 0; + PyArrayObject *__pyx_v_d = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_deadline = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + CYTHON_UNUSED PyObject *__pyx_v_print_info = 0; + PyObject *__pyx_v_boundary_fun = 0; + PyObject *__pyx_v_boundary_multiplicative = 0; + PyObject *__pyx_v_boundary_params = 0; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[22] = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("ddm_flexbound_tradeoff (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_vh,&__pyx_mstate_global->__pyx_n_u_vl1,&__pyx_mstate_global->__pyx_n_u_vl2,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_zh,&__pyx_mstate_global->__pyx_n_u_zl1,&__pyx_mstate_global->__pyx_n_u_zl2,&__pyx_mstate_global->__pyx_n_u_d,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_deadline,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_print_info,&__pyx_mstate_global->__pyx_n_u_boundary_fun,&__pyx_mstate_global->__pyx_n_u_boundary_multiplicative,&__pyx_mstate_global->__pyx_n_u_boundary_params,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,0}; + struct __pyx_defaults *__pyx_dynamic_args = __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_self); + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4606, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "ddm_flexbound_tradeoff", 1) < (0)) __PYX_ERR(0, 4606, __pyx_L3_error) + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":4622 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[18]) values[18] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":4625 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 11; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("ddm_flexbound_tradeoff", 0, 11, 22, i); __PYX_ERR(0, 4606, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 22: + values[21] = __Pyx_ArgRef_FASTCALL(__pyx_args, 21); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[21])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 21: + values[20] = __Pyx_ArgRef_FASTCALL(__pyx_args, 20); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[20])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 20: + values[19] = __Pyx_ArgRef_FASTCALL(__pyx_args, 19); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[19])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 19: + values[18] = __Pyx_ArgRef_FASTCALL(__pyx_args, 18); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[18])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 18: + values[17] = __Pyx_ArgRef_FASTCALL(__pyx_args, 17); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[17])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 17: + values[16] = __Pyx_ArgRef_FASTCALL(__pyx_args, 16); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[16])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 16: + values[15] = __Pyx_ArgRef_FASTCALL(__pyx_args, 15); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[15])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 15: + values[14] = __Pyx_ArgRef_FASTCALL(__pyx_args, 14); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[14])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 14: + values[13] = __Pyx_ArgRef_FASTCALL(__pyx_args, 13); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[13])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 4606, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4606, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4606, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + if (!values[15]) values[15] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + + /* "cssm.pyx":4622 + * int n_trials = 1, + * print_info = True, + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) # <<<<<<<<<<<<<< + * boundary_multiplicative = True, + * boundary_params = {}, +*/ + if (!values[16]) values[16] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[17]) values[17] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_True))); + if (!values[18]) values[18] = __Pyx_NewRef(__pyx_dynamic_args->arg0); + + /* "cssm.pyx":4625 + * boundary_multiplicative = True, + * boundary_params = {}, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[19]) values[19] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[20]) values[20] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[21]) values[21] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_vh = ((PyArrayObject *)values[0]); + __pyx_v_vl1 = ((PyArrayObject *)values[1]); + __pyx_v_vl2 = ((PyArrayObject *)values[2]); + __pyx_v_a = ((PyArrayObject *)values[3]); + __pyx_v_zh = ((PyArrayObject *)values[4]); + __pyx_v_zl1 = ((PyArrayObject *)values[5]); + __pyx_v_zl2 = ((PyArrayObject *)values[6]); + __pyx_v_d = ((PyArrayObject *)values[7]); + __pyx_v_t = ((PyArrayObject *)values[8]); + __pyx_v_deadline = ((PyArrayObject *)values[9]); + __pyx_v_s = ((PyArrayObject *)values[10]); + if (values[11]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[11]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4617, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[12]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[12]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4618, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[13]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[13]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4619, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[14]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[14]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4620, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_print_info = values[15]; + __pyx_v_boundary_fun = values[16]; + __pyx_v_boundary_multiplicative = values[17]; + __pyx_v_boundary_params = values[18]; + __pyx_v_random_state = values[19]; + __pyx_v_return_option = values[20]; + __pyx_v_smooth_unif = values[21]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("ddm_flexbound_tradeoff", 0, 11, 22, __pyx_nargs); __PYX_ERR(0, 4606, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.ddm_flexbound_tradeoff", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vh", 0))) __PYX_ERR(0, 4606, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl1", 0))) __PYX_ERR(0, 4607, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_vl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "vl2", 0))) __PYX_ERR(0, 4608, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 4609, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zh), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zh", 0))) __PYX_ERR(0, 4610, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl1), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl1", 0))) __PYX_ERR(0, 4611, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_zl2), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "zl2", 0))) __PYX_ERR(0, 4612, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_d), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "d", 0))) __PYX_ERR(0, 4613, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 4614, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_deadline), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "deadline", 0))) __PYX_ERR(0, 4615, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 4616, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_42ddm_flexbound_tradeoff(__pyx_self, __pyx_v_vh, __pyx_v_vl1, __pyx_v_vl2, __pyx_v_a, __pyx_v_zh, __pyx_v_zl1, __pyx_v_zl2, __pyx_v_d, __pyx_v_t, __pyx_v_deadline, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_print_info, __pyx_v_boundary_fun, __pyx_v_boundary_multiplicative, __pyx_v_boundary_params, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_kwargs); + + /* "cssm.pyx":4606 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_tradeoff(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_42ddm_flexbound_tradeoff(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_vh, PyArrayObject *__pyx_v_vl1, PyArrayObject *__pyx_v_vl2, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_zh, PyArrayObject *__pyx_v_zl1, PyArrayObject *__pyx_v_zl2, PyArrayObject *__pyx_v_d, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_deadline, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, CYTHON_UNUSED PyObject *__pyx_v_print_info, PyObject *__pyx_v_boundary_fun, PyObject *__pyx_v_boundary_multiplicative, PyObject *__pyx_v_boundary_params, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_vh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_vl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zh_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl1_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_zl2_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_d_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_deadline_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + int __pyx_v_num_draws; + PyObject *__pyx_v_t_s = NULL; + PyObject *__pyx_v_boundary = NULL; + __Pyx_memviewslice __pyx_v_boundary_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_bias_trace = NULL; + __Pyx_memviewslice __pyx_v_bias_trace_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_y_h; + float __pyx_v_y_l; + float __pyx_v_v_l; + float __pyx_v_t_h; + float __pyx_v_t_l; + float __pyx_v_tmp_pos_dep; + CYTHON_UNUSED float __pyx_v_smooth_u; + float __pyx_v_deadline_tmp; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_ix_tmp; + Py_ssize_t __pyx_v_k; + Py_ssize_t __pyx_v_m; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_boundary_params_tmp = NULL; + float __pyx_v_sqrt_st; + PyObject *__pyx_9genexpr16__pyx_v_key = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_d; + __Pyx_Buffer __pyx_pybuffer_d; + __Pyx_LocalBuf_ND __pyx_pybuffernd_deadline; + __Pyx_Buffer __pyx_pybuffer_deadline; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vh; + __Pyx_Buffer __pyx_pybuffer_vh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl1; + __Pyx_Buffer __pyx_pybuffer_vl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_vl2; + __Pyx_Buffer __pyx_pybuffer_vl2; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zh; + __Pyx_Buffer __pyx_pybuffer_zh; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl1; + __Pyx_Buffer __pyx_pybuffer_zl1; + __Pyx_LocalBuf_ND __pyx_pybuffernd_zl2; + __Pyx_Buffer __pyx_pybuffer_zl2; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + __Pyx_memviewslice __pyx_t_9 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_11 = NULL; + int __pyx_t_12; + int __pyx_t_13; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + Py_ssize_t __pyx_t_16; + int __pyx_t_17; + int __pyx_t_18; + int __pyx_t_19; + Py_ssize_t __pyx_t_20; + PyObject *__pyx_t_21 = NULL; + Py_ssize_t __pyx_t_22; + float __pyx_t_23; + float __pyx_t_24; + float __pyx_t_25; + Py_ssize_t __pyx_t_26; + int __pyx_t_27; + Py_ssize_t __pyx_t_28; + Py_ssize_t __pyx_t_29; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("ddm_flexbound_tradeoff", 0); + __pyx_pybuffer_vh.pybuffer.buf = NULL; + __pyx_pybuffer_vh.refcount = 0; + __pyx_pybuffernd_vh.data = NULL; + __pyx_pybuffernd_vh.rcbuffer = &__pyx_pybuffer_vh; + __pyx_pybuffer_vl1.pybuffer.buf = NULL; + __pyx_pybuffer_vl1.refcount = 0; + __pyx_pybuffernd_vl1.data = NULL; + __pyx_pybuffernd_vl1.rcbuffer = &__pyx_pybuffer_vl1; + __pyx_pybuffer_vl2.pybuffer.buf = NULL; + __pyx_pybuffer_vl2.refcount = 0; + __pyx_pybuffernd_vl2.data = NULL; + __pyx_pybuffernd_vl2.rcbuffer = &__pyx_pybuffer_vl2; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_zh.pybuffer.buf = NULL; + __pyx_pybuffer_zh.refcount = 0; + __pyx_pybuffernd_zh.data = NULL; + __pyx_pybuffernd_zh.rcbuffer = &__pyx_pybuffer_zh; + __pyx_pybuffer_zl1.pybuffer.buf = NULL; + __pyx_pybuffer_zl1.refcount = 0; + __pyx_pybuffernd_zl1.data = NULL; + __pyx_pybuffernd_zl1.rcbuffer = &__pyx_pybuffer_zl1; + __pyx_pybuffer_zl2.pybuffer.buf = NULL; + __pyx_pybuffer_zl2.refcount = 0; + __pyx_pybuffernd_zl2.data = NULL; + __pyx_pybuffernd_zl2.rcbuffer = &__pyx_pybuffer_zl2; + __pyx_pybuffer_d.pybuffer.buf = NULL; + __pyx_pybuffer_d.refcount = 0; + __pyx_pybuffernd_d.data = NULL; + __pyx_pybuffernd_d.rcbuffer = &__pyx_pybuffer_d; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_deadline.pybuffer.buf = NULL; + __pyx_pybuffer_deadline.refcount = 0; + __pyx_pybuffernd_deadline.data = NULL; + __pyx_pybuffernd_deadline.rcbuffer = &__pyx_pybuffer_deadline; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vh.rcbuffer->pybuffer, (PyObject*)__pyx_v_vh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_vh.diminfo[0].strides = __pyx_pybuffernd_vh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vh.diminfo[0].shape = __pyx_pybuffernd_vh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_vl1.diminfo[0].strides = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl1.diminfo[0].shape = __pyx_pybuffernd_vl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_vl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_vl2.diminfo[0].strides = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_vl2.diminfo[0].shape = __pyx_pybuffernd_vl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zh.rcbuffer->pybuffer, (PyObject*)__pyx_v_zh, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_zh.diminfo[0].strides = __pyx_pybuffernd_zh.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zh.diminfo[0].shape = __pyx_pybuffernd_zh.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl1, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_zl1.diminfo[0].strides = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl1.diminfo[0].shape = __pyx_pybuffernd_zl1.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer, (PyObject*)__pyx_v_zl2, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_zl2.diminfo[0].strides = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_zl2.diminfo[0].shape = __pyx_pybuffernd_zl2.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_d.rcbuffer->pybuffer, (PyObject*)__pyx_v_d, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_d.diminfo[0].strides = __pyx_pybuffernd_d.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_d.diminfo[0].shape = __pyx_pybuffernd_d.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer, (PyObject*)__pyx_v_deadline, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_deadline.diminfo[0].strides = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_deadline.diminfo[0].shape = __pyx_pybuffernd_deadline.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4606, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":4691 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * # Param views + * cdef float[:] vh_view = vh +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4691, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":4693 + * set_seed(random_state) + * # Param views + * cdef float[:] vh_view = vh # <<<<<<<<<<<<<< + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4693, __pyx_L1_error) + __pyx_v_vh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4694 + * # Param views + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 # <<<<<<<<<<<<<< + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4694, __pyx_L1_error) + __pyx_v_vl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4695 + * cdef float[:] vh_view = vh + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 # <<<<<<<<<<<<<< + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_vl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4695, __pyx_L1_error) + __pyx_v_vl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4696 + * cdef float[:] vl1_view = vl1 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a # <<<<<<<<<<<<<< + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4696, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4697 + * cdef float[:] vl2_view = vl2 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh # <<<<<<<<<<<<<< + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zh), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4697, __pyx_L1_error) + __pyx_v_zh_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4698 + * cdef float[:] a_view = a + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 # <<<<<<<<<<<<<< + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl1), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4698, __pyx_L1_error) + __pyx_v_zl1_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4699 + * cdef float[:] zh_view = zh + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 # <<<<<<<<<<<<<< + * cdef float[:] d_view = d + * cdef float[:] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_zl2), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4699, __pyx_L1_error) + __pyx_v_zl2_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4700 + * cdef float[:] zl1_view = zl1 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d # <<<<<<<<<<<<<< + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_d), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4700, __pyx_L1_error) + __pyx_v_d_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4701 + * cdef float[:] zl2_view = zl2 + * cdef float[:] d_view = d + * cdef float[:] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4701, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4702 + * cdef float[:] d_view = d + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_deadline), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4702, __pyx_L1_error) + __pyx_v_deadline_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4703 + * cdef float[:] t_view = t + * cdef float[:] deadline_view = deadline + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4703, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4706 + * # TD: Add trajectory --> same issue as with par2 model above... might need to make a separate simulator for trajectories + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_7 = PyTuple_New(3); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 4706, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 4706, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_7, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4706, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_7}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4706, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4706, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4707 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_5 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_7 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 4707, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_7) != (0)) __PYX_ERR(0, 4707, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4707, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_5 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_5); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_5); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4707, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4707, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4709 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_9 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_9.memview)) __PYX_ERR(0, 4709, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_9; + __pyx_t_9.memview = NULL; + __pyx_t_9.data = NULL; + + /* "cssm.pyx":4710 + * + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 4710, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":4712 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # correct scalar so we can use standard normal samples for the brownian motion # <<<<<<<<<<<<<< + * #cdef float sqrt_st = delta_t_sqrt * s # scalar to ensure the correct variance for the gaussian step + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":4716 + * + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) # <<<<<<<<<<<<<< + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) +*/ + __pyx_v_num_draws = ((int)((__pyx_v_max_t / __pyx_v_delta_t) + 1.0)); + + /* "cssm.pyx":4717 + * # Boundary storage for the upper bound + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) # <<<<<<<<<<<<<< + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_arange); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyFloat_FromDouble((__pyx_v_max_t + __pyx_v_delta_t)); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_11 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_mstate_global->__pyx_int_0, __pyx_t_3, __pyx_t_11}; + __pyx_t_7 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (4-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + } + __pyx_t_6 = __pyx_t_7; + __Pyx_INCREF(__pyx_t_6); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_5}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4717, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_t_s = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4718 + * cdef int num_draws = int((max_t / delta_t) + 1) + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] boundary_view = boundary + * +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_v_t_s, __pyx_mstate_global->__pyx_n_u_shape); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_11, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_t_5}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_11, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4718, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4718, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_boundary = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4719 + * t_s = np.arange(0, max_t + delta_t, delta_t).astype(DTYPE) + * boundary = np.zeros(t_s.shape, dtype = DTYPE) + * cdef float[:] boundary_view = boundary # <<<<<<<<<<<<<< + * + * # Y particle trace +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_boundary, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4719, __pyx_L1_error) + __pyx_v_boundary_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4722 + * + * # Y particle trace + * bias_trace = np.zeros(num_draws, dtype = DTYPE) # <<<<<<<<<<<<<< + * cdef float[:] bias_trace_view = bias_trace + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_11 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_num_draws); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_11))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_11); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_11); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_11, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_3}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4722, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_11, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4722, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_bias_trace = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4723 + * # Y particle trace + * bias_trace = np.zeros(num_draws, dtype = DTYPE) + * cdef float[:] bias_trace_view = bias_trace # <<<<<<<<<<<<<< + * + * cdef float y_h, y_l, v_l, t_h, t_l, tmp_pos_dep, smooth_u, deadline_tmp +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(__pyx_v_bias_trace, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4723, __pyx_L1_error) + __pyx_v_bias_trace_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4727 + * cdef float y_h, y_l, v_l, t_h, t_l, tmp_pos_dep, smooth_u, deadline_tmp + * cdef Py_ssize_t n, ix, ix_tmp, k + * cdef Py_ssize_t m = 0 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":4728 + * cdef Py_ssize_t n, ix, ix_tmp, k + * cdef Py_ssize_t m = 0 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4728, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4730 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} +*/ + __pyx_t_12 = __pyx_v_n_trials; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_k = __pyx_t_14; + + /* "cssm.pyx":4732 + * for k in range(n_trials): + * # Precompute boundary evaluations + * boundary_params_tmp = {key: boundary_params[key][k] for key in boundary_params.keys()} # <<<<<<<<<<<<<< + * + * # Precompute boundary evaluations +*/ + { /* enter inner scope */ + __pyx_t_1 = PyDict_New(); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4732, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_15 = 0; + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_Format(PyExc_AttributeError, "'NoneType' object has no attribute '%.30s'", "keys"); + __PYX_ERR(0, 4732, __pyx_L7_error) + } + __pyx_t_7 = __Pyx_dict_iterator(__pyx_v_boundary_params, 0, __pyx_mstate_global->__pyx_n_u_keys, (&__pyx_t_16), (&__pyx_t_17)); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4732, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_11); + __pyx_t_11 = __pyx_t_7; + __pyx_t_7 = 0; + while (1) { + __pyx_t_18 = __Pyx_dict_iter_next(__pyx_t_11, __pyx_t_16, &__pyx_t_15, &__pyx_t_7, NULL, NULL, __pyx_t_17); + if (unlikely(__pyx_t_18 == 0)) break; + if (unlikely(__pyx_t_18 == -1)) __PYX_ERR(0, 4732, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_XDECREF_SET(__pyx_9genexpr16__pyx_v_key, __pyx_t_7); + __pyx_t_7 = 0; + __pyx_t_7 = __Pyx_PyObject_GetItem(__pyx_v_boundary_params, __pyx_9genexpr16__pyx_v_key); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 4732, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_5 = __Pyx_GetItemInt(__pyx_t_7, __pyx_v_k, Py_ssize_t, 1, PyLong_FromSsize_t, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4732, __pyx_L7_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(PyDict_SetItem(__pyx_t_1, (PyObject*)__pyx_9genexpr16__pyx_v_key, (PyObject*)__pyx_t_5))) __PYX_ERR(0, 4732, __pyx_L7_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_XDECREF(__pyx_9genexpr16__pyx_v_key); __pyx_9genexpr16__pyx_v_key = 0; + goto __pyx_L10_exit_scope; + __pyx_L7_error:; + __Pyx_XDECREF(__pyx_9genexpr16__pyx_v_key); __pyx_9genexpr16__pyx_v_key = 0; + goto __pyx_L1_error; + __pyx_L10_exit_scope:; + } /* exit inner scope */ + __Pyx_XDECREF_SET(__pyx_v_boundary_params_tmp, ((PyObject*)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":4735 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_boundary_multiplicative); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4735, __pyx_L1_error) + if (__pyx_t_19) { + + /* "cssm.pyx":4736 + * # Precompute boundary evaluations + * if boundary_multiplicative: + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_multiply); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_3 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_20 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_21 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + if (PyDict_SetItem(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 4736, __pyx_L1_error) + __pyx_t_4 = __pyx_t_21; + __pyx_t_21 = 0; + if (__Pyx_MergeKeywords(__pyx_t_4, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 4736, __pyx_L1_error) + __pyx_t_21 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_4); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_7, __pyx_t_3, __pyx_t_21}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __pyx_t_11 = __pyx_t_5; + __Pyx_INCREF(__pyx_t_11); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_11, __pyx_t_6}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4736, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 4736, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":4735 + * + * # Precompute boundary evaluations + * if boundary_multiplicative: # <<<<<<<<<<<<<< + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: +*/ + goto __pyx_L11; + } + + /* "cssm.pyx":4738 + * boundary[:] = np.multiply(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * else: + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) # <<<<<<<<<<<<<< + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) +*/ + /*else*/ { + __pyx_t_11 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_21, __pyx_mstate_global->__pyx_n_u_add); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_21 = PyFloat_FromDouble((*((float *) ( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_20 * __pyx_v_a_view.strides[0]) )))); if (unlikely(!__pyx_t_21)) __PYX_ERR(0, 4738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_21); + __pyx_t_4 = __Pyx_PyDict_NewPresized(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_t, __pyx_v_t_s) < (0)) __PYX_ERR(0, 4738, __pyx_L1_error) + __pyx_t_7 = __pyx_t_4; + __pyx_t_4 = 0; + if (__Pyx_MergeKeywords(__pyx_t_7, __pyx_v_boundary_params_tmp) < (0)) __PYX_ERR(0, 4738, __pyx_L1_error) + __pyx_t_4 = __Pyx_PyObject_Call(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_empty_tuple, __pyx_t_7); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_11 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_11); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_11); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_11, __pyx_t_21, __pyx_t_4}; + __pyx_t_6 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_8, (3-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_21); __pyx_t_21 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + } + __pyx_t_5 = __pyx_t_6; + __Pyx_INCREF(__pyx_t_5); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_8 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_astype, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4738, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (__Pyx_PyObject_SetSlice(__pyx_v_boundary, __pyx_t_1, 0, 0, NULL, NULL, &__pyx_mstate_global->__pyx_slice[0], 0, 0, 0) < (0)) __PYX_ERR(0, 4738, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + } + __pyx_L11:; + + /* "cssm.pyx":4740 + * boundary[:] = np.add(a_view[k], boundary_fun(t = t_s, **boundary_params_tmp)).astype(DTYPE) + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples +*/ + __pyx_t_20 = __pyx_v_k; + __pyx_t_22 = __pyx_v_k; + __pyx_t_23 = ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_20 * __pyx_v_deadline_view.strides[0]) ))) - (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_22 * __pyx_v_t_view.strides[0]) )))); + __pyx_t_24 = __pyx_v_max_t; + __pyx_t_19 = (__pyx_t_23 < __pyx_t_24); + if (__pyx_t_19) { + __pyx_t_25 = __pyx_t_23; + } else { + __pyx_t_25 = __pyx_t_24; + } + __pyx_v_deadline_tmp = __pyx_t_25; + + /* "cssm.pyx":4741 + * + * deadline_tmp = min(max_t, deadline_view[k] - t_view[k]) + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * # Loop over samples + * for n in range(n_samples): +*/ + __pyx_t_22 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_22 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":4743 + * sqrt_st = delta_t_sqrt * s_view[k] + * # Loop over samples + * for n in range(n_samples): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension +*/ + __pyx_t_17 = __pyx_v_n_samples; + __pyx_t_18 = __pyx_t_17; + for (__pyx_t_16 = 0; __pyx_t_16 < __pyx_t_18; __pyx_t_16+=1) { + __pyx_v_n = __pyx_t_16; + + /* "cssm.pyx":4744 + * # Loop over samples + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice # <<<<<<<<<<<<<< + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension +*/ + __pyx_t_22 = __pyx_v_n; + __pyx_t_20 = __pyx_v_k; + __pyx_t_26 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_22 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_20 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_26 * __pyx_v_choices_view.strides[2]) )) = 0; + + /* "cssm.pyx":4745 + * for n in range(n_samples): + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension # <<<<<<<<<<<<<< + * t_l = 0 # reset time low dimension + * ix = 0 # reset boundary index +*/ + __pyx_v_t_h = 0.0; + + /* "cssm.pyx":4746 + * choices_view[n, k, 0] = 0 # reset choice + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension # <<<<<<<<<<<<<< + * ix = 0 # reset boundary index + * +*/ + __pyx_v_t_l = 0.0; + + /* "cssm.pyx":4747 + * t_h = 0 # reset time high dimension + * t_l = 0 # reset time low dimension + * ix = 0 # reset boundary index # <<<<<<<<<<<<<< + * + * # Initialize walkers +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":4750 + * + * # Initialize walkers + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * bias_trace_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) + * +*/ + __pyx_t_26 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_22 = 0; + __pyx_v_y_h = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_26 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zh_view.data + __pyx_t_20 * __pyx_v_zh_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":4751 + * # Initialize walkers + * y_h = (-1) * boundary_view[0] + (zh_view[k] * 2 * (boundary_view[0])) + * bias_trace_view[0] = ((y_h + boundary_view[0]) / (2 * boundary_view[0])) # <<<<<<<<<<<<<< + * + * # Random walks until y_h hits bound +*/ + __pyx_t_22 = 0; + __pyx_t_20 = 0; + __pyx_t_26 = 0; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_view.data + __pyx_t_26 * __pyx_v_bias_trace_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_20 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":4754 + * + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): # <<<<<<<<<<<<<< + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) +*/ + while (1) { + __pyx_t_20 = __pyx_v_ix; + __pyx_t_27 = (__pyx_v_y_h >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_20 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_27) { + } else { + __pyx_t_19 = __pyx_t_27; + goto __pyx_L16_bool_binop_done; + } + __pyx_t_20 = __pyx_v_ix; + __pyx_t_27 = (__pyx_v_y_h <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_20 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_27) { + } else { + __pyx_t_19 = __pyx_t_27; + goto __pyx_L16_bool_binop_done; + } + __pyx_t_27 = (__pyx_v_t_h <= __pyx_v_deadline_tmp); + __pyx_t_19 = __pyx_t_27; + __pyx_L16_bool_binop_done:; + if (!__pyx_t_19) break; + + /* "cssm.pyx":4755 + * # Random walks until y_h hits bound + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * bias_trace_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * t_h += delta_t +*/ + __pyx_t_20 = __pyx_v_k; + __pyx_t_22 = __pyx_v_m; + __pyx_v_y_h = (__pyx_v_y_h + (((*((float *) ( /* dim=0 */ (__pyx_v_vh_view.data + __pyx_t_20 * __pyx_v_vh_view.strides[0]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_22 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":4756 + * while (y_h >= ((-1) * boundary_view[ix])) and ((y_h <= boundary_view[ix])) and (t_h <= deadline_tmp): + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) # <<<<<<<<<<<<<< + * t_h += delta_t + * ix += 1 +*/ + __pyx_t_22 = __pyx_v_ix; + __pyx_t_20 = __pyx_v_ix; + __pyx_t_26 = __pyx_v_ix; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_view.data + __pyx_t_26 * __pyx_v_bias_trace_view.strides[0]) )) = ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_20 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":4757 + * y_h += (vh_view[k] * delta_t) + (sqrt_st * gaussian_values[m]) + * bias_trace_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * t_h += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_h = (__pyx_v_t_h + __pyx_v_delta_t); + + /* "cssm.pyx":4758 + * bias_trace_view[ix] = ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])) + * t_h += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":4759 + * t_h += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":4760 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_19 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_19) { + + /* "cssm.pyx":4761 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4761, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4762 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":4760 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":4767 + * # y at upper bound --> choices_view[n, k, 0] add 2 deterministically + * # y at lower bound --> choice_view[n, k, 0] stay the same deterministically + * if random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + __pyx_t_25 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_25 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4767, __pyx_L1_error) + __pyx_t_20 = __pyx_v_ix; + __pyx_t_22 = __pyx_v_ix; + __pyx_t_19 = (__pyx_t_25 <= ((__pyx_v_y_h + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_20 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_19) { + + /* "cssm.pyx":4768 + * # y at lower bound --> choice_view[n, k, 0] stay the same deterministically + * if random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 2 # <<<<<<<<<<<<<< + * + * if choices_view[n, k, 0] == 2: +*/ + __pyx_t_22 = __pyx_v_n; + __pyx_t_20 = __pyx_v_k; + __pyx_t_26 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_22 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_20 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_26 * __pyx_v_choices_view.strides[2]) )) += 2; + + /* "cssm.pyx":4767 + * # y at upper bound --> choices_view[n, k, 0] add 2 deterministically + * # y at lower bound --> choice_view[n, k, 0] stay the same deterministically + * if random_uniform() <= ((y_h + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 2 + * +*/ + } + + /* "cssm.pyx":4770 + * choices_view[n, k, 0] += 2 + * + * if choices_view[n, k, 0] == 2: # <<<<<<<<<<<<<< + * y_l = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) + * v_l = vl2_view[k] +*/ + __pyx_t_26 = __pyx_v_n; + __pyx_t_20 = __pyx_v_k; + __pyx_t_22 = 0; + __pyx_t_19 = ((*((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_26 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_20 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_22 * __pyx_v_choices_view.strides[2]) ))) == 2); + if (__pyx_t_19) { + + /* "cssm.pyx":4771 + * + * if choices_view[n, k, 0] == 2: + * y_l = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * v_l = vl2_view[k] + * +*/ + __pyx_t_22 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_26 = 0; + __pyx_v_y_l = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl2_view.data + __pyx_t_20 * __pyx_v_zl2_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_26 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":4772 + * if choices_view[n, k, 0] == 2: + * y_l = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) + * v_l = vl2_view[k] # <<<<<<<<<<<<<< + * + * # Fill bias trace until max_rt reached +*/ + __pyx_t_26 = __pyx_v_k; + __pyx_v_v_l = (*((float *) ( /* dim=0 */ (__pyx_v_vl2_view.data + __pyx_t_26 * __pyx_v_vl2_view.strides[0]) ))); + + /* "cssm.pyx":4775 + * + * # Fill bias trace until max_rt reached + * ix_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix_tmp < num_draws: + * bias_trace_view[ix_tmp] = 1.0 +*/ + __pyx_v_ix_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":4776 + * # Fill bias trace until max_rt reached + * ix_tmp = ix + 1 + * while ix_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_view[ix_tmp] = 1.0 + * ix_tmp += 1 +*/ + while (1) { + __pyx_t_19 = (__pyx_v_ix_tmp < __pyx_v_num_draws); + if (!__pyx_t_19) break; + + /* "cssm.pyx":4777 + * ix_tmp = ix + 1 + * while ix_tmp < num_draws: + * bias_trace_view[ix_tmp] = 1.0 # <<<<<<<<<<<<<< + * ix_tmp += 1 + * +*/ + __pyx_t_26 = __pyx_v_ix_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_view.data + __pyx_t_26 * __pyx_v_bias_trace_view.strides[0]) )) = 1.0; + + /* "cssm.pyx":4778 + * while ix_tmp < num_draws: + * bias_trace_view[ix_tmp] = 1.0 + * ix_tmp += 1 # <<<<<<<<<<<<<< + * + * else: # Store intermediate choice +*/ + __pyx_v_ix_tmp = (__pyx_v_ix_tmp + 1); + } + + /* "cssm.pyx":4770 + * choices_view[n, k, 0] += 2 + * + * if choices_view[n, k, 0] == 2: # <<<<<<<<<<<<<< + * y_l = (- 1) * boundary_view[0] + (zl2_view[k] * 2 * (boundary_view[0])) + * v_l = vl2_view[k] +*/ + goto __pyx_L21; + } + + /* "cssm.pyx":4781 + * + * else: # Store intermediate choice + * y_l = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) # <<<<<<<<<<<<<< + * v_l = vl1_view[k] + * +*/ + /*else*/ { + __pyx_t_26 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_22 = 0; + __pyx_v_y_l = ((-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_26 * __pyx_v_boundary_view.strides[0]) )))) + (((*((float *) ( /* dim=0 */ (__pyx_v_zl1_view.data + __pyx_t_20 * __pyx_v_zl1_view.strides[0]) ))) * 2.0) * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) ))))); + + /* "cssm.pyx":4782 + * else: # Store intermediate choice + * y_l = (- 1) * boundary_view[0] + (zl1_view[k] * 2 * (boundary_view[0])) + * v_l = vl1_view[k] # <<<<<<<<<<<<<< + * + * # Fill bias trace until max_rt reached +*/ + __pyx_t_22 = __pyx_v_k; + __pyx_v_v_l = (*((float *) ( /* dim=0 */ (__pyx_v_vl1_view.data + __pyx_t_22 * __pyx_v_vl1_view.strides[0]) ))); + + /* "cssm.pyx":4785 + * + * # Fill bias trace until max_rt reached + * ix_tmp = ix + 1 # <<<<<<<<<<<<<< + * while ix_tmp < num_draws: + * bias_trace_view[ix_tmp] = 0.0 +*/ + __pyx_v_ix_tmp = (__pyx_v_ix + 1); + + /* "cssm.pyx":4786 + * # Fill bias trace until max_rt reached + * ix_tmp = ix + 1 + * while ix_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_view[ix_tmp] = 0.0 + * ix_tmp += 1 +*/ + while (1) { + __pyx_t_19 = (__pyx_v_ix_tmp < __pyx_v_num_draws); + if (!__pyx_t_19) break; + + /* "cssm.pyx":4787 + * ix_tmp = ix + 1 + * while ix_tmp < num_draws: + * bias_trace_view[ix_tmp] = 0.0 # <<<<<<<<<<<<<< + * ix_tmp += 1 + * +*/ + __pyx_t_22 = __pyx_v_ix_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_view.data + __pyx_t_22 * __pyx_v_bias_trace_view.strides[0]) )) = 0.0; + + /* "cssm.pyx":4788 + * while ix_tmp < num_draws: + * bias_trace_view[ix_tmp] = 0.0 + * ix_tmp += 1 # <<<<<<<<<<<<<< + * + * #We need to reverse the bias_trace if we took the lower choice +*/ + __pyx_v_ix_tmp = (__pyx_v_ix_tmp + 1); + } + + /* "cssm.pyx":4791 + * + * #We need to reverse the bias_trace if we took the lower choice + * ix_tmp = 0 # <<<<<<<<<<<<<< + * while ix_tmp < num_draws: + * bias_trace_view[ix_tmp] = 1.0 - bias_trace_view[ix_tmp] +*/ + __pyx_v_ix_tmp = 0; + + /* "cssm.pyx":4792 + * #We need to reverse the bias_trace if we took the lower choice + * ix_tmp = 0 + * while ix_tmp < num_draws: # <<<<<<<<<<<<<< + * bias_trace_view[ix_tmp] = 1.0 - bias_trace_view[ix_tmp] + * ix_tmp += 1 +*/ + while (1) { + __pyx_t_19 = (__pyx_v_ix_tmp < __pyx_v_num_draws); + if (!__pyx_t_19) break; + + /* "cssm.pyx":4793 + * ix_tmp = 0 + * while ix_tmp < num_draws: + * bias_trace_view[ix_tmp] = 1.0 - bias_trace_view[ix_tmp] # <<<<<<<<<<<<<< + * ix_tmp += 1 + * +*/ + __pyx_t_22 = __pyx_v_ix_tmp; + __pyx_t_20 = __pyx_v_ix_tmp; + *((float *) ( /* dim=0 */ (__pyx_v_bias_trace_view.data + __pyx_t_20 * __pyx_v_bias_trace_view.strides[0]) )) = (1.0 - (*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_view.data + __pyx_t_22 * __pyx_v_bias_trace_view.strides[0]) )))); + + /* "cssm.pyx":4794 + * while ix_tmp < num_draws: + * bias_trace_view[ix_tmp] = 1.0 - bias_trace_view[ix_tmp] + * ix_tmp += 1 # <<<<<<<<<<<<<< + * + * # Random walks until the y_l corresponding to y_h hits bound +*/ + __pyx_v_ix_tmp = (__pyx_v_ix_tmp + 1); + } + } + __pyx_L21:; + + /* "cssm.pyx":4797 + * + * # Random walks until the y_l corresponding to y_h hits bound + * ix = 0 # <<<<<<<<<<<<<< + * while (y_l >= ((-1) * boundary_view[ix])) and (y_l <= boundary_view[ix]) and (t_l <= deadline_tmp): + * # Compute local position dependence +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":4798 + * # Random walks until the y_l corresponding to y_h hits bound + * ix = 0 + * while (y_l >= ((-1) * boundary_view[ix])) and (y_l <= boundary_view[ix]) and (t_l <= deadline_tmp): # <<<<<<<<<<<<<< + * # Compute local position dependence + * # AF-todo: can't understand what the idea here is anymore +*/ + while (1) { + __pyx_t_22 = __pyx_v_ix; + __pyx_t_27 = (__pyx_v_y_l >= (-1.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) ))))); + if (__pyx_t_27) { + } else { + __pyx_t_19 = __pyx_t_27; + goto __pyx_L30_bool_binop_done; + } + __pyx_t_22 = __pyx_v_ix; + __pyx_t_27 = (__pyx_v_y_l <= (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_22 * __pyx_v_boundary_view.strides[0]) )))); + if (__pyx_t_27) { + } else { + __pyx_t_19 = __pyx_t_27; + goto __pyx_L30_bool_binop_done; + } + __pyx_t_27 = (__pyx_v_t_l <= __pyx_v_deadline_tmp); + __pyx_t_19 = __pyx_t_27; + __pyx_L30_bool_binop_done:; + if (!__pyx_t_19) break; + + /* "cssm.pyx":4802 + * # AF-todo: can't understand what the idea here is anymore + * # especially why bias_trace_view is flipped (-1) here + * tmp_pos_dep = (1 + (d_view[k] * (bias_trace_view[ix] - 1.0))) / (2 - d_view[k]) # <<<<<<<<<<<<<< + * + * if (bias_trace_view[ix] < 1) and (bias_trace_view[ix] > 0): +*/ + __pyx_t_22 = __pyx_v_k; + __pyx_t_20 = __pyx_v_ix; + __pyx_t_26 = __pyx_v_k; + __pyx_v_tmp_pos_dep = ((1.0 + ((*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_22 * __pyx_v_d_view.strides[0]) ))) * ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_view.data + __pyx_t_20 * __pyx_v_bias_trace_view.strides[0]) ))) - 1.0))) / ((double)(2.0 - (*((float *) ( /* dim=0 */ (__pyx_v_d_view.data + __pyx_t_26 * __pyx_v_d_view.strides[0]) )))))); + + /* "cssm.pyx":4804 + * tmp_pos_dep = (1 + (d_view[k] * (bias_trace_view[ix] - 1.0))) / (2 - d_view[k]) + * + * if (bias_trace_view[ix] < 1) and (bias_trace_view[ix] > 0): # <<<<<<<<<<<<<< + * # Before high-dim choice is taken + * y_l += tmp_pos_dep * (v_l * delta_t) # Add drift +*/ + __pyx_t_26 = __pyx_v_ix; + __pyx_t_27 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_view.data + __pyx_t_26 * __pyx_v_bias_trace_view.strides[0]) ))) < 1.0); + if (__pyx_t_27) { + } else { + __pyx_t_19 = __pyx_t_27; + goto __pyx_L34_bool_binop_done; + } + __pyx_t_26 = __pyx_v_ix; + __pyx_t_27 = ((*((float *) ( /* dim=0 */ (__pyx_v_bias_trace_view.data + __pyx_t_26 * __pyx_v_bias_trace_view.strides[0]) ))) > 0.0); + __pyx_t_19 = __pyx_t_27; + __pyx_L34_bool_binop_done:; + if (__pyx_t_19) { + + /* "cssm.pyx":4806 + * if (bias_trace_view[ix] < 1) and (bias_trace_view[ix] > 0): + * # Before high-dim choice is taken + * y_l += tmp_pos_dep * (v_l * delta_t) # Add drift # <<<<<<<<<<<<<< + * y_l += tmp_pos_dep * sqrt_st * gaussian_values[m] # Add noise + * else: +*/ + __pyx_v_y_l = (__pyx_v_y_l + (__pyx_v_tmp_pos_dep * (__pyx_v_v_l * __pyx_v_delta_t))); + + /* "cssm.pyx":4807 + * # Before high-dim choice is taken + * y_l += tmp_pos_dep * (v_l * delta_t) # Add drift + * y_l += tmp_pos_dep * sqrt_st * gaussian_values[m] # Add noise # <<<<<<<<<<<<<< + * else: + * # After high-dim choice is taken +*/ + __pyx_t_26 = __pyx_v_m; + __pyx_v_y_l = (__pyx_v_y_l + ((__pyx_v_tmp_pos_dep * __pyx_v_sqrt_st) * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_26 * __pyx_v_gaussian_values.strides[0]) ))))); + + /* "cssm.pyx":4804 + * tmp_pos_dep = (1 + (d_view[k] * (bias_trace_view[ix] - 1.0))) / (2 - d_view[k]) + * + * if (bias_trace_view[ix] < 1) and (bias_trace_view[ix] > 0): # <<<<<<<<<<<<<< + * # Before high-dim choice is taken + * y_l += tmp_pos_dep * (v_l * delta_t) # Add drift +*/ + goto __pyx_L33; + } + + /* "cssm.pyx":4810 + * else: + * # After high-dim choice is taken + * y_l += (v_l * delta_t) # Add drift # <<<<<<<<<<<<<< + * y_l += sqrt_st * gaussian_values[m] # Add noise + * +*/ + /*else*/ { + __pyx_v_y_l = (__pyx_v_y_l + (__pyx_v_v_l * __pyx_v_delta_t)); + + /* "cssm.pyx":4811 + * # After high-dim choice is taken + * y_l += (v_l * delta_t) # Add drift + * y_l += sqrt_st * gaussian_values[m] # Add noise # <<<<<<<<<<<<<< + * + * t_l += delta_t # update time for low_dim choice +*/ + __pyx_t_26 = __pyx_v_m; + __pyx_v_y_l = (__pyx_v_y_l + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_26 * __pyx_v_gaussian_values.strides[0]) ))))); + } + __pyx_L33:; + + /* "cssm.pyx":4813 + * y_l += sqrt_st * gaussian_values[m] # Add noise + * + * t_l += delta_t # update time for low_dim choice # <<<<<<<<<<<<<< + * ix += 1 # update time index + * m += 1 # update rv couter +*/ + __pyx_v_t_l = (__pyx_v_t_l + __pyx_v_delta_t); + + /* "cssm.pyx":4814 + * + * t_l += delta_t # update time for low_dim choice + * ix += 1 # update time index # <<<<<<<<<<<<<< + * m += 1 # update rv couter + * +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":4815 + * t_l += delta_t # update time for low_dim choice + * ix += 1 # update time index + * m += 1 # update rv couter # <<<<<<<<<<<<<< + * + * if m == num_draws: +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":4817 + * m += 1 # update rv couter + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_19 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_19) { + + /* "cssm.pyx":4818 + * + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_2 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 4818, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":4819 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":4817 + * m += 1 # update rv couter + * + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + } + + /* "cssm.pyx":4821 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4821, __pyx_L1_error) + if (__pyx_t_19) { + + /* "cssm.pyx":4822 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + __pyx_t_19 = (__pyx_v_t_h == 0.0); + if (__pyx_t_19) { + + /* "cssm.pyx":4823 + * if smooth_unif: + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_25 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_25 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4823, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_25 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":4822 + * + * if smooth_unif: + * if t_h == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: +*/ + goto __pyx_L38; + } + + /* "cssm.pyx":4824 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_19 = (fmax(__pyx_v_t_h, __pyx_v_t_l) < __pyx_v_deadline_tmp); + if (__pyx_t_19) { + + /* "cssm.pyx":4825 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_25 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_25 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4825, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_25) * __pyx_v_delta_t); + + /* "cssm.pyx":4824 + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif fmax(t_h, t_l) < deadline_tmp: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L38; + } + + /* "cssm.pyx":4827 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L38:; + + /* "cssm.pyx":4821 + * m = 0 + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_h == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L37; + } + + /* "cssm.pyx":4829 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L37:; + + /* "cssm.pyx":4831 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = fmax(t_h, t_l) + t_view[k] # <<<<<<<<<<<<<< + * + * # The probability of making a 'mistake' 1 - (relative y position) +*/ + __pyx_t_26 = __pyx_v_k; + __pyx_t_20 = __pyx_v_n; + __pyx_t_22 = __pyx_v_k; + __pyx_t_28 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_20 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_22 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_28 * __pyx_v_rts_view.strides[2]) )) = (fmax(__pyx_v_t_h, __pyx_v_t_l) + (*((float *) ( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_26 * __pyx_v_t_view.strides[0]) )))); + + /* "cssm.pyx":4836 + * # y at upper bound --> choices_view[n, k, 0] add one deterministically + * # y at lower bound --> choice_view[n, k, 0] stays the same deterministically + * if random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + __pyx_t_25 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_25 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4836, __pyx_L1_error) + __pyx_t_26 = __pyx_v_ix; + __pyx_t_28 = __pyx_v_ix; + __pyx_t_19 = (__pyx_t_25 <= ((__pyx_v_y_l + (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_26 * __pyx_v_boundary_view.strides[0]) )))) / (2.0 * (*((float *) ( /* dim=0 */ (__pyx_v_boundary_view.data + __pyx_t_28 * __pyx_v_boundary_view.strides[0]) )))))); + if (__pyx_t_19) { + + /* "cssm.pyx":4837 + * # y at lower bound --> choice_view[n, k, 0] stays the same deterministically + * if random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): + * choices_view[n, k, 0] += 1 # <<<<<<<<<<<<<< + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): +*/ + __pyx_t_28 = __pyx_v_n; + __pyx_t_26 = __pyx_v_k; + __pyx_t_22 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_28 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_26 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_22 * __pyx_v_choices_view.strides[2]) )) += 1; + + /* "cssm.pyx":4836 + * # y at upper bound --> choices_view[n, k, 0] add one deterministically + * # y at lower bound --> choice_view[n, k, 0] stays the same deterministically + * if random_uniform() <= ((y_l + boundary_view[ix]) / (2 * boundary_view[ix])): # <<<<<<<<<<<<<< + * choices_view[n, k, 0] += 1 + * +*/ + } + + /* "cssm.pyx":4839 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + __pyx_t_22 = __pyx_v_n; + __pyx_t_26 = __pyx_v_k; + __pyx_t_28 = 0; + __pyx_t_20 = __pyx_v_k; + __pyx_t_29 = __pyx_v_k; + __pyx_t_19 = (((*((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_22 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_26 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_28 * __pyx_v_rts_view.strides[2]) ))) >= (*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_20 * __pyx_v_deadline_view.strides[0]) )))) | ((*((float *) ( /* dim=0 */ (__pyx_v_deadline_view.data + __pyx_t_29 * __pyx_v_deadline_view.strides[0]) ))) <= 0.0)); + if (__pyx_t_19) { + + /* "cssm.pyx":4840 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): + * rts_view[n, k, 0] = -999 # <<<<<<<<<<<<<< + * + * if return_option == 'full': +*/ + __pyx_t_29 = __pyx_v_n; + __pyx_t_20 = __pyx_v_k; + __pyx_t_28 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_29 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_20 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_28 * __pyx_v_rts_view.strides[2]) )) = -999.0; + + /* "cssm.pyx":4839 + * choices_view[n, k, 0] += 1 + * + * if (rts_view[n, k, 0] >= deadline_view[k]) | (deadline_view[k] <= 0): # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = -999 + * +*/ + } + } + } + + /* "cssm.pyx":4842 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, + * 'vl1': vl1, +*/ + __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4842, __pyx_L1_error) + if (__pyx_t_19) { + + /* "cssm.pyx":4843 + * + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, # <<<<<<<<<<<<<< + * 'vl1': vl1, + * 'vl2': vl2, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4843, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4843, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_vh, ((PyObject *)__pyx_v_vh)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4844 + * if return_option == 'full': + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, + * 'vl1': vl1, # <<<<<<<<<<<<<< + * 'vl2': vl2, + * 'a': a, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_vl1, ((PyObject *)__pyx_v_vl1)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4845 + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, + * 'vl1': vl1, + * 'vl2': vl2, # <<<<<<<<<<<<<< + * 'a': a, + * 'zh': zh, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_vl2, ((PyObject *)__pyx_v_vl2)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4846 + * 'vl1': vl1, + * 'vl2': vl2, + * 'a': a, # <<<<<<<<<<<<<< + * 'zh': zh, + * 'zl1': zl1, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4847 + * 'vl2': vl2, + * 'a': a, + * 'zh': zh, # <<<<<<<<<<<<<< + * 'zl1': zl1, + * 'zl2': zl2, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zh, ((PyObject *)__pyx_v_zh)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4848 + * 'a': a, + * 'zh': zh, + * 'zl1': zl1, # <<<<<<<<<<<<<< + * 'zl2': zl2, + * 'd': d, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zl1, ((PyObject *)__pyx_v_zl1)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4849 + * 'zh': zh, + * 'zl1': zl1, + * 'zl2': zl2, # <<<<<<<<<<<<<< + * 'd': d, + * 't': t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_zl2, ((PyObject *)__pyx_v_zl2)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4850 + * 'zl1': zl1, + * 'zl2': zl2, + * 'd': d, # <<<<<<<<<<<<<< + * 't': t, + * 'deadline': deadline, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_d, ((PyObject *)__pyx_v_d)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4851 + * 'zl2': zl2, + * 'd': d, + * 't': t, # <<<<<<<<<<<<<< + * 'deadline': deadline, + * 's': s, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4852 + * 'd': d, + * 't': t, + * 'deadline': deadline, # <<<<<<<<<<<<<< + * 's': s, + * **boundary_params, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_deadline, ((PyObject *)__pyx_v_deadline)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + + /* "cssm.pyx":4853 + * 't': t, + * 'deadline': deadline, + * 's': s, # <<<<<<<<<<<<<< + * **boundary_params, + * 'delta_t': delta_t, +*/ + if (PyDict_SetItem(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + __pyx_t_6 = __pyx_t_3; + __pyx_t_3 = 0; + + /* "cssm.pyx":4854 + * 'deadline': deadline, + * 's': s, + * **boundary_params, # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + if (unlikely(__pyx_v_boundary_params == Py_None)) { + PyErr_SetString(PyExc_TypeError, "argument after ** must be a mapping, not NoneType"); + __PYX_ERR(0, 4854, __pyx_L1_error) + } + if (unlikely(PyDict_Update(__pyx_t_6, __pyx_v_boundary_params) < 0)) { + if (PyErr_ExceptionMatches(PyExc_AttributeError)) __Pyx_RaiseMappingExpectedError(__pyx_v_boundary_params); + __PYX_ERR(0, 4854, __pyx_L1_error) + } + + /* "cssm.pyx":4855 + * 's': s, + * **boundary_params, + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'n_samples': n_samples, +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4855, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_3) < (0)) __PYX_ERR(0, 4855, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4856 + * **boundary_params, + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4856, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_3) < (0)) __PYX_ERR(0, 4856, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4857 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4857, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 4857, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4858 + * 'max_t': max_t, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4858, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 4858, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 4859, __pyx_L1_error) + + /* "cssm.pyx":4860 + * 'n_trials': n_trials, + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': 'This simulator does not yet allow for trajectory simulation', +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4860, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_3) < (0)) __PYX_ERR(0, 4860, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4861 + * 'simulator': 'ddm_flexbound_mic2_adj', + * 'boundary_fun_type': boundary_fun.__name__, + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'trajectory': 'This simulator does not yet allow for trajectory simulation', + * 'boundary': boundary}} +*/ + __pyx_t_3 = PyList_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4861, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 4861, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4861, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 4861, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 4861, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 4861, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_mstate_global->__pyx_kp_u_This_simulator_does_not_yet_allo) < (0)) __PYX_ERR(0, 4862, __pyx_L1_error) + + /* "cssm.pyx":4863 + * 'possible_choices': [0, 1, 2, 3], + * 'trajectory': 'This simulator does not yet allow for trajectory simulation', + * 'boundary': boundary}} # <<<<<<<<<<<<<< + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_boundary, __pyx_v_boundary) < (0)) __PYX_ERR(0, 4863, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_6) < (0)) __PYX_ERR(0, 4843, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":4842 + * rts_view[n, k, 0] = -999 + * + * if return_option == 'full': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'vh': vh, + * 'vl1': vl1, +*/ + } + + /* "cssm.pyx":4864 + * 'trajectory': 'This simulator does not yet allow for trajectory simulation', + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], +*/ + __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 4864, __pyx_L1_error) + if (likely(__pyx_t_19)) { + + /* "cssm.pyx":4865 + * 'boundary': boundary}} + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', # <<<<<<<<<<<<<< + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_1 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4865, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4865, __pyx_L1_error) + __pyx_t_6 = __Pyx_PyDict_NewPresized(5); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_adj) < (0)) __PYX_ERR(0, 4865, __pyx_L1_error) + + /* "cssm.pyx":4866 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], # <<<<<<<<<<<<<< + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, +*/ + __pyx_t_3 = PyList_New(4); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4866, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 4866, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4866, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_2); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_2); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_2) != (0)) __PYX_ERR(0, 4866, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_3); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_3); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 3, __pyx_mstate_global->__pyx_int_3) != (0)) __PYX_ERR(0, 4866, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 4865, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4867 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_v_boundary_fun, __pyx_mstate_global->__pyx_n_u_name_2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4867, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_boundary_fun_type, __pyx_t_3) < (0)) __PYX_ERR(0, 4865, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4868 + * 'possible_choices': [0, 1, 2, 3], + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * }} +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4868, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 4865, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4869 + * 'boundary_fun_type': boundary_fun.__name__, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * }} + * else: +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4869, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 4865, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_6) < (0)) __PYX_ERR(0, 4865, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_1; + __pyx_t_1 = 0; + goto __pyx_L0; + + /* "cssm.pyx":4864 + * 'trajectory': 'This simulator does not yet allow for trajectory simulation', + * 'boundary': boundary}} + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'ddm_flexbound_mic2_adj', + * 'possible_choices': [0, 1, 2, 3], +*/ + } + + /* "cssm.pyx":4872 + * }} + * else: + * raise ValueError('return_option must be either "full" or "minimal"') # <<<<<<<<<<<<<< + * # ----------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_6 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_either_ful}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4872, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_Raise(__pyx_t_1, 0, 0, 0); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __PYX_ERR(0, 4872, __pyx_L1_error) + } + + /* "cssm.pyx":4606 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_tradeoff(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_9, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __Pyx_XDECREF(__pyx_t_11); + __Pyx_XDECREF(__pyx_t_21); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.ddm_flexbound_tradeoff", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_d.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_deadline.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_vl2.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zh.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl1.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_zl2.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_vl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zh_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl1_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_zl2_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_d_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_deadline_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __Pyx_XDECREF(__pyx_v_t_s); + __Pyx_XDECREF(__pyx_v_boundary); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_boundary_view, 1); + __Pyx_XDECREF(__pyx_v_bias_trace); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_bias_trace_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_boundary_params_tmp); + __Pyx_XDECREF(__pyx_9genexpr16__pyx_v_key); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":4880 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def exgauss(np.ndarray[float, ndim = 2] mu, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] sigma, + * np.ndarray[float, ndim = 2] tau, +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_45exgauss(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_44exgauss, " Fit reaction times and choices from an ex-Gaussian distribution \n \n Args: \n mu (np.ndarray[float, ndim = 1]): mean of the gaussian component\n sigma (np.ndarray[float, ndim = 1]): standard deviation of the gaussian component\n tau (np.ndarray[float, ndim = 1]): mean of the exponential component\n p (np.ndarray[float, ndim = 1]): probability of choice 1\n delta_t (float, optional): time step for simulation. Defaults to 0.001.\n n_samples (int, optional): number of samples per trial. Defaults to 20000.\n n_trials (int, optional): number of trials to simulate. Defaults to 1.\n random_state (int, optional): random seed. Defaults to None.\n return_option (str, optional): 'full' or 'minimal' return data. Defaults to 'full'.\n \n Returns: \n dict: simulated reaction times, choices, and metadata\n "); +static PyMethodDef __pyx_mdef_4cssm_45exgauss = {"exgauss", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_45exgauss, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_44exgauss}; +static PyObject *__pyx_pw_4cssm_45exgauss(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_mu = 0; + PyArrayObject *__pyx_v_sigma = 0; + PyArrayObject *__pyx_v_tau = 0; + PyArrayObject *__pyx_v_p = 0; + float __pyx_v_delta_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + float __pyx_v_max_t; + PyObject *__pyx_v_race = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[11] = {0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("exgauss (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_mu,&__pyx_mstate_global->__pyx_n_u_sigma,&__pyx_mstate_global->__pyx_n_u_tau,&__pyx_mstate_global->__pyx_n_u_p,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_race,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 4880, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "exgauss", 1) < (0)) __PYX_ERR(0, 4880, __pyx_L3_error) + + /* "cssm.pyx":4887 + * int n_samples = 20000, + * int n_trials = 1, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * float max_t = -1, +*/ + if (!values[7]) values[7] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[8]) values[8] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + + /* "cssm.pyx":4890 + * return_option = 'full', + * float max_t = -1, + * race = False, # <<<<<<<<<<<<<< + * **kwargs): + * """ Fit reaction times and choices from an ex-Gaussian distribution +*/ + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 4; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("exgauss", 0, 4, 11, i); __PYX_ERR(0, 4880, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 4880, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 4880, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 4880, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 4880, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 4880, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":4887 + * int n_samples = 20000, + * int n_trials = 1, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * float max_t = -1, +*/ + if (!values[7]) values[7] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[8]) values[8] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_mu = ((PyArrayObject *)values[0]); + __pyx_v_sigma = ((PyArrayObject *)values[1]); + __pyx_v_tau = ((PyArrayObject *)values[2]); + __pyx_v_p = ((PyArrayObject *)values[3]); + if (values[4]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[4]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4884, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[5]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[5]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4885, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[6]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[6]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 4886, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_random_state = values[7]; + __pyx_v_return_option = values[8]; + if (values[9]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[9]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 4889, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)-1.0)); + } + __pyx_v_race = values[10]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("exgauss", 0, 4, 11, __pyx_nargs); __PYX_ERR(0, 4880, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.exgauss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_mu), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "mu", 0))) __PYX_ERR(0, 4880, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_sigma), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "sigma", 0))) __PYX_ERR(0, 4881, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_tau), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "tau", 0))) __PYX_ERR(0, 4882, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_p), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "p", 0))) __PYX_ERR(0, 4883, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_44exgauss(__pyx_self, __pyx_v_mu, __pyx_v_sigma, __pyx_v_tau, __pyx_v_p, __pyx_v_delta_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_max_t, __pyx_v_race, __pyx_v_kwargs); + + /* "cssm.pyx":4880 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def exgauss(np.ndarray[float, ndim = 2] mu, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] sigma, + * np.ndarray[float, ndim = 2] tau, +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_44exgauss(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_mu, PyArrayObject *__pyx_v_sigma, PyArrayObject *__pyx_v_tau, PyArrayObject *__pyx_v_p, float __pyx_v_delta_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, float __pyx_v_max_t, PyObject *__pyx_v_race, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + PyObject *__pyx_v_rng = NULL; + npy_intp __pyx_v_n_choices; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + int __pyx_v_k; + int __pyx_v_n; + PyObject *__pyx_v_rt_candidates = NULL; + npy_intp __pyx_v_c; + PyObject *__pyx_v_mu_val = NULL; + PyObject *__pyx_v_sigma_val = NULL; + PyObject *__pyx_v_tau_val = NULL; + PyObject *__pyx_v_norm_sample = NULL; + PyObject *__pyx_v_exp_sample = NULL; + PyObject *__pyx_v_rt_val = NULL; + PyObject *__pyx_v_choice_idx = NULL; + PyObject *__pyx_v_random_val = NULL; + __Pyx_LocalBuf_ND __pyx_pybuffernd_mu; + __Pyx_Buffer __pyx_pybuffer_mu; + __Pyx_LocalBuf_ND __pyx_pybuffernd_p; + __Pyx_Buffer __pyx_pybuffer_p; + __Pyx_LocalBuf_ND __pyx_pybuffernd_sigma; + __Pyx_Buffer __pyx_pybuffer_sigma; + __Pyx_LocalBuf_ND __pyx_pybuffernd_tau; + __Pyx_Buffer __pyx_pybuffer_tau; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + size_t __pyx_t_5; + PyObject *__pyx_t_6 = NULL; + int __pyx_t_7; + PyObject *__pyx_t_8 = NULL; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + int __pyx_t_11; + PyObject *__pyx_t_12 = NULL; + int __pyx_t_13; + int __pyx_t_14; + int __pyx_t_15; + int __pyx_t_16; + int __pyx_t_17; + npy_intp __pyx_t_18; + npy_intp __pyx_t_19; + npy_intp __pyx_t_20; + Py_ssize_t __pyx_t_21; + Py_ssize_t __pyx_t_22; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("exgauss", 0); + __Pyx_INCREF((PyObject *)__pyx_v_mu); + __Pyx_INCREF((PyObject *)__pyx_v_sigma); + __Pyx_INCREF((PyObject *)__pyx_v_tau); + __Pyx_INCREF((PyObject *)__pyx_v_p); + __pyx_pybuffer_mu.pybuffer.buf = NULL; + __pyx_pybuffer_mu.refcount = 0; + __pyx_pybuffernd_mu.data = NULL; + __pyx_pybuffernd_mu.rcbuffer = &__pyx_pybuffer_mu; + __pyx_pybuffer_sigma.pybuffer.buf = NULL; + __pyx_pybuffer_sigma.refcount = 0; + __pyx_pybuffernd_sigma.data = NULL; + __pyx_pybuffernd_sigma.rcbuffer = &__pyx_pybuffer_sigma; + __pyx_pybuffer_tau.pybuffer.buf = NULL; + __pyx_pybuffer_tau.refcount = 0; + __pyx_pybuffernd_tau.data = NULL; + __pyx_pybuffernd_tau.rcbuffer = &__pyx_pybuffer_tau; + __pyx_pybuffer_p.pybuffer.buf = NULL; + __pyx_pybuffer_p.refcount = 0; + __pyx_pybuffernd_p.data = NULL; + __pyx_pybuffernd_p.rcbuffer = &__pyx_pybuffer_p; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mu.rcbuffer->pybuffer, (PyObject*)__pyx_v_mu, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4880, __pyx_L1_error) + } + __pyx_pybuffernd_mu.diminfo[0].strides = __pyx_pybuffernd_mu.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mu.diminfo[0].shape = __pyx_pybuffernd_mu.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_mu.diminfo[1].strides = __pyx_pybuffernd_mu.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_mu.diminfo[1].shape = __pyx_pybuffernd_mu.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sigma.rcbuffer->pybuffer, (PyObject*)__pyx_v_sigma, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4880, __pyx_L1_error) + } + __pyx_pybuffernd_sigma.diminfo[0].strides = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sigma.diminfo[0].shape = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sigma.diminfo[1].strides = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sigma.diminfo[1].shape = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_tau.rcbuffer->pybuffer, (PyObject*)__pyx_v_tau, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4880, __pyx_L1_error) + } + __pyx_pybuffernd_tau.diminfo[0].strides = __pyx_pybuffernd_tau.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_tau.diminfo[0].shape = __pyx_pybuffernd_tau.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_tau.diminfo[1].strides = __pyx_pybuffernd_tau.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_tau.diminfo[1].shape = __pyx_pybuffernd_tau.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_p.rcbuffer->pybuffer, (PyObject*)__pyx_v_p, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 4880, __pyx_L1_error) + } + __pyx_pybuffernd_p.diminfo[0].strides = __pyx_pybuffernd_p.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_p.diminfo[0].shape = __pyx_pybuffernd_p.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":4909 + * """ + * + * rng = np.random.default_rng(random_state) # <<<<<<<<<<<<<< + * + * mu = np.asarray(mu, dtype=DTYPE) +*/ + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4909, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_random); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4909, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_2 = __pyx_t_4; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_random_state}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_default_rng, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4909, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rng = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4911 + * rng = np.random.default_rng(random_state) + * + * mu = np.asarray(mu, dtype=DTYPE) # <<<<<<<<<<<<<< + * sigma = np.asarray(sigma, dtype=DTYPE) + * tau = np.asarray(tau, dtype=DTYPE) +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_asarray); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, ((PyObject *)__pyx_v_mu)}; + __pyx_t_6 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_2, __pyx_t_6, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4911, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_6); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4911, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4911, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mu.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mu.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mu.rcbuffer->pybuffer, (PyObject*)__pyx_v_mu, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10); + } + __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; + } + __pyx_pybuffernd_mu.diminfo[0].strides = __pyx_pybuffernd_mu.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mu.diminfo[0].shape = __pyx_pybuffernd_mu.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_mu.diminfo[1].strides = __pyx_pybuffernd_mu.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_mu.diminfo[1].shape = __pyx_pybuffernd_mu.rcbuffer->pybuffer.shape[1]; + if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4911, __pyx_L1_error) + } + __Pyx_DECREF_SET(__pyx_v_mu, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":4912 + * + * mu = np.asarray(mu, dtype=DTYPE) + * sigma = np.asarray(sigma, dtype=DTYPE) # <<<<<<<<<<<<<< + * tau = np.asarray(tau, dtype=DTYPE) + * p = np.asarray(p, dtype=DTYPE) +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_asarray); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, ((PyObject *)__pyx_v_sigma)}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4912, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4912, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4912, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sigma.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sigma.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sigma.rcbuffer->pybuffer, (PyObject*)__pyx_v_sigma, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_8); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_10, __pyx_t_9, __pyx_t_8); + } + __pyx_t_10 = __pyx_t_9 = __pyx_t_8 = 0; + } + __pyx_pybuffernd_sigma.diminfo[0].strides = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sigma.diminfo[0].shape = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sigma.diminfo[1].strides = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sigma.diminfo[1].shape = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.shape[1]; + if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4912, __pyx_L1_error) + } + __Pyx_DECREF_SET(__pyx_v_sigma, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":4913 + * mu = np.asarray(mu, dtype=DTYPE) + * sigma = np.asarray(sigma, dtype=DTYPE) + * tau = np.asarray(tau, dtype=DTYPE) # <<<<<<<<<<<<<< + * p = np.asarray(p, dtype=DTYPE) + * n_choices = mu.shape[1] +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_asarray); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_2, ((PyObject *)__pyx_v_tau)}; + __pyx_t_3 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_4, __pyx_t_3, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4913, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_3); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4913, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4913, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_tau.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_tau.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_tau.rcbuffer->pybuffer, (PyObject*)__pyx_v_tau, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10); + } + __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; + } + __pyx_pybuffernd_tau.diminfo[0].strides = __pyx_pybuffernd_tau.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_tau.diminfo[0].shape = __pyx_pybuffernd_tau.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_tau.diminfo[1].strides = __pyx_pybuffernd_tau.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_tau.diminfo[1].shape = __pyx_pybuffernd_tau.rcbuffer->pybuffer.shape[1]; + if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4913, __pyx_L1_error) + } + __Pyx_DECREF_SET(__pyx_v_tau, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":4914 + * sigma = np.asarray(sigma, dtype=DTYPE) + * tau = np.asarray(tau, dtype=DTYPE) + * p = np.asarray(p, dtype=DTYPE) # <<<<<<<<<<<<<< + * n_choices = mu.shape[1] + * +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_asarray); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, ((PyObject *)__pyx_v_p)}; + __pyx_t_2 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_2, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4914, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_2); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4914, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4914, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_p.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_p.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_p.rcbuffer->pybuffer, (PyObject*)__pyx_v_p, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_8); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_10, __pyx_t_9, __pyx_t_8); + } + __pyx_t_10 = __pyx_t_9 = __pyx_t_8 = 0; + } + __pyx_pybuffernd_p.diminfo[0].strides = __pyx_pybuffernd_p.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_p.diminfo[0].shape = __pyx_pybuffernd_p.rcbuffer->pybuffer.shape[0]; + if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4914, __pyx_L1_error) + } + __Pyx_DECREF_SET(__pyx_v_p, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":4915 + * tau = np.asarray(tau, dtype=DTYPE) + * p = np.asarray(p, dtype=DTYPE) + * n_choices = mu.shape[1] # <<<<<<<<<<<<<< + * + * if mu.size == 1: +*/ + __pyx_v_n_choices = (__pyx_f_5numpy_7ndarray_5shape_shape(((PyArrayObject *)__pyx_v_mu))[1]); + + /* "cssm.pyx":4917 + * n_choices = mu.shape[1] + * + * if mu.size == 1: # <<<<<<<<<<<<<< + * mu = np.repeat(mu, n_trials) + * if sigma.size == 1: +*/ + __pyx_t_11 = (__pyx_f_5numpy_7ndarray_4size_size(((PyArrayObject *)__pyx_v_mu)) == 1); + if (__pyx_t_11) { + + /* "cssm.pyx":4918 + * + * if mu.size == 1: + * mu = np.repeat(mu, n_trials) # <<<<<<<<<<<<<< + * if sigma.size == 1: + * sigma = np.repeat(sigma, n_trials) +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_repeat); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, ((PyObject *)__pyx_v_mu), __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4918, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4918, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mu.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mu.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_mu.rcbuffer->pybuffer, (PyObject*)__pyx_v_mu, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10); + } + __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; + } + __pyx_pybuffernd_mu.diminfo[0].strides = __pyx_pybuffernd_mu.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_mu.diminfo[0].shape = __pyx_pybuffernd_mu.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_mu.diminfo[1].strides = __pyx_pybuffernd_mu.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_mu.diminfo[1].shape = __pyx_pybuffernd_mu.rcbuffer->pybuffer.shape[1]; + if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4918, __pyx_L1_error) + } + __Pyx_DECREF_SET(__pyx_v_mu, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":4917 + * n_choices = mu.shape[1] + * + * if mu.size == 1: # <<<<<<<<<<<<<< + * mu = np.repeat(mu, n_trials) + * if sigma.size == 1: +*/ + } + + /* "cssm.pyx":4919 + * if mu.size == 1: + * mu = np.repeat(mu, n_trials) + * if sigma.size == 1: # <<<<<<<<<<<<<< + * sigma = np.repeat(sigma, n_trials) + * if tau.size == 1: +*/ + __pyx_t_11 = (__pyx_f_5numpy_7ndarray_4size_size(((PyArrayObject *)__pyx_v_sigma)) == 1); + if (__pyx_t_11) { + + /* "cssm.pyx":4920 + * mu = np.repeat(mu, n_trials) + * if sigma.size == 1: + * sigma = np.repeat(sigma, n_trials) # <<<<<<<<<<<<<< + * if tau.size == 1: + * tau = np.repeat(tau, n_trials) +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_repeat); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_3, ((PyObject *)__pyx_v_sigma), __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4920, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4920, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sigma.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sigma.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_10, &__pyx_t_9, &__pyx_t_8); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_sigma.rcbuffer->pybuffer, (PyObject*)__pyx_v_sigma, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_10); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_8); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_10, __pyx_t_9, __pyx_t_8); + } + __pyx_t_10 = __pyx_t_9 = __pyx_t_8 = 0; + } + __pyx_pybuffernd_sigma.diminfo[0].strides = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_sigma.diminfo[0].shape = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_sigma.diminfo[1].strides = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_sigma.diminfo[1].shape = __pyx_pybuffernd_sigma.rcbuffer->pybuffer.shape[1]; + if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4920, __pyx_L1_error) + } + __Pyx_DECREF_SET(__pyx_v_sigma, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":4919 + * if mu.size == 1: + * mu = np.repeat(mu, n_trials) + * if sigma.size == 1: # <<<<<<<<<<<<<< + * sigma = np.repeat(sigma, n_trials) + * if tau.size == 1: +*/ + } + + /* "cssm.pyx":4921 + * if sigma.size == 1: + * sigma = np.repeat(sigma, n_trials) + * if tau.size == 1: # <<<<<<<<<<<<<< + * tau = np.repeat(tau, n_trials) + * +*/ + __pyx_t_11 = (__pyx_f_5numpy_7ndarray_4size_size(((PyArrayObject *)__pyx_v_tau)) == 1); + if (__pyx_t_11) { + + /* "cssm.pyx":4922 + * sigma = np.repeat(sigma, n_trials) + * if tau.size == 1: + * tau = np.repeat(tau, n_trials) # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_repeat); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[3] = {__pyx_t_4, ((PyObject *)__pyx_v_tau), __pyx_t_2}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4922, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + if (!(likely(((__pyx_t_1) == Py_None) || likely(__Pyx_TypeTest(__pyx_t_1, __pyx_mstate_global->__pyx_ptype_5numpy_ndarray))))) __PYX_ERR(0, 4922, __pyx_L1_error) + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_tau.rcbuffer->pybuffer); + __pyx_t_7 = __Pyx_GetBufferAndValidate(&__pyx_pybuffernd_tau.rcbuffer->pybuffer, (PyObject*)((PyArrayObject *)__pyx_t_1), &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack); + if (unlikely(__pyx_t_7 < 0)) { + PyErr_Fetch(&__pyx_t_8, &__pyx_t_9, &__pyx_t_10); + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_tau.rcbuffer->pybuffer, (PyObject*)__pyx_v_tau, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) { + Py_XDECREF(__pyx_t_8); Py_XDECREF(__pyx_t_9); Py_XDECREF(__pyx_t_10); + __Pyx_RaiseBufferFallbackError(); + } else { + PyErr_Restore(__pyx_t_8, __pyx_t_9, __pyx_t_10); + } + __pyx_t_8 = __pyx_t_9 = __pyx_t_10 = 0; + } + __pyx_pybuffernd_tau.diminfo[0].strides = __pyx_pybuffernd_tau.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_tau.diminfo[0].shape = __pyx_pybuffernd_tau.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_tau.diminfo[1].strides = __pyx_pybuffernd_tau.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_tau.diminfo[1].shape = __pyx_pybuffernd_tau.rcbuffer->pybuffer.shape[1]; + if (unlikely((__pyx_t_7 < 0))) __PYX_ERR(0, 4922, __pyx_L1_error) + } + __Pyx_DECREF_SET(__pyx_v_tau, ((PyArrayObject *)__pyx_t_1)); + __pyx_t_1 = 0; + + /* "cssm.pyx":4921 + * if sigma.size == 1: + * sigma = np.repeat(sigma, n_trials) + * if tau.size == 1: # <<<<<<<<<<<<<< + * tau = np.repeat(tau, n_trials) + * +*/ + } + + /* "cssm.pyx":4925 + * + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * +*/ + __pyx_t_3 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_12 = PyTuple_New(3); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 4925, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_6); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 1, __pyx_t_6) != (0)) __PYX_ERR(0, 4925, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_12, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4925, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_6 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_4))) { + __pyx_t_3 = PyMethod_GET_SELF(__pyx_t_4); + assert(__pyx_t_3); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_4); + __Pyx_INCREF(__pyx_t_3); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_4, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_3, __pyx_t_12}; + __pyx_t_2 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_2, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4925, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_4, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4925, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4926 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_12 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 4926, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_12); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_12) != (0)) __PYX_ERR(0, 4926, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4926, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_12 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_3}; + __pyx_t_12 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_2, __pyx_t_12, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4926, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_12); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4926, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":4928 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * for n in range(n_samples): + * # decide choice +*/ + __pyx_t_7 = __pyx_v_n_trials; + __pyx_t_13 = __pyx_t_7; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_k = __pyx_t_14; + + /* "cssm.pyx":4929 + * + * for k in range(n_trials): + * for n in range(n_samples): # <<<<<<<<<<<<<< + * # decide choice + * if race: +*/ + __pyx_t_15 = __pyx_v_n_samples; + __pyx_t_16 = __pyx_t_15; + for (__pyx_t_17 = 0; __pyx_t_17 < __pyx_t_16; __pyx_t_17+=1) { + __pyx_v_n = __pyx_t_17; + + /* "cssm.pyx":4931 + * for n in range(n_samples): + * # decide choice + * if race: # <<<<<<<<<<<<<< + * # choose 'choice' from race + * rt_candidates = np.empty(n_choices, dtype=DTYPE) +*/ + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_race); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4931, __pyx_L1_error) + if (__pyx_t_11) { + + /* "cssm.pyx":4933 + * if race: + * # choose 'choice' from race + * rt_candidates = np.empty(n_choices, dtype=DTYPE) # <<<<<<<<<<<<<< + * for c in range(n_choices): + * mu_val = mu[k, c] +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __pyx_t_2 = __Pyx_PyObject_GetAttrStr(__pyx_t_12, __pyx_mstate_global->__pyx_n_u_empty); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __pyx_t_12 = __Pyx_PyLong_From_npy_intp(__pyx_v_n_choices); if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 4933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_12); + __Pyx_GetModuleGlobalName(__pyx_t_3, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_2))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_2); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_2); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_2, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_12}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_3, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 4933, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_2, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_12); __pyx_t_12 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4933, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_rt_candidates, __pyx_t_1); + __pyx_t_1 = 0; + + /* "cssm.pyx":4934 + * # choose 'choice' from race + * rt_candidates = np.empty(n_choices, dtype=DTYPE) + * for c in range(n_choices): # <<<<<<<<<<<<<< + * mu_val = mu[k, c] + * sigma_val = sigma[k, c] +*/ + __pyx_t_18 = __pyx_v_n_choices; + __pyx_t_19 = __pyx_t_18; + for (__pyx_t_20 = 0; __pyx_t_20 < __pyx_t_19; __pyx_t_20+=1) { + __pyx_v_c = __pyx_t_20; + + /* "cssm.pyx":4935 + * rt_candidates = np.empty(n_choices, dtype=DTYPE) + * for c in range(n_choices): + * mu_val = mu[k, c] # <<<<<<<<<<<<<< + * sigma_val = sigma[k, c] + * tau_val = tau[k, c] +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = __pyx_v_c; + __pyx_t_1 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_mu.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_mu.diminfo[0].strides, __pyx_t_22, __pyx_pybuffernd_mu.diminfo[1].strides))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4935, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_mu_val, __pyx_t_1); + __pyx_t_1 = 0; + + /* "cssm.pyx":4936 + * for c in range(n_choices): + * mu_val = mu[k, c] + * sigma_val = sigma[k, c] # <<<<<<<<<<<<<< + * tau_val = tau[k, c] + * +*/ + __pyx_t_22 = __pyx_v_k; + __pyx_t_21 = __pyx_v_c; + __pyx_t_1 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_sigma.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_sigma.diminfo[0].strides, __pyx_t_21, __pyx_pybuffernd_sigma.diminfo[1].strides))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4936, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_sigma_val, __pyx_t_1); + __pyx_t_1 = 0; + + /* "cssm.pyx":4937 + * mu_val = mu[k, c] + * sigma_val = sigma[k, c] + * tau_val = tau[k, c] # <<<<<<<<<<<<<< + * + * # draw components and compose RT +*/ + __pyx_t_21 = __pyx_v_k; + __pyx_t_22 = __pyx_v_c; + __pyx_t_1 = PyFloat_FromDouble((*__Pyx_BufPtrStrided2d(float *, __pyx_pybuffernd_tau.rcbuffer->pybuffer.buf, __pyx_t_21, __pyx_pybuffernd_tau.diminfo[0].strides, __pyx_t_22, __pyx_pybuffernd_tau.diminfo[1].strides))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4937, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_tau_val, __pyx_t_1); + __pyx_t_1 = 0; + + /* "cssm.pyx":4940 + * + * # draw components and compose RT + * norm_sample = rng.normal(mu_val, sigma_val) # <<<<<<<<<<<<<< + * exp_sample = rng.exponential(tau_val) + * rt_val = norm_sample + exp_sample +*/ + __pyx_t_2 = __pyx_v_rng; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_2, __pyx_v_mu_val, __pyx_v_sigma_val}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_normal, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4940, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_norm_sample, __pyx_t_1); + __pyx_t_1 = 0; + + /* "cssm.pyx":4941 + * # draw components and compose RT + * norm_sample = rng.normal(mu_val, sigma_val) + * exp_sample = rng.exponential(tau_val) # <<<<<<<<<<<<<< + * rt_val = norm_sample + exp_sample + * +*/ + __pyx_t_2 = __pyx_v_rng; + __Pyx_INCREF(__pyx_t_2); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_tau_val}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_exponential, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4941, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_exp_sample, __pyx_t_1); + __pyx_t_1 = 0; + + /* "cssm.pyx":4942 + * norm_sample = rng.normal(mu_val, sigma_val) + * exp_sample = rng.exponential(tau_val) + * rt_val = norm_sample + exp_sample # <<<<<<<<<<<<<< + * + * if rt_val < 0.0: # ensure no negative rts +*/ + __pyx_t_1 = PyNumber_Add(__pyx_v_norm_sample, __pyx_v_exp_sample); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4942, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_XDECREF_SET(__pyx_v_rt_val, __pyx_t_1); + __pyx_t_1 = 0; + + /* "cssm.pyx":4944 + * rt_val = norm_sample + exp_sample + * + * if rt_val < 0.0: # ensure no negative rts # <<<<<<<<<<<<<< + * rt_val = 0.0 + * rt_candidates[c] = rt_val +*/ + __pyx_t_1 = PyObject_RichCompare(__pyx_v_rt_val, __pyx_mstate_global->__pyx_float_0_0, Py_LT); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4944, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4944, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + if (__pyx_t_11) { + + /* "cssm.pyx":4945 + * + * if rt_val < 0.0: # ensure no negative rts + * rt_val = 0.0 # <<<<<<<<<<<<<< + * rt_candidates[c] = rt_val + * choice_idx = np.argmin(rt_candidates) +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0); + __Pyx_DECREF_SET(__pyx_v_rt_val, __pyx_mstate_global->__pyx_float_0_0); + + /* "cssm.pyx":4944 + * rt_val = norm_sample + exp_sample + * + * if rt_val < 0.0: # ensure no negative rts # <<<<<<<<<<<<<< + * rt_val = 0.0 + * rt_candidates[c] = rt_val +*/ + } + + /* "cssm.pyx":4946 + * if rt_val < 0.0: # ensure no negative rts + * rt_val = 0.0 + * rt_candidates[c] = rt_val # <<<<<<<<<<<<<< + * choice_idx = np.argmin(rt_candidates) + * choices[n, k, 0] = 1 if choice_idx == 0 else -1 +*/ + if (unlikely((__Pyx_SetItemInt(__pyx_v_rt_candidates, __pyx_v_c, __pyx_v_rt_val, npy_intp, 1, __Pyx_PyLong_From_npy_intp, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(0, 4946, __pyx_L1_error) + } + + /* "cssm.pyx":4947 + * rt_val = 0.0 + * rt_candidates[c] = rt_val + * choice_idx = np.argmin(rt_candidates) # <<<<<<<<<<<<<< + * choices[n, k, 0] = 1 if choice_idx == 0 else -1 + * rts[n, k, 0] = rt_candidates[choice_idx] +*/ + __pyx_t_2 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_3 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_argmin); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_5 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_3))) { + __pyx_t_2 = PyMethod_GET_SELF(__pyx_t_3); + assert(__pyx_t_2); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_3); + __Pyx_INCREF(__pyx_t_2); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_3, __pyx__function); + __pyx_t_5 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_v_rt_candidates}; + __pyx_t_1 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_3, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4947, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_choice_idx, __pyx_t_1); + __pyx_t_1 = 0; + + /* "cssm.pyx":4948 + * rt_candidates[c] = rt_val + * choice_idx = np.argmin(rt_candidates) + * choices[n, k, 0] = 1 if choice_idx == 0 else -1 # <<<<<<<<<<<<<< + * rts[n, k, 0] = rt_candidates[choice_idx] + * +*/ + __pyx_t_11 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_choice_idx, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4948, __pyx_L1_error) + if (__pyx_t_11) { + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __pyx_t_1 = __pyx_mstate_global->__pyx_int_1; + } else { + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __pyx_t_1 = __pyx_mstate_global->__pyx_int_neg_1; + } + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_k); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4948, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 4948, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 4948, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 4948, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_2 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_choices, __pyx_t_4, __pyx_t_1) < 0))) __PYX_ERR(0, 4948, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":4949 + * choice_idx = np.argmin(rt_candidates) + * choices[n, k, 0] = 1 if choice_idx == 0 else -1 + * rts[n, k, 0] = rt_candidates[choice_idx] # <<<<<<<<<<<<<< + * + * else: +*/ + __pyx_t_1 = __Pyx_PyObject_GetItem(__pyx_v_rt_candidates, __pyx_v_choice_idx); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4949, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4949, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_k); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4949, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4949, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_4) != (0)) __PYX_ERR(0, 4949, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_2) != (0)) __PYX_ERR(0, 4949, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 4949, __pyx_L1_error); + __pyx_t_4 = 0; + __pyx_t_2 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_rts, __pyx_t_3, __pyx_t_1) < 0))) __PYX_ERR(0, 4949, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":4931 + * for n in range(n_samples): + * # decide choice + * if race: # <<<<<<<<<<<<<< + * # choose 'choice' from race + * rt_candidates = np.empty(n_choices, dtype=DTYPE) +*/ + goto __pyx_L10; + } + + /* "cssm.pyx":4953 + * else: + * # choose 'choice' from Bernoulli + * random_val = rng.random() # <<<<<<<<<<<<<< + * if random_val <= p[k]: + * choice_idx = 0 +*/ + /*else*/ { + __pyx_t_3 = __pyx_v_rng; + __Pyx_INCREF(__pyx_t_3); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_3, NULL}; + __pyx_t_1 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_random, __pyx_callargs+__pyx_t_5, (1-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4953, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __Pyx_XDECREF_SET(__pyx_v_random_val, __pyx_t_1); + __pyx_t_1 = 0; + + /* "cssm.pyx":4954 + * # choose 'choice' from Bernoulli + * random_val = rng.random() + * if random_val <= p[k]: # <<<<<<<<<<<<<< + * choice_idx = 0 + * choices[n, k, 0] = 1 +*/ + __pyx_t_22 = __pyx_v_k; + __pyx_t_1 = PyFloat_FromDouble((*__Pyx_BufPtrStrided1d(float *, __pyx_pybuffernd_p.rcbuffer->pybuffer.buf, __pyx_t_22, __pyx_pybuffernd_p.diminfo[0].strides))); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4954, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyObject_RichCompare(__pyx_v_random_val, __pyx_t_1, Py_LE); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4954, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4954, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_11) { + + /* "cssm.pyx":4955 + * random_val = rng.random() + * if random_val <= p[k]: + * choice_idx = 0 # <<<<<<<<<<<<<< + * choices[n, k, 0] = 1 + * +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_XDECREF_SET(__pyx_v_choice_idx, __pyx_mstate_global->__pyx_int_0); + + /* "cssm.pyx":4956 + * if random_val <= p[k]: + * choice_idx = 0 + * choices[n, k, 0] = 1 # <<<<<<<<<<<<<< + * + * else: +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_k); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4956, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 4956, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 4956, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 4956, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_choices, __pyx_t_2, __pyx_mstate_global->__pyx_int_1) < 0))) __PYX_ERR(0, 4956, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + + /* "cssm.pyx":4954 + * # choose 'choice' from Bernoulli + * random_val = rng.random() + * if random_val <= p[k]: # <<<<<<<<<<<<<< + * choice_idx = 0 + * choices[n, k, 0] = 1 +*/ + goto __pyx_L14; + } + + /* "cssm.pyx":4959 + * + * else: + * choice_idx = 1 # <<<<<<<<<<<<<< + * choices[n, k, 0] = -1 + * +*/ + /*else*/ { + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_XDECREF_SET(__pyx_v_choice_idx, __pyx_mstate_global->__pyx_int_1); + + /* "cssm.pyx":4960 + * else: + * choice_idx = 1 + * choices[n, k, 0] = -1 # <<<<<<<<<<<<<< + * + * mu_val = mu[k, choice_idx] +*/ + __pyx_t_2 = __Pyx_PyLong_From_int(__pyx_v_n); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_k); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_3 = PyTuple_New(3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4960, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_GIVEREF(__pyx_t_2); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 0, __pyx_t_2) != (0)) __PYX_ERR(0, 4960, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 4960, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_3, 2, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 4960, __pyx_L1_error); + __pyx_t_2 = 0; + __pyx_t_1 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_choices, __pyx_t_3, __pyx_mstate_global->__pyx_int_neg_1) < 0))) __PYX_ERR(0, 4960, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + } + __pyx_L14:; + + /* "cssm.pyx":4962 + * choices[n, k, 0] = -1 + * + * mu_val = mu[k, choice_idx] # <<<<<<<<<<<<<< + * sigma_val = sigma[k, choice_idx] + * tau_val = tau[k, choice_idx] +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_k); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 4962, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_choice_idx); + __Pyx_GIVEREF(__pyx_v_choice_idx); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_choice_idx) != (0)) __PYX_ERR(0, 4962, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_mu), __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4962, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_mu_val, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":4963 + * + * mu_val = mu[k, choice_idx] + * sigma_val = sigma[k, choice_idx] # <<<<<<<<<<<<<< + * tau_val = tau[k, choice_idx] + * +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_k); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 4963, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_choice_idx); + __Pyx_GIVEREF(__pyx_v_choice_idx); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_choice_idx) != (0)) __PYX_ERR(0, 4963, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_sigma), __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4963, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_sigma_val, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":4964 + * mu_val = mu[k, choice_idx] + * sigma_val = sigma[k, choice_idx] + * tau_val = tau[k, choice_idx] # <<<<<<<<<<<<<< + * + * # draw components and compose RT +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_k); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = PyTuple_New(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 4964, __pyx_L1_error); + __Pyx_INCREF(__pyx_v_choice_idx); + __Pyx_GIVEREF(__pyx_v_choice_idx); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_1, 1, __pyx_v_choice_idx) != (0)) __PYX_ERR(0, 4964, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyObject_GetItem(((PyObject *)__pyx_v_tau), __pyx_t_1); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4964, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF_SET(__pyx_v_tau_val, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":4967 + * + * # draw components and compose RT + * norm_sample = rng.normal(mu_val, sigma_val) # <<<<<<<<<<<<<< + * exp_sample = rng.exponential(tau_val) + * rt_val = norm_sample + exp_sample +*/ + __pyx_t_1 = __pyx_v_rng; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[3] = {__pyx_t_1, __pyx_v_mu_val, __pyx_v_sigma_val}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_normal, __pyx_callargs+__pyx_t_5, (3-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4967, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_norm_sample, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":4968 + * # draw components and compose RT + * norm_sample = rng.normal(mu_val, sigma_val) + * exp_sample = rng.exponential(tau_val) # <<<<<<<<<<<<<< + * rt_val = norm_sample + exp_sample + * +*/ + __pyx_t_1 = __pyx_v_rng; + __Pyx_INCREF(__pyx_t_1); + __pyx_t_5 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_tau_val}; + __pyx_t_3 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_exponential, __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + } + __Pyx_XDECREF_SET(__pyx_v_exp_sample, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":4969 + * norm_sample = rng.normal(mu_val, sigma_val) + * exp_sample = rng.exponential(tau_val) + * rt_val = norm_sample + exp_sample # <<<<<<<<<<<<<< + * + * if rt_val < 0.0: # ensure no negative rts +*/ + __pyx_t_3 = PyNumber_Add(__pyx_v_norm_sample, __pyx_v_exp_sample); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4969, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_XDECREF_SET(__pyx_v_rt_val, __pyx_t_3); + __pyx_t_3 = 0; + + /* "cssm.pyx":4971 + * rt_val = norm_sample + exp_sample + * + * if rt_val < 0.0: # ensure no negative rts # <<<<<<<<<<<<<< + * rt_val = 0.0 + * rts[n, k, 0] = rt_val +*/ + __pyx_t_3 = PyObject_RichCompare(__pyx_v_rt_val, __pyx_mstate_global->__pyx_float_0_0, Py_LT); __Pyx_XGOTREF(__pyx_t_3); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4971, __pyx_L1_error) + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_t_3); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4971, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (__pyx_t_11) { + + /* "cssm.pyx":4972 + * + * if rt_val < 0.0: # ensure no negative rts + * rt_val = 0.0 # <<<<<<<<<<<<<< + * rts[n, k, 0] = rt_val + * +*/ + __Pyx_INCREF(__pyx_mstate_global->__pyx_float_0_0); + __Pyx_DECREF_SET(__pyx_v_rt_val, __pyx_mstate_global->__pyx_float_0_0); + + /* "cssm.pyx":4971 + * rt_val = norm_sample + exp_sample + * + * if rt_val < 0.0: # ensure no negative rts # <<<<<<<<<<<<<< + * rt_val = 0.0 + * rts[n, k, 0] = rt_val +*/ + } + + /* "cssm.pyx":4973 + * if rt_val < 0.0: # ensure no negative rts + * rt_val = 0.0 + * rts[n, k, 0] = rt_val # <<<<<<<<<<<<<< + * + * if race: +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4973, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __pyx_t_1 = __Pyx_PyLong_From_int(__pyx_v_k); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4973, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_2 = PyTuple_New(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4973, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + __Pyx_GIVEREF(__pyx_t_3); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 0, __pyx_t_3) != (0)) __PYX_ERR(0, 4973, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 1, __pyx_t_1) != (0)) __PYX_ERR(0, 4973, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_0); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_0); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_2, 2, __pyx_mstate_global->__pyx_int_0) != (0)) __PYX_ERR(0, 4973, __pyx_L1_error); + __pyx_t_3 = 0; + __pyx_t_1 = 0; + if (unlikely((PyObject_SetItem(__pyx_v_rts, __pyx_t_2, __pyx_v_rt_val) < 0))) __PYX_ERR(0, 4973, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + } + __pyx_L10:; + } + } + + /* "cssm.pyx":4975 + * rts[n, k, 0] = rt_val + * + * if race: # <<<<<<<<<<<<<< + * if return_option == 'full': + * return { +*/ + __pyx_t_11 = __Pyx_PyObject_IsTrue(__pyx_v_race); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4975, __pyx_L1_error) + if (__pyx_t_11) { + + /* "cssm.pyx":4976 + * + * if race: + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { + * 'rts': rts, +*/ + __pyx_t_11 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4976, __pyx_L1_error) + if (__pyx_t_11) { + + /* "cssm.pyx":4977 + * if race: + * if return_option == 'full': + * return { # <<<<<<<<<<<<<< + * 'rts': rts, + * 'choices': choices, +*/ + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":4978 + * if return_option == 'full': + * return { + * 'rts': rts, # <<<<<<<<<<<<<< + * 'choices': choices, + * 'metadata': { +*/ + __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4978, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4978, __pyx_L1_error) + + /* "cssm.pyx":4979 + * return { + * 'rts': rts, + * 'choices': choices, # <<<<<<<<<<<<<< + * 'metadata': { + * 'mu': mu, 'sigma': sigma, 'tau': tau, +*/ + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4978, __pyx_L1_error) + + /* "cssm.pyx":4981 + * 'choices': choices, + * 'metadata': { + * 'mu': mu, 'sigma': sigma, 'tau': tau, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4981, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_mu, ((PyObject *)__pyx_v_mu)) < (0)) __PYX_ERR(0, 4981, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_sigma, ((PyObject *)__pyx_v_sigma)) < (0)) __PYX_ERR(0, 4981, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_tau, ((PyObject *)__pyx_v_tau)) < (0)) __PYX_ERR(0, 4981, __pyx_L1_error) + + /* "cssm.pyx":4982 + * 'metadata': { + * 'mu': mu, 'sigma': sigma, 'tau': tau, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'exgauss_race', +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4982, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 4981, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4983 + * 'mu': mu, 'sigma': sigma, 'tau': tau, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'exgauss_race', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4983, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 4981, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_exgauss_race) < (0)) __PYX_ERR(0, 4981, __pyx_L1_error) + + /* "cssm.pyx":4985 + * 'n_trials': n_trials, + * 'simulator': 'exgauss_race', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t +*/ + __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4985, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 4985, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4985, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 4981, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4986 + * 'simulator': 'exgauss_race', + * 'possible_choices': [-1, 1], + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t + * } +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4986, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_3) < (0)) __PYX_ERR(0, 4981, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":4987 + * 'possible_choices': [-1, 1], + * 'delta_t': delta_t, + * 'max_t': max_t # <<<<<<<<<<<<<< + * } + * } +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4987, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_3) < (0)) __PYX_ERR(0, 4981, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_1) < (0)) __PYX_ERR(0, 4978, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "cssm.pyx":4976 + * + * if race: + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { + * 'rts': rts, +*/ + } + + /* "cssm.pyx":4990 + * } + * } + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss_race', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}} + * else: +*/ + __pyx_t_11 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4990, __pyx_L1_error) + if (likely(__pyx_t_11)) { + + /* "cssm.pyx":4991 + * } + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss_race', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}} # <<<<<<<<<<<<<< + * else: + * raise ValueError("return_option must be 'full' or 'minimal'") +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4991, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4991, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 4991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_exgauss_race) < (0)) __PYX_ERR(0, 4991, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 4991, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 4991, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 4991, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 4991, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 4991, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 4991, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_1) < (0)) __PYX_ERR(0, 4991, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "cssm.pyx":4990 + * } + * } + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss_race', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}} + * else: +*/ + } + + /* "cssm.pyx":4993 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss_race', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}} + * else: + * raise ValueError("return_option must be 'full' or 'minimal'") # <<<<<<<<<<<<<< + * else: + * if return_option == 'full': +*/ + /*else*/ { + __pyx_t_1 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_full_or_mi}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4993, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 4993, __pyx_L1_error) + } + + /* "cssm.pyx":4975 + * rts[n, k, 0] = rt_val + * + * if race: # <<<<<<<<<<<<<< + * if return_option == 'full': + * return { +*/ + } + + /* "cssm.pyx":4995 + * raise ValueError("return_option must be 'full' or 'minimal'") + * else: + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { + * 'rts': rts, +*/ + /*else*/ { + __pyx_t_11 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 4995, __pyx_L1_error) + if (__pyx_t_11) { + + /* "cssm.pyx":4996 + * else: + * if return_option == 'full': + * return { # <<<<<<<<<<<<<< + * 'rts': rts, + * 'choices': choices, +*/ + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":4997 + * if return_option == 'full': + * return { + * 'rts': rts, # <<<<<<<<<<<<<< + * 'choices': choices, + * 'metadata': { +*/ + __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 4997, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 4997, __pyx_L1_error) + + /* "cssm.pyx":4998 + * return { + * 'rts': rts, + * 'choices': choices, # <<<<<<<<<<<<<< + * 'metadata': { + * 'mu': mu, 'sigma': sigma, 'tau': tau, +*/ + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 4997, __pyx_L1_error) + + /* "cssm.pyx":5000 + * 'choices': choices, + * 'metadata': { + * 'mu': mu, 'sigma': sigma, 'tau': tau, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_1 = __Pyx_PyDict_NewPresized(9); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5000, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_mu, ((PyObject *)__pyx_v_mu)) < (0)) __PYX_ERR(0, 5000, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_sigma, ((PyObject *)__pyx_v_sigma)) < (0)) __PYX_ERR(0, 5000, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_tau, ((PyObject *)__pyx_v_tau)) < (0)) __PYX_ERR(0, 5000, __pyx_L1_error) + + /* "cssm.pyx":5001 + * 'metadata': { + * 'mu': mu, 'sigma': sigma, 'tau': tau, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'exgauss', +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5001, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 5000, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":5002 + * 'mu': mu, 'sigma': sigma, 'tau': tau, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'exgauss', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5002, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 5000, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_exgauss) < (0)) __PYX_ERR(0, 5000, __pyx_L1_error) + + /* "cssm.pyx":5004 + * 'n_trials': n_trials, + * 'simulator': 'exgauss', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t +*/ + __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5004, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 5004, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 5004, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 5000, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":5005 + * 'simulator': 'exgauss', + * 'possible_choices': [-1, 1], + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t + * } +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5005, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_3) < (0)) __PYX_ERR(0, 5000, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + + /* "cssm.pyx":5006 + * 'possible_choices': [-1, 1], + * 'delta_t': delta_t, + * 'max_t': max_t # <<<<<<<<<<<<<< + * } + * } +*/ + __pyx_t_3 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5006, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_3) < (0)) __PYX_ERR(0, 5000, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_1) < (0)) __PYX_ERR(0, 4997, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "cssm.pyx":4995 + * raise ValueError("return_option must be 'full' or 'minimal'") + * else: + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { + * 'rts': rts, +*/ + } + + /* "cssm.pyx":5009 + * } + * } + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}} + * else: +*/ + __pyx_t_11 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_11 < 0))) __PYX_ERR(0, 5009, __pyx_L1_error) + if (likely(__pyx_t_11)) { + + /* "cssm.pyx":5010 + * } + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}} # <<<<<<<<<<<<<< + * else: + * raise ValueError("return_option must be 'full' or 'minimal'") +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_2 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 5010, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 5010, __pyx_L1_error) + __pyx_t_1 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_exgauss) < (0)) __PYX_ERR(0, 5010, __pyx_L1_error) + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_3) < (0)) __PYX_ERR(0, 5010, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_3) < (0)) __PYX_ERR(0, 5010, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + __pyx_t_3 = PyList_New(2); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 5010, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_3); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 5010, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_3, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 5010, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_1, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_3) < (0)) __PYX_ERR(0, 5010, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0; + if (PyDict_SetItem(__pyx_t_2, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_1) < (0)) __PYX_ERR(0, 5010, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_r = __pyx_t_2; + __pyx_t_2 = 0; + goto __pyx_L0; + + /* "cssm.pyx":5009 + * } + * } + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}} + * else: +*/ + } + + /* "cssm.pyx":5012 + * return {'rts': rts, 'choices': choices, 'metadata': {'simulator': 'exgauss', 'n_samples': n_samples, 'n_trials': n_trials, 'possible_choices': [-1, 1]}} + * else: + * raise ValueError("return_option must be 'full' or 'minimal'") # <<<<<<<<<<<<<< + * # ----------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_1 = NULL; + __pyx_t_5 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_full_or_mi}; + __pyx_t_2 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_5, (2-__pyx_t_5) | (__pyx_t_5*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5012, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_2); + } + __Pyx_Raise(__pyx_t_2, 0, 0, 0); + __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0; + __PYX_ERR(0, 5012, __pyx_L1_error) + } + } + + /* "cssm.pyx":4880 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def exgauss(np.ndarray[float, ndim = 2] mu, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] sigma, + * np.ndarray[float, ndim = 2] tau, +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_XDECREF(__pyx_t_2); + __Pyx_XDECREF(__pyx_t_3); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_12); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mu.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_p.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sigma.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_tau.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.exgauss", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_mu.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_p.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_sigma.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_tau.rcbuffer->pybuffer); + __pyx_L2:; + __Pyx_XDECREF(__pyx_v_rng); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __Pyx_XDECREF(__pyx_v_rt_candidates); + __Pyx_XDECREF(__pyx_v_mu_val); + __Pyx_XDECREF(__pyx_v_sigma_val); + __Pyx_XDECREF(__pyx_v_tau_val); + __Pyx_XDECREF(__pyx_v_norm_sample); + __Pyx_XDECREF(__pyx_v_exp_sample); + __Pyx_XDECREF(__pyx_v_rt_val); + __Pyx_XDECREF(__pyx_v_choice_idx); + __Pyx_XDECREF(__pyx_v_random_val); + __Pyx_XDECREF((PyObject *)__pyx_v_mu); + __Pyx_XDECREF((PyObject *)__pyx_v_sigma); + __Pyx_XDECREF((PyObject *)__pyx_v_tau); + __Pyx_XDECREF((PyObject *)__pyx_v_p); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +/* "cssm.pyx":5022 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def shifted_wald(np.ndarray[float, ndim = 2] v, # drift rate # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # boundary separation + * np.ndarray[float, ndim = 2] t, # nondecision time +*/ + +/* Python wrapper */ +static PyObject *__pyx_pw_4cssm_47shifted_wald(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +); /*proto*/ +PyDoc_STRVAR(__pyx_doc_4cssm_46shifted_wald, " Fit reaction times and choices from a shifted Wald distribution \n \n Args: \n v (np.ndarray[float, ndim = 1]): drift rate\n a (np.ndarray[float, ndim = 1]): boundary separation\n t (np.ndarray[float, ndim = 1]): non-decision time\n p (np.ndarray[float, ndim = 1]): probability of choice 1\n s (np.ndarray[float, ndim = 1]): noise standard deviation\n delta_t (float, optional): time step for simulation. Defaults to 0.001.\n max_t (float, optional): maximum time for simulation. Defaults to 20.\n n_samples (int, optional): number of samples per trial. Defaults to 20000.\n n_trials (int, optional): number of trials to simulate. Defaults to 1.\n random_state (int, optional): random seed. Defaults to None.\n return_option (str, optional): 'full' or 'minimal' return data. Defaults to 'full'.\n smooth_unif (bool, optional): whether to use smooth uniform distribution for small time increments. Defaults to False.\n \n Returns: \n dict: simulated reaction times, choices, and metadata\n "); +static PyMethodDef __pyx_mdef_4cssm_47shifted_wald = {"shifted_wald", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_4cssm_47shifted_wald, __Pyx_METH_FASTCALL|METH_KEYWORDS, __pyx_doc_4cssm_46shifted_wald}; +static PyObject *__pyx_pw_4cssm_47shifted_wald(PyObject *__pyx_self, +#if CYTHON_METH_FASTCALL +PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds +#else +PyObject *__pyx_args, PyObject *__pyx_kwds +#endif +) { + PyArrayObject *__pyx_v_v = 0; + PyArrayObject *__pyx_v_a = 0; + PyArrayObject *__pyx_v_t = 0; + PyArrayObject *__pyx_v_p = 0; + PyArrayObject *__pyx_v_s = 0; + float __pyx_v_delta_t; + float __pyx_v_max_t; + int __pyx_v_n_samples; + int __pyx_v_n_trials; + PyObject *__pyx_v_random_state = 0; + PyObject *__pyx_v_return_option = 0; + PyObject *__pyx_v_smooth_unif = 0; + PyObject *__pyx_v_race = 0; + CYTHON_UNUSED PyObject *__pyx_v_kwargs = 0; + #if !CYTHON_METH_FASTCALL + CYTHON_UNUSED Py_ssize_t __pyx_nargs; + #endif + CYTHON_UNUSED PyObject *const *__pyx_kwvalues; + PyObject* values[13] = {0,0,0,0,0,0,0,0,0,0,0,0,0}; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + PyObject *__pyx_r = 0; + __Pyx_RefNannyDeclarations + __Pyx_RefNannySetupContext("shifted_wald (wrapper)", 0); + #if !CYTHON_METH_FASTCALL + #if CYTHON_ASSUME_SAFE_SIZE + __pyx_nargs = PyTuple_GET_SIZE(__pyx_args); + #else + __pyx_nargs = PyTuple_Size(__pyx_args); if (unlikely(__pyx_nargs < 0)) return NULL; + #endif + #endif + __pyx_kwvalues = __Pyx_KwValues_FASTCALL(__pyx_args, __pyx_nargs); + { + PyObject ** const __pyx_pyargnames[] = {&__pyx_mstate_global->__pyx_n_u_v,&__pyx_mstate_global->__pyx_n_u_a,&__pyx_mstate_global->__pyx_n_u_t,&__pyx_mstate_global->__pyx_n_u_p,&__pyx_mstate_global->__pyx_n_u_s,&__pyx_mstate_global->__pyx_n_u_delta_t,&__pyx_mstate_global->__pyx_n_u_max_t,&__pyx_mstate_global->__pyx_n_u_n_samples,&__pyx_mstate_global->__pyx_n_u_n_trials,&__pyx_mstate_global->__pyx_n_u_random_state,&__pyx_mstate_global->__pyx_n_u_return_option,&__pyx_mstate_global->__pyx_n_u_smooth_unif,&__pyx_mstate_global->__pyx_n_u_race,0}; + const Py_ssize_t __pyx_kwds_len = (__pyx_kwds) ? __Pyx_NumKwargs_FASTCALL(__pyx_kwds) : 0; + if (unlikely(__pyx_kwds_len) < 0) __PYX_ERR(0, 5022, __pyx_L3_error) + if (__pyx_kwds_len > 0) { + switch (__pyx_nargs) { + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 4: + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 3: + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 2: + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 1: + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 0: break; + default: goto __pyx_L5_argtuple_error; + } + const Py_ssize_t kwd_pos_args = __pyx_nargs; + if (__Pyx_ParseKeywords(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, __pyx_v_kwargs, values, kwd_pos_args, __pyx_kwds_len, "shifted_wald", 1) < (0)) __PYX_ERR(0, 5022, __pyx_L3_error) + + /* "cssm.pyx":5031 + * int n_samples = 20000, + * int n_trials = 1, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[9]) values[9] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + + /* "cssm.pyx":5033 + * random_state = None, + * return_option = 'full', + * smooth_unif = False, # <<<<<<<<<<<<<< + * race = False, + * **kwargs): +*/ + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + + /* "cssm.pyx":5034 + * return_option = 'full', + * smooth_unif = False, + * race = False, # <<<<<<<<<<<<<< + * **kwargs): + * """ Fit reaction times and choices from a shifted Wald distribution +*/ + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + for (Py_ssize_t i = __pyx_nargs; i < 5; i++) { + if (unlikely(!values[i])) { __Pyx_RaiseArgtupleInvalid("shifted_wald", 0, 5, 13, i); __PYX_ERR(0, 5022, __pyx_L3_error) } + } + } else { + switch (__pyx_nargs) { + case 13: + values[12] = __Pyx_ArgRef_FASTCALL(__pyx_args, 12); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[12])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 12: + values[11] = __Pyx_ArgRef_FASTCALL(__pyx_args, 11); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[11])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 11: + values[10] = __Pyx_ArgRef_FASTCALL(__pyx_args, 10); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[10])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 10: + values[9] = __Pyx_ArgRef_FASTCALL(__pyx_args, 9); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[9])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 9: + values[8] = __Pyx_ArgRef_FASTCALL(__pyx_args, 8); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[8])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 8: + values[7] = __Pyx_ArgRef_FASTCALL(__pyx_args, 7); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[7])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 7: + values[6] = __Pyx_ArgRef_FASTCALL(__pyx_args, 6); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[6])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 6: + values[5] = __Pyx_ArgRef_FASTCALL(__pyx_args, 5); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[5])) __PYX_ERR(0, 5022, __pyx_L3_error) + CYTHON_FALLTHROUGH; + case 5: + values[4] = __Pyx_ArgRef_FASTCALL(__pyx_args, 4); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[4])) __PYX_ERR(0, 5022, __pyx_L3_error) + values[3] = __Pyx_ArgRef_FASTCALL(__pyx_args, 3); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[3])) __PYX_ERR(0, 5022, __pyx_L3_error) + values[2] = __Pyx_ArgRef_FASTCALL(__pyx_args, 2); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[2])) __PYX_ERR(0, 5022, __pyx_L3_error) + values[1] = __Pyx_ArgRef_FASTCALL(__pyx_args, 1); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[1])) __PYX_ERR(0, 5022, __pyx_L3_error) + values[0] = __Pyx_ArgRef_FASTCALL(__pyx_args, 0); + if (!CYTHON_ASSUME_SAFE_MACROS && unlikely(!values[0])) __PYX_ERR(0, 5022, __pyx_L3_error) + break; + default: goto __pyx_L5_argtuple_error; + } + + /* "cssm.pyx":5031 + * int n_samples = 20000, + * int n_trials = 1, + * random_state = None, # <<<<<<<<<<<<<< + * return_option = 'full', + * smooth_unif = False, +*/ + if (!values[9]) values[9] = __Pyx_NewRef(((PyObject *)Py_None)); + if (!values[10]) values[10] = __Pyx_NewRef(((PyObject *)((PyObject*)__pyx_mstate_global->__pyx_n_u_full))); + if (!values[11]) values[11] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + if (!values[12]) values[12] = __Pyx_NewRef(((PyObject *)((PyObject*)Py_False))); + } + __pyx_v_v = ((PyArrayObject *)values[0]); + __pyx_v_a = ((PyArrayObject *)values[1]); + __pyx_v_t = ((PyArrayObject *)values[2]); + __pyx_v_p = ((PyArrayObject *)values[3]); + __pyx_v_s = ((PyArrayObject *)values[4]); + if (values[5]) { + __pyx_v_delta_t = __Pyx_PyFloat_AsFloat(values[5]); if (unlikely((__pyx_v_delta_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 5027, __pyx_L3_error) + } else { + __pyx_v_delta_t = ((float)((double)0.001)); + } + if (values[6]) { + __pyx_v_max_t = __Pyx_PyFloat_AsFloat(values[6]); if (unlikely((__pyx_v_max_t == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 5028, __pyx_L3_error) + } else { + __pyx_v_max_t = ((float)((float)20.0)); + } + if (values[7]) { + __pyx_v_n_samples = __Pyx_PyLong_As_int(values[7]); if (unlikely((__pyx_v_n_samples == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 5029, __pyx_L3_error) + } else { + __pyx_v_n_samples = ((int)((int)0x4E20)); + } + if (values[8]) { + __pyx_v_n_trials = __Pyx_PyLong_As_int(values[8]); if (unlikely((__pyx_v_n_trials == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 5030, __pyx_L3_error) + } else { + __pyx_v_n_trials = ((int)((int)1)); + } + __pyx_v_random_state = values[9]; + __pyx_v_return_option = values[10]; + __pyx_v_smooth_unif = values[11]; + __pyx_v_race = values[12]; + } + goto __pyx_L6_skip; + __pyx_L5_argtuple_error:; + __Pyx_RaiseArgtupleInvalid("shifted_wald", 0, 5, 13, __pyx_nargs); __PYX_ERR(0, 5022, __pyx_L3_error) + __pyx_L6_skip:; + goto __pyx_L4_argument_unpacking_done; + __pyx_L3_error:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __Pyx_XDECREF(__pyx_v_kwargs); __pyx_v_kwargs = 0; + __Pyx_AddTraceback("cssm.shifted_wald", __pyx_clineno, __pyx_lineno, __pyx_filename); + __Pyx_RefNannyFinishContext(); + return NULL; + __pyx_L4_argument_unpacking_done:; + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_v), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "v", 0))) __PYX_ERR(0, 5022, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_a), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "a", 0))) __PYX_ERR(0, 5023, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_t), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "t", 0))) __PYX_ERR(0, 5024, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_p), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "p", 0))) __PYX_ERR(0, 5025, __pyx_L1_error) + if (unlikely(!__Pyx_ArgTypeTest(((PyObject *)__pyx_v_s), __pyx_mstate_global->__pyx_ptype_5numpy_ndarray, 1, "s", 0))) __PYX_ERR(0, 5026, __pyx_L1_error) + __pyx_r = __pyx_pf_4cssm_46shifted_wald(__pyx_self, __pyx_v_v, __pyx_v_a, __pyx_v_t, __pyx_v_p, __pyx_v_s, __pyx_v_delta_t, __pyx_v_max_t, __pyx_v_n_samples, __pyx_v_n_trials, __pyx_v_random_state, __pyx_v_return_option, __pyx_v_smooth_unif, __pyx_v_race, __pyx_v_kwargs); + + /* "cssm.pyx":5022 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def shifted_wald(np.ndarray[float, ndim = 2] v, # drift rate # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # boundary separation + * np.ndarray[float, ndim = 2] t, # nondecision time +*/ + + /* function exit code */ + goto __pyx_L0; + __pyx_L1_error:; + __pyx_r = NULL; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + goto __pyx_L7_cleaned_up; + __pyx_L0:; + for (Py_ssize_t __pyx_temp=0; __pyx_temp < (Py_ssize_t)(sizeof(values)/sizeof(values[0])); ++__pyx_temp) { + Py_XDECREF(values[__pyx_temp]); + } + __pyx_L7_cleaned_up:; + __Pyx_XDECREF(__pyx_v_kwargs); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} + +static PyObject *__pyx_pf_4cssm_46shifted_wald(CYTHON_UNUSED PyObject *__pyx_self, PyArrayObject *__pyx_v_v, PyArrayObject *__pyx_v_a, PyArrayObject *__pyx_v_t, PyArrayObject *__pyx_v_p, PyArrayObject *__pyx_v_s, float __pyx_v_delta_t, float __pyx_v_max_t, int __pyx_v_n_samples, int __pyx_v_n_trials, PyObject *__pyx_v_random_state, PyObject *__pyx_v_return_option, PyObject *__pyx_v_smooth_unif, PyObject *__pyx_v_race, CYTHON_UNUSED PyObject *__pyx_v_kwargs) { + __Pyx_memviewslice __pyx_v_v_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_a_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_t_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_p_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_s_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_traj = NULL; + __Pyx_memviewslice __pyx_v_traj_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_v_rts = NULL; + PyObject *__pyx_v_choices = NULL; + __Pyx_memviewslice __pyx_v_rts_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_v_choices_view = { 0, 0, { 0 }, { 0 }, { 0 } }; + float __pyx_v_delta_t_sqrt; + float __pyx_v_y; + float __pyx_v_t_particle; + float __pyx_v_smooth_u; + float __pyx_v_sqrt_st; + Py_ssize_t __pyx_v_n; + Py_ssize_t __pyx_v_ix; + Py_ssize_t __pyx_v_k; + int __pyx_v_m; + int __pyx_v_num_draws; + __Pyx_memviewslice __pyx_v_gaussian_values = { 0, 0, { 0 }, { 0 }, { 0 } }; + npy_intp __pyx_v_n_choices; + PyObject *__pyx_v_rt_candidates = NULL; + npy_intp __pyx_v_c; + PyObject *__pyx_v_choices_idx = NULL; + double __pyx_v_random_val; + long __pyx_v_choice_idx; + __Pyx_LocalBuf_ND __pyx_pybuffernd_a; + __Pyx_Buffer __pyx_pybuffer_a; + __Pyx_LocalBuf_ND __pyx_pybuffernd_p; + __Pyx_Buffer __pyx_pybuffer_p; + __Pyx_LocalBuf_ND __pyx_pybuffernd_s; + __Pyx_Buffer __pyx_pybuffer_s; + __Pyx_LocalBuf_ND __pyx_pybuffernd_t; + __Pyx_Buffer __pyx_pybuffer_t; + __Pyx_LocalBuf_ND __pyx_pybuffernd_v; + __Pyx_Buffer __pyx_pybuffer_v; + PyObject *__pyx_r = NULL; + __Pyx_RefNannyDeclarations + PyObject *__pyx_t_1 = NULL; + __Pyx_memviewslice __pyx_t_2 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_3 = { 0, 0, { 0 }, { 0 }, { 0 } }; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + PyObject *__pyx_t_6 = NULL; + PyObject *__pyx_t_7 = NULL; + size_t __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + __Pyx_memviewslice __pyx_t_10 = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_memviewslice __pyx_t_11 = { 0, 0, { 0 }, { 0 }, { 0 } }; + int __pyx_t_12; + int __pyx_t_13; + Py_ssize_t __pyx_t_14; + Py_ssize_t __pyx_t_15; + int __pyx_t_16; + int __pyx_t_17; + Py_ssize_t __pyx_t_18; + int __pyx_t_19; + npy_intp __pyx_t_20; + npy_intp __pyx_t_21; + npy_intp __pyx_t_22; + Py_ssize_t __pyx_t_23; + int __pyx_t_24; + Py_ssize_t __pyx_t_25; + float __pyx_t_26; + int __pyx_t_27; + Py_ssize_t __pyx_t_28; + Py_ssize_t __pyx_t_29; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("shifted_wald", 0); + __pyx_pybuffer_v.pybuffer.buf = NULL; + __pyx_pybuffer_v.refcount = 0; + __pyx_pybuffernd_v.data = NULL; + __pyx_pybuffernd_v.rcbuffer = &__pyx_pybuffer_v; + __pyx_pybuffer_a.pybuffer.buf = NULL; + __pyx_pybuffer_a.refcount = 0; + __pyx_pybuffernd_a.data = NULL; + __pyx_pybuffernd_a.rcbuffer = &__pyx_pybuffer_a; + __pyx_pybuffer_t.pybuffer.buf = NULL; + __pyx_pybuffer_t.refcount = 0; + __pyx_pybuffernd_t.data = NULL; + __pyx_pybuffernd_t.rcbuffer = &__pyx_pybuffer_t; + __pyx_pybuffer_p.pybuffer.buf = NULL; + __pyx_pybuffer_p.refcount = 0; + __pyx_pybuffernd_p.data = NULL; + __pyx_pybuffernd_p.rcbuffer = &__pyx_pybuffer_p; + __pyx_pybuffer_s.pybuffer.buf = NULL; + __pyx_pybuffer_s.refcount = 0; + __pyx_pybuffernd_s.data = NULL; + __pyx_pybuffernd_s.rcbuffer = &__pyx_pybuffer_s; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_v.rcbuffer->pybuffer, (PyObject*)__pyx_v_v, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 5022, __pyx_L1_error) + } + __pyx_pybuffernd_v.diminfo[0].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_v.diminfo[0].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_v.diminfo[1].strides = __pyx_pybuffernd_v.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_v.diminfo[1].shape = __pyx_pybuffernd_v.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_a.rcbuffer->pybuffer, (PyObject*)__pyx_v_a, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 5022, __pyx_L1_error) + } + __pyx_pybuffernd_a.diminfo[0].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_a.diminfo[0].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_a.diminfo[1].strides = __pyx_pybuffernd_a.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_a.diminfo[1].shape = __pyx_pybuffernd_a.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_t.rcbuffer->pybuffer, (PyObject*)__pyx_v_t, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 2, 0, __pyx_stack) == -1)) __PYX_ERR(0, 5022, __pyx_L1_error) + } + __pyx_pybuffernd_t.diminfo[0].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_t.diminfo[0].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[0]; __pyx_pybuffernd_t.diminfo[1].strides = __pyx_pybuffernd_t.rcbuffer->pybuffer.strides[1]; __pyx_pybuffernd_t.diminfo[1].shape = __pyx_pybuffernd_t.rcbuffer->pybuffer.shape[1]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_p.rcbuffer->pybuffer, (PyObject*)__pyx_v_p, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 5022, __pyx_L1_error) + } + __pyx_pybuffernd_p.diminfo[0].strides = __pyx_pybuffernd_p.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_p.diminfo[0].shape = __pyx_pybuffernd_p.rcbuffer->pybuffer.shape[0]; + { + __Pyx_BufFmt_StackElem __pyx_stack[1]; + if (unlikely(__Pyx_GetBufferAndValidate(&__pyx_pybuffernd_s.rcbuffer->pybuffer, (PyObject*)__pyx_v_s, &__Pyx_TypeInfo_float, PyBUF_FORMAT| PyBUF_STRIDES, 1, 0, __pyx_stack) == -1)) __PYX_ERR(0, 5022, __pyx_L1_error) + } + __pyx_pybuffernd_s.diminfo[0].strides = __pyx_pybuffernd_s.rcbuffer->pybuffer.strides[0]; __pyx_pybuffernd_s.diminfo[0].shape = __pyx_pybuffernd_s.rcbuffer->pybuffer.shape[0]; + + /* "cssm.pyx":5056 + * """ + * + * set_seed(random_state) # <<<<<<<<<<<<<< + * + * cdef float[:, :] v_view = v +*/ + __pyx_t_1 = __pyx_f_4cssm_set_seed(__pyx_v_random_state); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5056, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + + /* "cssm.pyx":5058 + * set_seed(random_state) + * + * cdef float[:, :] v_view = v # <<<<<<<<<<<<<< + * cdef float[:, :] a_view = a + * cdef float[:, :] t_view = t +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_v), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 5058, __pyx_L1_error) + __pyx_v_v_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":5059 + * + * cdef float[:, :] v_view = v + * cdef float[:, :] a_view = a # <<<<<<<<<<<<<< + * cdef float[:, :] t_view = t + * cdef float[:] p_view = p +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_a), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 5059, __pyx_L1_error) + __pyx_v_a_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":5060 + * cdef float[:, :] v_view = v + * cdef float[:, :] a_view = a + * cdef float[:, :] t_view = t # <<<<<<<<<<<<<< + * cdef float[:] p_view = p + * cdef float[:] s_view = s +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(((PyObject *)__pyx_v_t), PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 5060, __pyx_L1_error) + __pyx_v_t_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":5061 + * cdef float[:, :] a_view = a + * cdef float[:, :] t_view = t + * cdef float[:] p_view = p # <<<<<<<<<<<<<< + * cdef float[:] s_view = s + * +*/ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_p), PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 5061, __pyx_L1_error) + __pyx_v_p_view = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":5062 + * cdef float[:, :] t_view = t + * cdef float[:] p_view = p + * cdef float[:] s_view = s # <<<<<<<<<<<<<< + * + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype=DTYPE) +*/ + __pyx_t_3 = __Pyx_PyObject_to_MemoryviewSlice_ds_float(((PyObject *)__pyx_v_s), PyBUF_WRITABLE); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 5062, __pyx_L1_error) + __pyx_v_s_view = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":5064 + * cdef float[:] s_view = s + * + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype=DTYPE) # <<<<<<<<<<<<<< + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj +*/ + __pyx_t_4 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_7 = __Pyx_PyLong_AddObjC(__pyx_t_5, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = PyTuple_New(2); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_GIVEREF(__pyx_t_7); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 0, __pyx_t_7) != (0)) __PYX_ERR(0, 5064, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_5, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 5064, __pyx_L1_error); + __pyx_t_7 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_4 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_4); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_4); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_4, __pyx_t_5}; + __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_7, __pyx_t_9, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 5064, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9); + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5064, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_traj = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":5065 + * + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype=DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + if (unlikely((PyObject_SetItem(__pyx_v_traj, __pyx_mstate_global->__pyx_tuple[2], __pyx_mstate_global->__pyx_int_neg_999) < 0))) __PYX_ERR(0, 5065, __pyx_L1_error) + + /* "cssm.pyx":5066 + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype=DTYPE) + * traj[:, :] = -999 + * cdef float[:, :] traj_view = traj # <<<<<<<<<<<<<< + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) +*/ + __pyx_t_2 = __Pyx_PyObject_to_MemoryviewSlice_dsds_float(__pyx_v_traj, PyBUF_WRITABLE); if (unlikely(!__pyx_t_2.memview)) __PYX_ERR(0, 5066, __pyx_L1_error) + __pyx_v_traj_view = __pyx_t_2; + __pyx_t_2.memview = NULL; + __pyx_t_2.data = NULL; + + /* "cssm.pyx":5068 + * cdef float[:, :] traj_view = traj + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) # <<<<<<<<<<<<<< + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef float[:, :, :] rts_view = rts +*/ + __pyx_t_6 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_7 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_5 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_4 = PyTuple_New(3); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 0, __pyx_t_9) != (0)) __PYX_ERR(0, 5068, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_5); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 1, __pyx_t_5) != (0)) __PYX_ERR(0, 5068, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_4, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 5068, __pyx_L1_error); + __pyx_t_9 = 0; + __pyx_t_5 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_7))) { + __pyx_t_6 = PyMethod_GET_SELF(__pyx_t_7); + assert(__pyx_t_6); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_7); + __Pyx_INCREF(__pyx_t_6); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_7, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_6, __pyx_t_4}; + __pyx_t_9 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_5, __pyx_t_9, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 5068, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_7, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_9); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5068, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_rts = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":5069 + * + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) # <<<<<<<<<<<<<< + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices +*/ + __pyx_t_7 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_9, __pyx_mstate_global->__pyx_n_u_zeros); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __pyx_t_4 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_GIVEREF(__pyx_t_9); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_t_9) != (0)) __PYX_ERR(0, 5069, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_t_4); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_t_4) != (0)) __PYX_ERR(0, 5069, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 5069, __pyx_L1_error); + __pyx_t_9 = 0; + __pyx_t_4 = 0; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_intc); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_5))) { + __pyx_t_7 = PyMethod_GET_SELF(__pyx_t_5); + assert(__pyx_t_7); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_5); + __Pyx_INCREF(__pyx_t_7); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_5, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_7, __pyx_t_6}; + __pyx_t_4 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_9, __pyx_t_4, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 5069, __pyx_L1_error) + __pyx_t_1 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_5, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_4); + __Pyx_XDECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5069, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + } + __pyx_v_choices = __pyx_t_1; + __pyx_t_1 = 0; + + /* "cssm.pyx":5070 + * rts = np.zeros((n_samples, n_trials, 1), dtype = DTYPE) + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef float[:, :, :] rts_view = rts # <<<<<<<<<<<<<< + * cdef int[:, :, :] choices_view = choices + * +*/ + __pyx_t_10 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(__pyx_v_rts, PyBUF_WRITABLE); if (unlikely(!__pyx_t_10.memview)) __PYX_ERR(0, 5070, __pyx_L1_error) + __pyx_v_rts_view = __pyx_t_10; + __pyx_t_10.memview = NULL; + __pyx_t_10.data = NULL; + + /* "cssm.pyx":5071 + * choices = np.zeros((n_samples, n_trials, 1), dtype = np.intc) + * cdef float[:, :, :] rts_view = rts + * cdef int[:, :, :] choices_view = choices # <<<<<<<<<<<<<< + * + * cdef float delta_t_sqrt = sqrt(delta_t) +*/ + __pyx_t_11 = __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(__pyx_v_choices, PyBUF_WRITABLE); if (unlikely(!__pyx_t_11.memview)) __PYX_ERR(0, 5071, __pyx_L1_error) + __pyx_v_choices_view = __pyx_t_11; + __pyx_t_11.memview = NULL; + __pyx_t_11.data = NULL; + + /* "cssm.pyx":5073 + * cdef int[:, :, :] choices_view = choices + * + * cdef float delta_t_sqrt = sqrt(delta_t) # <<<<<<<<<<<<<< + * cdef float y, t_particle, smooth_u, sqrt_st + * +*/ + __pyx_v_delta_t_sqrt = sqrt(__pyx_v_delta_t); + + /* "cssm.pyx":5077 + * + * cdef Py_ssize_t n, ix, k + * cdef int m = 0 # <<<<<<<<<<<<<< + * cdef int num_draws = int(max_t / delta_t) + 1 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":5078 + * cdef Py_ssize_t n, ix, k + * cdef int m = 0 + * cdef int num_draws = int(max_t / delta_t) + 1 # <<<<<<<<<<<<<< + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * n_choices = v.shape[1] +*/ + __pyx_t_1 = PyLong_FromDouble((__pyx_v_max_t / __pyx_v_delta_t)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 5078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_t_5 = __Pyx_PyLong_AddObjC(__pyx_t_1, __pyx_mstate_global->__pyx_int_1, 1, 0, 0); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5078, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_12 = __Pyx_PyLong_As_int(__pyx_t_5); if (unlikely((__pyx_t_12 == (int)-1) && PyErr_Occurred())) __PYX_ERR(0, 5078, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_v_num_draws = __pyx_t_12; + + /* "cssm.pyx":5079 + * cdef int m = 0 + * cdef int num_draws = int(max_t / delta_t) + 1 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * n_choices = v.shape[1] + * +*/ + __pyx_t_3 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 5079, __pyx_L1_error) + __pyx_v_gaussian_values = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":5080 + * cdef int num_draws = int(max_t / delta_t) + 1 + * cdef float[:] gaussian_values = draw_gaussian(num_draws) + * n_choices = v.shape[1] # <<<<<<<<<<<<<< + * + * for k in range(n_trials): +*/ + __pyx_v_n_choices = (__pyx_f_5numpy_7ndarray_5shape_shape(((PyArrayObject *)__pyx_v_v))[1]); + + /* "cssm.pyx":5082 + * n_choices = v.shape[1] + * + * for k in range(n_trials): # <<<<<<<<<<<<<< + * sqrt_st = delta_t_sqrt * s_view[k] + * +*/ + __pyx_t_12 = __pyx_v_n_trials; + __pyx_t_13 = __pyx_t_12; + for (__pyx_t_14 = 0; __pyx_t_14 < __pyx_t_13; __pyx_t_14+=1) { + __pyx_v_k = __pyx_t_14; + + /* "cssm.pyx":5083 + * + * for k in range(n_trials): + * sqrt_st = delta_t_sqrt * s_view[k] # <<<<<<<<<<<<<< + * + * for n in range(n_samples): +*/ + __pyx_t_15 = __pyx_v_k; + __pyx_v_sqrt_st = (__pyx_v_delta_t_sqrt * (*((float *) ( /* dim=0 */ (__pyx_v_s_view.data + __pyx_t_15 * __pyx_v_s_view.strides[0]) )))); + + /* "cssm.pyx":5085 + * sqrt_st = delta_t_sqrt * s_view[k] + * + * for n in range(n_samples): # <<<<<<<<<<<<<< + * # Random choice depending on p + * if race: +*/ + __pyx_t_16 = __pyx_v_n_samples; + __pyx_t_17 = __pyx_t_16; + for (__pyx_t_18 = 0; __pyx_t_18 < __pyx_t_17; __pyx_t_18+=1) { + __pyx_v_n = __pyx_t_18; + + /* "cssm.pyx":5087 + * for n in range(n_samples): + * # Random choice depending on p + * if race: # <<<<<<<<<<<<<< + * rt_candidates = np.empty(n_choices, dtype=DTYPE) + * for c in range(n_choices): +*/ + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_race); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5087, __pyx_L1_error) + if (__pyx_t_19) { + + /* "cssm.pyx":5088 + * # Random choice depending on p + * if race: + * rt_candidates = np.empty(n_choices, dtype=DTYPE) # <<<<<<<<<<<<<< + * for c in range(n_choices): + * y = 0.0 +*/ + __pyx_t_1 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_9 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_empty); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyLong_From_npy_intp(__pyx_v_n_choices); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_GetModuleGlobalName(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_DTYPE); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_9))) { + __pyx_t_1 = PyMethod_GET_SELF(__pyx_t_9); + assert(__pyx_t_1); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_9); + __Pyx_INCREF(__pyx_t_1); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_9, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2 + ((CYTHON_VECTORCALL) ? 1 : 0)] = {__pyx_t_1, __pyx_t_4}; + __pyx_t_7 = __Pyx_MakeVectorcallBuilderKwds(1); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + if (__Pyx_VectorcallBuilder_AddArg(__pyx_mstate_global->__pyx_n_u_dtype, __pyx_t_6, __pyx_t_7, __pyx_callargs+2, 0) < (0)) __PYX_ERR(0, 5088, __pyx_L1_error) + __pyx_t_5 = __Pyx_Object_Vectorcall_CallFromBuilder((PyObject*)__pyx_t_9, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET), __pyx_t_7); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5088, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_rt_candidates, __pyx_t_5); + __pyx_t_5 = 0; + + /* "cssm.pyx":5089 + * if race: + * rt_candidates = np.empty(n_choices, dtype=DTYPE) + * for c in range(n_choices): # <<<<<<<<<<<<<< + * y = 0.0 + * t_particle = 0.0 +*/ + __pyx_t_20 = __pyx_v_n_choices; + __pyx_t_21 = __pyx_t_20; + for (__pyx_t_22 = 0; __pyx_t_22 < __pyx_t_21; __pyx_t_22+=1) { + __pyx_v_c = __pyx_t_22; + + /* "cssm.pyx":5090 + * rt_candidates = np.empty(n_choices, dtype=DTYPE) + * for c in range(n_choices): + * y = 0.0 # <<<<<<<<<<<<<< + * t_particle = 0.0 + * ix = 0 +*/ + __pyx_v_y = 0.0; + + /* "cssm.pyx":5091 + * for c in range(n_choices): + * y = 0.0 + * t_particle = 0.0 # <<<<<<<<<<<<<< + * ix = 0 + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":5092 + * y = 0.0 + * t_particle = 0.0 + * ix = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":5094 + * ix = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_19 = (__pyx_v_n == 0); + if (__pyx_t_19) { + + /* "cssm.pyx":5095 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * while (y < a_view[k, c]) and (t_particle <= max_t): +*/ + __pyx_t_19 = (__pyx_v_k == 0); + if (__pyx_t_19) { + + /* "cssm.pyx":5096 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * while (y < a_view[k, c]) and (t_particle <= max_t): + * y += (v_view[k, c] * delta_t) + (sqrt_st * gaussian_values[m]) +*/ + __pyx_t_15 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_15 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":5095 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * while (y < a_view[k, c]) and (t_particle <= max_t): +*/ + } + + /* "cssm.pyx":5094 + * ix = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":5097 + * if k == 0: + * traj_view[0, 0] = y + * while (y < a_view[k, c]) and (t_particle <= max_t): # <<<<<<<<<<<<<< + * y += (v_view[k, c] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_23 = __pyx_v_k; + __pyx_t_15 = __pyx_v_c; + __pyx_t_24 = (__pyx_v_y < (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_23 * __pyx_v_a_view.strides[0]) ) + __pyx_t_15 * __pyx_v_a_view.strides[1]) )))); + if (__pyx_t_24) { + } else { + __pyx_t_19 = __pyx_t_24; + goto __pyx_L14_bool_binop_done; + } + __pyx_t_24 = (__pyx_v_t_particle <= __pyx_v_max_t); + __pyx_t_19 = __pyx_t_24; + __pyx_L14_bool_binop_done:; + if (!__pyx_t_19) break; + + /* "cssm.pyx":5098 + * traj_view[0, 0] = y + * while (y < a_view[k, c]) and (t_particle <= max_t): + * y += (v_view[k, c] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_15 = __pyx_v_k; + __pyx_t_23 = __pyx_v_c; + __pyx_t_25 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_15 * __pyx_v_v_view.strides[0]) ) + __pyx_t_23 * __pyx_v_v_view.strides[1]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_25 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":5099 + * while (y < a_view[k, c]) and (t_particle <= max_t): + * y += (v_view[k, c] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":5100 + * y += (v_view[k, c] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":5101 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":5102 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_19 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_19) { + + /* "cssm.pyx":5103 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_3 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 5103, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":5104 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":5102 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":5106 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_19 = (__pyx_v_n == 0); + if (__pyx_t_19) { + + /* "cssm.pyx":5107 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + __pyx_t_19 = (__pyx_v_k == 0); + if (__pyx_t_19) { + + /* "cssm.pyx":5108 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_t_25 = __pyx_v_ix; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_25 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":5107 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + } + + /* "cssm.pyx":5106 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + + /* "cssm.pyx":5110 + * traj_view[ix, 0] = y + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5110, __pyx_L1_error) + if (__pyx_t_19) { + + /* "cssm.pyx":5111 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: +*/ + __pyx_t_19 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_19) { + + /* "cssm.pyx":5112 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < max_t: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 5112, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":5111 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: +*/ + goto __pyx_L20; + } + + /* "cssm.pyx":5113 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_19 = (__pyx_v_t_particle < __pyx_v_max_t); + if (__pyx_t_19) { + + /* "cssm.pyx":5114 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 5114, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":5113 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L20; + } + + /* "cssm.pyx":5116 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L20:; + + /* "cssm.pyx":5110 + * traj_view[ix, 0] = y + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L19; + } + + /* "cssm.pyx":5118 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * rt_candidates[c] = t_particle + t_view[k, c] + smooth_u + * +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L19:; + } + + /* "cssm.pyx":5119 + * else: + * smooth_u = 0.0 + * rt_candidates[c] = t_particle + t_view[k, c] + smooth_u # <<<<<<<<<<<<<< + * + * choices_idx = np.argmin(rt_candidates) +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_25 = __pyx_v_c; + __pyx_t_5 = PyFloat_FromDouble(((__pyx_v_t_particle + (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) ) + __pyx_t_25 * __pyx_v_t_view.strides[1]) )))) + __pyx_v_smooth_u)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5119, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (unlikely((__Pyx_SetItemInt(__pyx_v_rt_candidates, __pyx_v_c, __pyx_t_5, npy_intp, 1, __Pyx_PyLong_From_npy_intp, 0, 0, 0, 1, __Pyx_ReferenceSharing_OwnStrongReference) < 0))) __PYX_ERR(0, 5119, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + } + + /* "cssm.pyx":5121 + * rt_candidates[c] = t_particle + t_view[k, c] + smooth_u + * + * choices_idx = np.argmin(rt_candidates) # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 1 if choices_idx == 0 else -1 + * rts_view[n, k, 0] = rt_candidates[choices_idx] +*/ + __pyx_t_9 = NULL; + __Pyx_GetModuleGlobalName(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 5121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_7); + __pyx_t_6 = __Pyx_PyObject_GetAttrStr(__pyx_t_7, __pyx_mstate_global->__pyx_n_u_argmin); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + __Pyx_DECREF(__pyx_t_7); __pyx_t_7 = 0; + __pyx_t_8 = 1; + #if CYTHON_UNPACK_METHODS + if (unlikely(PyMethod_Check(__pyx_t_6))) { + __pyx_t_9 = PyMethod_GET_SELF(__pyx_t_6); + assert(__pyx_t_9); + PyObject* __pyx__function = PyMethod_GET_FUNCTION(__pyx_t_6); + __Pyx_INCREF(__pyx_t_9); + __Pyx_INCREF(__pyx__function); + __Pyx_DECREF_SET(__pyx_t_6, __pyx__function); + __pyx_t_8 = 0; + } + #endif + { + PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_rt_candidates}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)__pyx_t_6, __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5121, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_XDECREF_SET(__pyx_v_choices_idx, __pyx_t_5); + __pyx_t_5 = 0; + + /* "cssm.pyx":5122 + * + * choices_idx = np.argmin(rt_candidates) + * choices_view[n, k, 0] = 1 if choices_idx == 0 else -1 # <<<<<<<<<<<<<< + * rts_view[n, k, 0] = rt_candidates[choices_idx] + * +*/ + __pyx_t_19 = (__Pyx_PyLong_BoolEqObjC(__pyx_v_choices_idx, __pyx_mstate_global->__pyx_int_0, 0, 0)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5122, __pyx_L1_error) + if (__pyx_t_19) { + __pyx_t_27 = 1; + } else { + __pyx_t_27 = -1; + } + __pyx_t_25 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_15 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_25 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_15 * __pyx_v_choices_view.strides[2]) )) = __pyx_t_27; + + /* "cssm.pyx":5123 + * choices_idx = np.argmin(rt_candidates) + * choices_view[n, k, 0] = 1 if choices_idx == 0 else -1 + * rts_view[n, k, 0] = rt_candidates[choices_idx] # <<<<<<<<<<<<<< + * + * else: +*/ + __pyx_t_5 = __Pyx_PyObject_GetItem(__pyx_v_rt_candidates, __pyx_v_choices_idx); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5123, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __pyx_t_26 = __Pyx_PyFloat_AsFloat(__pyx_t_5); if (unlikely((__pyx_t_26 == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 5123, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_15 = __pyx_v_n; + __pyx_t_23 = __pyx_v_k; + __pyx_t_25 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_15 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_23 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_25 * __pyx_v_rts_view.strides[2]) )) = __pyx_t_26; + + /* "cssm.pyx":5087 + * for n in range(n_samples): + * # Random choice depending on p + * if race: # <<<<<<<<<<<<<< + * rt_candidates = np.empty(n_choices, dtype=DTYPE) + * for c in range(n_choices): +*/ + goto __pyx_L7; + } + + /* "cssm.pyx":5126 + * + * else: + * y = 0.0 # <<<<<<<<<<<<<< + * t_particle = 0.0 + * ix = 0 +*/ + /*else*/ { + __pyx_v_y = 0.0; + + /* "cssm.pyx":5127 + * else: + * y = 0.0 + * t_particle = 0.0 # <<<<<<<<<<<<<< + * ix = 0 + * +*/ + __pyx_v_t_particle = 0.0; + + /* "cssm.pyx":5128 + * y = 0.0 + * t_particle = 0.0 + * ix = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_ix = 0; + + /* "cssm.pyx":5130 + * ix = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + __pyx_t_19 = (__pyx_v_n == 0); + if (__pyx_t_19) { + + /* "cssm.pyx":5131 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + __pyx_t_19 = (__pyx_v_k == 0); + if (__pyx_t_19) { + + /* "cssm.pyx":5132 + * if n == 0: + * if k == 0: + * traj_view[0, 0] = y # <<<<<<<<<<<<<< + * + * random_val = rand() / float(RAND_MAX) +*/ + __pyx_t_25 = 0; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_25 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":5131 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[0, 0] = y + * +*/ + } + + /* "cssm.pyx":5130 + * ix = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[0, 0] = y +*/ + } + + /* "cssm.pyx":5134 + * traj_view[0, 0] = y + * + * random_val = rand() / float(RAND_MAX) # <<<<<<<<<<<<<< + * if random_val <= p_view[k]: + * choices_view[n, k, 0] = 1 +*/ + __pyx_v_random_val = (((double)rand()) / ((double)RAND_MAX)); + + /* "cssm.pyx":5135 + * + * random_val = rand() / float(RAND_MAX) + * if random_val <= p_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 1 + * choice_idx = 0 +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_19 = (__pyx_v_random_val <= (*((float *) ( /* dim=0 */ (__pyx_v_p_view.data + __pyx_t_23 * __pyx_v_p_view.strides[0]) )))); + if (__pyx_t_19) { + + /* "cssm.pyx":5136 + * random_val = rand() / float(RAND_MAX) + * if random_val <= p_view[k]: + * choices_view[n, k, 0] = 1 # <<<<<<<<<<<<<< + * choice_idx = 0 + * else: +*/ + __pyx_t_23 = __pyx_v_n; + __pyx_t_25 = __pyx_v_k; + __pyx_t_15 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_23 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_25 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_15 * __pyx_v_choices_view.strides[2]) )) = 1; + + /* "cssm.pyx":5137 + * if random_val <= p_view[k]: + * choices_view[n, k, 0] = 1 + * choice_idx = 0 # <<<<<<<<<<<<<< + * else: + * choices_view[n, k, 0] = -1 +*/ + __pyx_v_choice_idx = 0; + + /* "cssm.pyx":5135 + * + * random_val = rand() / float(RAND_MAX) + * if random_val <= p_view[k]: # <<<<<<<<<<<<<< + * choices_view[n, k, 0] = 1 + * choice_idx = 0 +*/ + goto __pyx_L23; + } + + /* "cssm.pyx":5139 + * choice_idx = 0 + * else: + * choices_view[n, k, 0] = -1 # <<<<<<<<<<<<<< + * choice_idx = 1 + * +*/ + /*else*/ { + __pyx_t_15 = __pyx_v_n; + __pyx_t_25 = __pyx_v_k; + __pyx_t_23 = 0; + *((int *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_choices_view.data + __pyx_t_15 * __pyx_v_choices_view.strides[0]) ) + __pyx_t_25 * __pyx_v_choices_view.strides[1]) ) + __pyx_t_23 * __pyx_v_choices_view.strides[2]) )) = -1; + + /* "cssm.pyx":5140 + * else: + * choices_view[n, k, 0] = -1 + * choice_idx = 1 # <<<<<<<<<<<<<< + * + * # Random walk +*/ + __pyx_v_choice_idx = 1; + } + __pyx_L23:; + + /* "cssm.pyx":5143 + * + * # Random walk + * while (y < a_view[k, choice_idx]) and (t_particle <= max_t): # <<<<<<<<<<<<<< + * y += (v_view[k, choice_idx] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t +*/ + while (1) { + __pyx_t_23 = __pyx_v_k; + __pyx_t_25 = __pyx_v_choice_idx; + __pyx_t_24 = (__pyx_v_y < (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_a_view.data + __pyx_t_23 * __pyx_v_a_view.strides[0]) ) + __pyx_t_25 * __pyx_v_a_view.strides[1]) )))); + if (__pyx_t_24) { + } else { + __pyx_t_19 = __pyx_t_24; + goto __pyx_L26_bool_binop_done; + } + __pyx_t_24 = (__pyx_v_t_particle <= __pyx_v_max_t); + __pyx_t_19 = __pyx_t_24; + __pyx_L26_bool_binop_done:; + if (!__pyx_t_19) break; + + /* "cssm.pyx":5144 + * # Random walk + * while (y < a_view[k, choice_idx]) and (t_particle <= max_t): + * y += (v_view[k, choice_idx] * delta_t) + (sqrt_st * gaussian_values[m]) # <<<<<<<<<<<<<< + * t_particle += delta_t + * ix += 1 +*/ + __pyx_t_25 = __pyx_v_k; + __pyx_t_23 = __pyx_v_choice_idx; + __pyx_t_15 = __pyx_v_m; + __pyx_v_y = (__pyx_v_y + (((*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_v_view.data + __pyx_t_25 * __pyx_v_v_view.strides[0]) ) + __pyx_t_23 * __pyx_v_v_view.strides[1]) ))) * __pyx_v_delta_t) + (__pyx_v_sqrt_st * (*((float *) ( /* dim=0 */ (__pyx_v_gaussian_values.data + __pyx_t_15 * __pyx_v_gaussian_values.strides[0]) )))))); + + /* "cssm.pyx":5145 + * while (y < a_view[k, choice_idx]) and (t_particle <= max_t): + * y += (v_view[k, choice_idx] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t # <<<<<<<<<<<<<< + * ix += 1 + * m += 1 +*/ + __pyx_v_t_particle = (__pyx_v_t_particle + __pyx_v_delta_t); + + /* "cssm.pyx":5146 + * y += (v_view[k, choice_idx] * delta_t) + (sqrt_st * gaussian_values[m]) + * t_particle += delta_t + * ix += 1 # <<<<<<<<<<<<<< + * m += 1 + * if m == num_draws: +*/ + __pyx_v_ix = (__pyx_v_ix + 1); + + /* "cssm.pyx":5147 + * t_particle += delta_t + * ix += 1 + * m += 1 # <<<<<<<<<<<<<< + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) +*/ + __pyx_v_m = (__pyx_v_m + 1); + + /* "cssm.pyx":5148 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + __pyx_t_19 = (__pyx_v_m == __pyx_v_num_draws); + if (__pyx_t_19) { + + /* "cssm.pyx":5149 + * m += 1 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) # <<<<<<<<<<<<<< + * m = 0 + * +*/ + __pyx_t_3 = __pyx_f_4cssm_draw_gaussian(__pyx_v_num_draws); if (unlikely(!__pyx_t_3.memview)) __PYX_ERR(0, 5149, __pyx_L1_error) + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __pyx_v_gaussian_values = __pyx_t_3; + __pyx_t_3.memview = NULL; + __pyx_t_3.data = NULL; + + /* "cssm.pyx":5150 + * if m == num_draws: + * gaussian_values = draw_gaussian(num_draws) + * m = 0 # <<<<<<<<<<<<<< + * + * if n == 0: +*/ + __pyx_v_m = 0; + + /* "cssm.pyx":5148 + * ix += 1 + * m += 1 + * if m == num_draws: # <<<<<<<<<<<<<< + * gaussian_values = draw_gaussian(num_draws) + * m = 0 +*/ + } + + /* "cssm.pyx":5152 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + __pyx_t_19 = (__pyx_v_n == 0); + if (__pyx_t_19) { + + /* "cssm.pyx":5153 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + __pyx_t_19 = (__pyx_v_k == 0); + if (__pyx_t_19) { + + /* "cssm.pyx":5154 + * if n == 0: + * if k == 0: + * traj_view[ix, 0] = y # <<<<<<<<<<<<<< + * + * if smooth_unif: +*/ + __pyx_t_15 = __pyx_v_ix; + __pyx_t_23 = 0; + *((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_traj_view.data + __pyx_t_15 * __pyx_v_traj_view.strides[0]) ) + __pyx_t_23 * __pyx_v_traj_view.strides[1]) )) = __pyx_v_y; + + /* "cssm.pyx":5153 + * + * if n == 0: + * if k == 0: # <<<<<<<<<<<<<< + * traj_view[ix, 0] = y + * +*/ + } + + /* "cssm.pyx":5152 + * m = 0 + * + * if n == 0: # <<<<<<<<<<<<<< + * if k == 0: + * traj_view[ix, 0] = y +*/ + } + } + + /* "cssm.pyx":5156 + * traj_view[ix, 0] = y + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_smooth_unif); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5156, __pyx_L1_error) + if (__pyx_t_19) { + + /* "cssm.pyx":5157 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: +*/ + __pyx_t_19 = (__pyx_v_t_particle == 0.0); + if (__pyx_t_19) { + + /* "cssm.pyx":5158 + * if smooth_unif: + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t # <<<<<<<<<<<<<< + * elif t_particle < max_t: + * smooth_u = (0.5 - random_uniform()) * delta_t +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 5158, __pyx_L1_error) + __pyx_v_smooth_u = ((__pyx_t_26 * 0.5) * __pyx_v_delta_t); + + /* "cssm.pyx":5157 + * + * if smooth_unif: + * if t_particle == 0.0: # <<<<<<<<<<<<<< + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: +*/ + goto __pyx_L32; + } + + /* "cssm.pyx":5159 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + __pyx_t_19 = (__pyx_v_t_particle < __pyx_v_max_t); + if (__pyx_t_19) { + + /* "cssm.pyx":5160 + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: + * smooth_u = (0.5 - random_uniform()) * delta_t # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + __pyx_t_26 = __pyx_f_4cssm_random_uniform(); if (unlikely(__pyx_t_26 == ((float)-1) && PyErr_Occurred())) __PYX_ERR(0, 5160, __pyx_L1_error) + __pyx_v_smooth_u = ((0.5 - __pyx_t_26) * __pyx_v_delta_t); + + /* "cssm.pyx":5159 + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t + * elif t_particle < max_t: # <<<<<<<<<<<<<< + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: +*/ + goto __pyx_L32; + } + + /* "cssm.pyx":5162 + * smooth_u = (0.5 - random_uniform()) * delta_t + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * else: + * smooth_u = 0.0 +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L32:; + + /* "cssm.pyx":5156 + * traj_view[ix, 0] = y + * + * if smooth_unif: # <<<<<<<<<<<<<< + * if t_particle == 0.0: + * smooth_u = random_uniform() * 0.5 * delta_t +*/ + goto __pyx_L31; + } + + /* "cssm.pyx":5164 + * smooth_u = 0.0 + * else: + * smooth_u = 0.0 # <<<<<<<<<<<<<< + * + * rts_view[n, k, 0] = t_particle + t_view[k, choice_idx] + smooth_u +*/ + /*else*/ { + __pyx_v_smooth_u = 0.0; + } + __pyx_L31:; + + /* "cssm.pyx":5166 + * smooth_u = 0.0 + * + * rts_view[n, k, 0] = t_particle + t_view[k, choice_idx] + smooth_u # <<<<<<<<<<<<<< + * if race: + * if return_option == 'full': +*/ + __pyx_t_23 = __pyx_v_k; + __pyx_t_15 = __pyx_v_choice_idx; + __pyx_t_25 = __pyx_v_n; + __pyx_t_28 = __pyx_v_k; + __pyx_t_29 = 0; + *((float *) ( /* dim=2 */ (( /* dim=1 */ (( /* dim=0 */ (__pyx_v_rts_view.data + __pyx_t_25 * __pyx_v_rts_view.strides[0]) ) + __pyx_t_28 * __pyx_v_rts_view.strides[1]) ) + __pyx_t_29 * __pyx_v_rts_view.strides[2]) )) = ((__pyx_v_t_particle + (*((float *) ( /* dim=1 */ (( /* dim=0 */ (__pyx_v_t_view.data + __pyx_t_23 * __pyx_v_t_view.strides[0]) ) + __pyx_t_15 * __pyx_v_t_view.strides[1]) )))) + __pyx_v_smooth_u); + } + __pyx_L7:; + } + } + + /* "cssm.pyx":5167 + * + * rts_view[n, k, 0] = t_particle + t_view[k, choice_idx] + smooth_u + * if race: # <<<<<<<<<<<<<< + * if return_option == 'full': + * return { +*/ + __pyx_t_19 = __Pyx_PyObject_IsTrue(__pyx_v_race); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5167, __pyx_L1_error) + if (__pyx_t_19) { + + /* "cssm.pyx":5168 + * rts_view[n, k, 0] = t_particle + t_view[k, choice_idx] + smooth_u + * if race: + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { + * 'rts': rts, +*/ + __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5168, __pyx_L1_error) + if (__pyx_t_19) { + + /* "cssm.pyx":5169 + * if race: + * if return_option == 'full': + * return { # <<<<<<<<<<<<<< + * 'rts': rts, + * 'choices': choices, +*/ + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":5170 + * if return_option == 'full': + * return { + * 'rts': rts, # <<<<<<<<<<<<<< + * 'choices': choices, + * 'metadata': { +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5170, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 5170, __pyx_L1_error) + + /* "cssm.pyx":5171 + * return { + * 'rts': rts, + * 'choices': choices, # <<<<<<<<<<<<<< + * 'metadata': { + * 'v': v, 'a': a, 't': t, 's': s, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 5170, __pyx_L1_error) + + /* "cssm.pyx":5173 + * 'choices': choices, + * 'metadata': { + * 'v': v, 'a': a, 't': t, 's': s, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5173, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + + /* "cssm.pyx":5174 + * 'metadata': { + * 'v': v, 'a': a, 't': t, 's': s, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'shifted_wald_race', +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5174, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_9) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5175 + * 'v': v, 'a': a, 't': t, 's': s, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'shifted_wald_race', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5175, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_9) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_shifted_wald_race) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + + /* "cssm.pyx":5177 + * 'n_trials': n_trials, + * 'simulator': 'shifted_wald_race', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + __pyx_t_9 = PyList_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5177, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 5177, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 5177, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_9) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5178 + * 'simulator': 'shifted_wald_race', + * 'possible_choices': [-1, 1], + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'trajectory': traj, +*/ + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5178, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_9) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5179 + * 'possible_choices': [-1, 1], + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'trajectory': traj, + * } +*/ + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5179, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_9) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5180 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'trajectory': traj, # <<<<<<<<<<<<<< + * } + * } +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 5173, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_6) < (0)) __PYX_ERR(0, 5170, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "cssm.pyx":5168 + * rts_view[n, k, 0] = t_particle + t_view[k, choice_idx] + smooth_u + * if race: + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { + * 'rts': rts, +*/ + } + + /* "cssm.pyx":5183 + * } + * } + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': + * {'simulator': 'shifted_wald_race', +*/ + __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5183, __pyx_L1_error) + if (likely(__pyx_t_19)) { + + /* "cssm.pyx":5184 + * } + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': # <<<<<<<<<<<<<< + * {'simulator': 'shifted_wald_race', + * 'n_samples': n_samples, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 5184, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 5184, __pyx_L1_error) + + /* "cssm.pyx":5185 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': + * {'simulator': 'shifted_wald_race', # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5185, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_shifted_wald_race) < (0)) __PYX_ERR(0, 5185, __pyx_L1_error) + + /* "cssm.pyx":5186 + * return {'rts': rts, 'choices': choices, 'metadata': + * {'simulator': 'shifted_wald_race', + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'possible_choices': [-1, 1]}} +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5186, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_9) < (0)) __PYX_ERR(0, 5185, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5187 + * {'simulator': 'shifted_wald_race', + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1]}} + * else: +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_9) < (0)) __PYX_ERR(0, 5185, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5188 + * 'n_samples': n_samples, + * 'n_trials': n_trials, + * 'possible_choices': [-1, 1]}} # <<<<<<<<<<<<<< + * else: + * raise ValueError("return_option must be 'full' or 'minimal'") +*/ + __pyx_t_9 = PyList_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5188, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 5188, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 5188, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_9) < (0)) __PYX_ERR(0, 5185, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_6) < (0)) __PYX_ERR(0, 5184, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "cssm.pyx":5183 + * } + * } + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': + * {'simulator': 'shifted_wald_race', +*/ + } + + /* "cssm.pyx":5190 + * 'possible_choices': [-1, 1]}} + * else: + * raise ValueError("return_option must be 'full' or 'minimal'") # <<<<<<<<<<<<<< + * else: + * if return_option == 'full': +*/ + /*else*/ { + __pyx_t_6 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_full_or_mi}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5190, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 5190, __pyx_L1_error) + } + + /* "cssm.pyx":5167 + * + * rts_view[n, k, 0] = t_particle + t_view[k, choice_idx] + smooth_u + * if race: # <<<<<<<<<<<<<< + * if return_option == 'full': + * return { +*/ + } + + /* "cssm.pyx":5192 + * raise ValueError("return_option must be 'full' or 'minimal'") + * else: + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { + * 'rts': rts, +*/ + /*else*/ { + __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_full, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5192, __pyx_L1_error) + if (__pyx_t_19) { + + /* "cssm.pyx":5193 + * else: + * if return_option == 'full': + * return { # <<<<<<<<<<<<<< + * 'rts': rts, + * 'choices': choices, +*/ + __Pyx_XDECREF(__pyx_r); + + /* "cssm.pyx":5194 + * if return_option == 'full': + * return { + * 'rts': rts, # <<<<<<<<<<<<<< + * 'choices': choices, + * 'metadata': { +*/ + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5194, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 5194, __pyx_L1_error) + + /* "cssm.pyx":5195 + * return { + * 'rts': rts, + * 'choices': choices, # <<<<<<<<<<<<<< + * 'metadata': { + * 'v': v, 'a': a, 't': t, 's': s, +*/ + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 5194, __pyx_L1_error) + + /* "cssm.pyx":5197 + * 'choices': choices, + * 'metadata': { + * 'v': v, 'a': a, 't': t, 's': s, # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = __Pyx_PyDict_NewPresized(11); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_v, ((PyObject *)__pyx_v_v)) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_a, ((PyObject *)__pyx_v_a)) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_t, ((PyObject *)__pyx_v_t)) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_s, ((PyObject *)__pyx_v_s)) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + + /* "cssm.pyx":5198 + * 'metadata': { + * 'v': v, 'a': a, 't': t, 's': s, + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'simulator': 'shifted_wald', +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_9) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5199 + * 'v': v, 'a': a, 't': t, 's': s, + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'simulator': 'shifted_wald', + * 'possible_choices': [-1, 1], +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_9) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_shifted_wald) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + + /* "cssm.pyx":5201 + * 'n_trials': n_trials, + * 'simulator': 'shifted_wald', + * 'possible_choices': [-1, 1], # <<<<<<<<<<<<<< + * 'delta_t': delta_t, + * 'max_t': max_t, +*/ + __pyx_t_9 = PyList_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5201, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 5201, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 5201, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_9) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5202 + * 'simulator': 'shifted_wald', + * 'possible_choices': [-1, 1], + * 'delta_t': delta_t, # <<<<<<<<<<<<<< + * 'max_t': max_t, + * 'trajectory': traj, +*/ + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_delta_t); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5202, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_delta_t, __pyx_t_9) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5203 + * 'possible_choices': [-1, 1], + * 'delta_t': delta_t, + * 'max_t': max_t, # <<<<<<<<<<<<<< + * 'trajectory': traj, + * } +*/ + __pyx_t_9 = PyFloat_FromDouble(__pyx_v_max_t); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5203, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_max_t, __pyx_t_9) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5204 + * 'delta_t': delta_t, + * 'max_t': max_t, + * 'trajectory': traj, # <<<<<<<<<<<<<< + * } + * } +*/ + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_trajectory, __pyx_v_traj) < (0)) __PYX_ERR(0, 5197, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_6) < (0)) __PYX_ERR(0, 5194, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "cssm.pyx":5192 + * raise ValueError("return_option must be 'full' or 'minimal'") + * else: + * if return_option == 'full': # <<<<<<<<<<<<<< + * return { + * 'rts': rts, +*/ + } + + /* "cssm.pyx":5207 + * } + * } + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': + * {'simulator': 'shifted_wald', +*/ + __pyx_t_19 = (__Pyx_PyUnicode_Equals(__pyx_v_return_option, __pyx_mstate_global->__pyx_n_u_minimal, Py_EQ)); if (unlikely((__pyx_t_19 < 0))) __PYX_ERR(0, 5207, __pyx_L1_error) + if (likely(__pyx_t_19)) { + + /* "cssm.pyx":5208 + * } + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': # <<<<<<<<<<<<<< + * {'simulator': 'shifted_wald', + * 'n_samples': n_samples, +*/ + __Pyx_XDECREF(__pyx_r); + __pyx_t_5 = __Pyx_PyDict_NewPresized(3); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5208, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_rts, __pyx_v_rts) < (0)) __PYX_ERR(0, 5208, __pyx_L1_error) + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_choices, __pyx_v_choices) < (0)) __PYX_ERR(0, 5208, __pyx_L1_error) + + /* "cssm.pyx":5209 + * elif return_option == 'minimal': + * return {'rts': rts, 'choices': choices, 'metadata': + * {'simulator': 'shifted_wald', # <<<<<<<<<<<<<< + * 'n_samples': n_samples, + * 'n_trials': n_trials, +*/ + __pyx_t_6 = __Pyx_PyDict_NewPresized(4); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 5209, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_6); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_simulator, __pyx_mstate_global->__pyx_n_u_shifted_wald) < (0)) __PYX_ERR(0, 5209, __pyx_L1_error) + + /* "cssm.pyx":5210 + * return {'rts': rts, 'choices': choices, 'metadata': + * {'simulator': 'shifted_wald', + * 'n_samples': n_samples, # <<<<<<<<<<<<<< + * 'n_trials': n_trials, + * 'possible_choices': [-1, 1]}} +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_samples); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5210, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_samples, __pyx_t_9) < (0)) __PYX_ERR(0, 5209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5211 + * {'simulator': 'shifted_wald', + * 'n_samples': n_samples, + * 'n_trials': n_trials, # <<<<<<<<<<<<<< + * 'possible_choices': [-1, 1]}} + * else: +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(__pyx_v_n_trials); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5211, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_n_trials, __pyx_t_9) < (0)) __PYX_ERR(0, 5209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":5212 + * 'n_samples': n_samples, + * 'n_trials': n_trials, + * 'possible_choices': [-1, 1]}} # <<<<<<<<<<<<<< + * else: + * raise ValueError("return_option must be 'full' or 'minimal'") +*/ + __pyx_t_9 = PyList_New(2); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5212, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(0, 5212, __pyx_L1_error); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_1); + if (__Pyx_PyList_SET_ITEM(__pyx_t_9, 1, __pyx_mstate_global->__pyx_int_1) != (0)) __PYX_ERR(0, 5212, __pyx_L1_error); + if (PyDict_SetItem(__pyx_t_6, __pyx_mstate_global->__pyx_n_u_possible_choices, __pyx_t_9) < (0)) __PYX_ERR(0, 5209, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_metadata, __pyx_t_6) < (0)) __PYX_ERR(0, 5208, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0; + __pyx_r = __pyx_t_5; + __pyx_t_5 = 0; + goto __pyx_L0; + + /* "cssm.pyx":5207 + * } + * } + * elif return_option == 'minimal': # <<<<<<<<<<<<<< + * return {'rts': rts, 'choices': choices, 'metadata': + * {'simulator': 'shifted_wald', +*/ + } + + /* "cssm.pyx":5214 + * 'possible_choices': [-1, 1]}} + * else: + * raise ValueError("return_option must be 'full' or 'minimal'") # <<<<<<<<<<<<<< + * # ----------------------------------------------------------------------------------------------- + * +*/ + /*else*/ { + __pyx_t_6 = NULL; + __pyx_t_8 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_mstate_global->__pyx_kp_u_return_option_must_be_full_or_mi}; + __pyx_t_5 = __Pyx_PyObject_FastCall((PyObject*)(((PyTypeObject*)PyExc_ValueError)), __pyx_callargs+__pyx_t_8, (2-__pyx_t_8) | (__pyx_t_8*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_6); __pyx_t_6 = 0; + if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5214, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + } + __Pyx_Raise(__pyx_t_5, 0, 0, 0); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __PYX_ERR(0, 5214, __pyx_L1_error) + } + } + + /* "cssm.pyx":5022 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def shifted_wald(np.ndarray[float, ndim = 2] v, # drift rate # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # boundary separation + * np.ndarray[float, ndim = 2] t, # nondecision time +*/ + + /* function exit code */ + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_2, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_3, 1); + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_6); + __Pyx_XDECREF(__pyx_t_7); + __Pyx_XDECREF(__pyx_t_9); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_10, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_t_11, 1); + { PyObject *__pyx_type, *__pyx_value, *__pyx_tb; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ErrFetch(&__pyx_type, &__pyx_value, &__pyx_tb); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_p.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __Pyx_ErrRestore(__pyx_type, __pyx_value, __pyx_tb);} + __Pyx_AddTraceback("cssm.shifted_wald", __pyx_clineno, __pyx_lineno, __pyx_filename); + __pyx_r = NULL; + goto __pyx_L2; + __pyx_L0:; + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_a.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_p.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_s.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_t.rcbuffer->pybuffer); + __Pyx_SafeReleaseBuffer(&__pyx_pybuffernd_v.rcbuffer->pybuffer); + __pyx_L2:; + __PYX_XCLEAR_MEMVIEW(&__pyx_v_v_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_a_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_t_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_p_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_s_view, 1); + __Pyx_XDECREF(__pyx_v_traj); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_traj_view, 1); + __Pyx_XDECREF(__pyx_v_rts); + __Pyx_XDECREF(__pyx_v_choices); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_rts_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_choices_view, 1); + __PYX_XCLEAR_MEMVIEW(&__pyx_v_gaussian_values, 1); + __Pyx_XDECREF(__pyx_v_rt_candidates); + __Pyx_XDECREF(__pyx_v_choices_idx); + __Pyx_XGIVEREF(__pyx_r); + __Pyx_RefNannyFinishContext(); + return __pyx_r; +} +/* #### Code section: module_exttypes ### */ + +static PyObject *__pyx_tp_new_4cssm___pyx_defaults(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 1); + if (unlikely(!o)) return 0; + return o; +} + +static void __pyx_tp_dealloc_4cssm___pyx_defaults(PyObject *o) { + struct __pyx_defaults *p = (struct __pyx_defaults *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4cssm___pyx_defaults) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->arg0); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_4cssm___pyx_defaults(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_defaults *p = (struct __pyx_defaults *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->arg0) { + e = (*v)(p->arg0, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_4cssm___pyx_defaults(PyObject *o) { + PyObject* tmp; + struct __pyx_defaults *p = (struct __pyx_defaults *)o; + tmp = ((PyObject*)p->arg0); + p->arg0 = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4cssm___pyx_defaults_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4cssm___pyx_defaults}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_4cssm___pyx_defaults}, + {Py_tp_clear, (void *)__pyx_tp_clear_4cssm___pyx_defaults}, + {Py_tp_new, (void *)__pyx_tp_new_4cssm___pyx_defaults}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4cssm___pyx_defaults_spec = { + "cssm.__pyx_defaults", + sizeof(struct __pyx_defaults), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_4cssm___pyx_defaults_slots, +}; +#else + +static PyTypeObject __pyx_type_4cssm___pyx_defaults = { + PyVarObject_HEAD_INIT(0, 0) + "cssm.""__pyx_defaults", /*tp_name*/ + sizeof(struct __pyx_defaults), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_4cssm___pyx_defaults, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_4cssm___pyx_defaults, /*tp_traverse*/ + __pyx_tp_clear_4cssm___pyx_defaults, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_4cssm___pyx_defaults, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_4cssm___pyx_defaults1(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 1); + if (unlikely(!o)) return 0; + return o; +} + +static void __pyx_tp_dealloc_4cssm___pyx_defaults1(PyObject *o) { + struct __pyx_defaults1 *p = (struct __pyx_defaults1 *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_4cssm___pyx_defaults1) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->arg0); + Py_CLEAR(p->arg1); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_4cssm___pyx_defaults1(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_defaults1 *p = (struct __pyx_defaults1 *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->arg0) { + e = (*v)(p->arg0, a); if (e) return e; + } + if (p->arg1) { + e = (*v)(p->arg1, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_4cssm___pyx_defaults1(PyObject *o) { + PyObject* tmp; + struct __pyx_defaults1 *p = (struct __pyx_defaults1 *)o; + tmp = ((PyObject*)p->arg0); + p->arg0 = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->arg1); + p->arg1 = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type_4cssm___pyx_defaults1_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_4cssm___pyx_defaults1}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_4cssm___pyx_defaults1}, + {Py_tp_clear, (void *)__pyx_tp_clear_4cssm___pyx_defaults1}, + {Py_tp_new, (void *)__pyx_tp_new_4cssm___pyx_defaults1}, + {0, 0}, +}; +static PyType_Spec __pyx_type_4cssm___pyx_defaults1_spec = { + "cssm.__pyx_defaults1", + sizeof(struct __pyx_defaults1), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, + __pyx_type_4cssm___pyx_defaults1_slots, +}; +#else + +static PyTypeObject __pyx_type_4cssm___pyx_defaults1 = { + PyVarObject_HEAD_INIT(0, 0) + "cssm.""__pyx_defaults1", /*tp_name*/ + sizeof(struct __pyx_defaults1), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_4cssm___pyx_defaults1, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_4cssm___pyx_defaults1, /*tp_traverse*/ + __pyx_tp_clear_4cssm___pyx_defaults1, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + 0, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_4cssm___pyx_defaults1, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_array __pyx_vtable_array; + +static PyObject *__pyx_tp_new_array(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_array_obj *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_array_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_array; + p->mode = ((PyObject*)Py_None); Py_INCREF(Py_None); + p->_format = ((PyObject*)Py_None); Py_INCREF(Py_None); + if (unlikely(__pyx_array___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_array(PyObject *o) { + struct __pyx_array_obj *p = (struct __pyx_array_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && (!PyType_IS_GC(Py_TYPE(o)) || !__Pyx_PyObject_GC_IsFinalized(o))) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_array) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_array___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->mode); + Py_CLEAR(p->_format); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static PyObject *__pyx_sq_item_array(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyLong_FromSsize_t(i); if(!x) return 0; + #if CYTHON_USE_TYPE_SLOTS || (!CYTHON_USE_TYPE_SPECS && __PYX_LIMITED_VERSION_HEX < 0x030A0000) + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + #else + r = ((binaryfunc)PyType_GetSlot(Py_TYPE(o), Py_mp_subscript))(o, x); + #endif + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_array(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_array___setitem__(o, i, v); + } + else { + __Pyx_TypeName o_type_name; + o_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(o)); + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); + __Pyx_DECREF_TypeName(o_type_name); + return -1; + } +} + +static PyObject *__pyx_tp_getattro_array(PyObject *o, PyObject *n) { + PyObject *v = PyObject_GenericGetAttr(o, n); + if (!v && PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + v = __pyx_array___getattr__(o, n); + } + return v; +} + +static PyObject *__pyx_getprop___pyx_array_memview(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_5array_7memview_1__get__(o); +} + +static PyMethodDef __pyx_methods_array[] = { + {"__getattr__", (PyCFunction)__pyx_array___getattr__, METH_O|METH_COEXIST, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_array_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_array[] = { + {"memview", __pyx_getprop___pyx_array_memview, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +#if !CYTHON_COMPILING_IN_LIMITED_API + +static PyBufferProcs __pyx_tp_as_buffer_array = { + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; +#endif +static PyType_Slot __pyx_type___pyx_array_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_array}, + {Py_sq_length, (void *)__pyx_array___len__}, + {Py_sq_item, (void *)__pyx_sq_item_array}, + {Py_mp_length, (void *)__pyx_array___len__}, + {Py_mp_subscript, (void *)__pyx_array___getitem__}, + {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_array}, + {Py_tp_getattro, (void *)__pyx_tp_getattro_array}, + #if defined(Py_bf_getbuffer) + {Py_bf_getbuffer, (void *)__pyx_array_getbuffer}, + #endif + {Py_tp_methods, (void *)__pyx_methods_array}, + {Py_tp_getset, (void *)__pyx_getsets_array}, + {Py_tp_new, (void *)__pyx_tp_new_array}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_array_spec = { + "cssm.array", + sizeof(struct __pyx_array_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_SEQUENCE, + __pyx_type___pyx_array_slots, +}; +#else + +static PySequenceMethods __pyx_tp_as_sequence_array = { + __pyx_array___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_array, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_array = { + __pyx_array___len__, /*mp_length*/ + __pyx_array___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_array, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_array = { + __pyx_array_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_array = { + PyVarObject_HEAD_INIT(0, 0) + "cssm.""array", /*tp_name*/ + sizeof(struct __pyx_array_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_array, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + 0, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_array, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_array, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + __pyx_tp_getattro_array, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_array, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ + 0, /*tp_doc*/ + 0, /*tp_traverse*/ + 0, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_array, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_array, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_array, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyObject *__pyx_tp_new_Enum(PyTypeObject *t, CYTHON_UNUSED PyObject *a, CYTHON_UNUSED PyObject *k) { + struct __pyx_MemviewEnum_obj *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_MemviewEnum_obj *)o); + p->name = Py_None; Py_INCREF(Py_None); + return o; +} + +static void __pyx_tp_dealloc_Enum(PyObject *o) { + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_Enum) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + Py_CLEAR(p->name); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_Enum(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->name) { + e = (*v)(p->name, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_Enum(PyObject *o) { + PyObject* tmp; + struct __pyx_MemviewEnum_obj *p = (struct __pyx_MemviewEnum_obj *)o; + tmp = ((PyObject*)p->name); + p->name = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + return 0; +} + +static PyMethodDef __pyx_methods_Enum[] = { + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_MemviewEnum_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type___pyx_MemviewEnum_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_Enum}, + {Py_tp_repr, (void *)__pyx_MemviewEnum___repr__}, + {Py_tp_traverse, (void *)__pyx_tp_traverse_Enum}, + {Py_tp_clear, (void *)__pyx_tp_clear_Enum}, + {Py_tp_methods, (void *)__pyx_methods_Enum}, + {Py_tp_init, (void *)__pyx_MemviewEnum___init__}, + {Py_tp_new, (void *)__pyx_tp_new_Enum}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_MemviewEnum_spec = { + "cssm.Enum", + sizeof(struct __pyx_MemviewEnum_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type___pyx_MemviewEnum_slots, +}; +#else + +static PyTypeObject __pyx_type___pyx_MemviewEnum = { + PyVarObject_HEAD_INIT(0, 0) + "cssm.""Enum", /*tp_name*/ + sizeof(struct __pyx_MemviewEnum_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_Enum, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_MemviewEnum___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + 0, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_Enum, /*tp_traverse*/ + __pyx_tp_clear_Enum, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_Enum, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + __pyx_MemviewEnum___init__, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_Enum, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct_memoryview __pyx_vtable_memoryview; + +static PyObject *__pyx_tp_new_memoryview(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryview_obj *p; + PyObject *o; + o = __Pyx_AllocateExtensionType(t, 0); + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryview_obj *)o); + p->__pyx_vtab = __pyx_vtabptr_memoryview; + p->obj = Py_None; Py_INCREF(Py_None); + p->_size = Py_None; Py_INCREF(Py_None); + p->view.obj = NULL; + if (unlikely(__pyx_memoryview___cinit__(o, a, k) < 0)) goto bad; + return o; + bad: + Py_DECREF(o); o = 0; + return NULL; +} + +static void __pyx_tp_dealloc_memoryview(PyObject *o) { + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc_memoryview) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryview___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + Py_CLEAR(p->obj); + Py_CLEAR(p->_size); + PyTypeObject *tp = Py_TYPE(o); + #if CYTHON_USE_TYPE_SLOTS + (*tp->tp_free)(o); + #else + { + freefunc tp_free = (freefunc)PyType_GetSlot(tp, Py_tp_free); + if (tp_free) tp_free(o); + } + #endif + #if CYTHON_USE_TYPE_SPECS + Py_DECREF(tp); + #endif +} + +static int __pyx_tp_traverse_memoryview(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + { + e = __Pyx_call_type_traverse(o, 1, v, a); + if (e) return e; + } + if (p->obj) { + e = (*v)(p->obj, a); if (e) return e; + } + if (p->_size) { + e = (*v)(p->_size, a); if (e) return e; + } + if (p->view.obj) { + e = (*v)(p->view.obj, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear_memoryview(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryview_obj *p = (struct __pyx_memoryview_obj *)o; + tmp = ((PyObject*)p->obj); + p->obj = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + tmp = ((PyObject*)p->_size); + p->_size = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + Py_CLEAR(p->view.obj); + return 0; +} + +static PyObject *__pyx_sq_item_memoryview(PyObject *o, Py_ssize_t i) { + PyObject *r; + PyObject *x = PyLong_FromSsize_t(i); if(!x) return 0; + #if CYTHON_USE_TYPE_SLOTS || (!CYTHON_USE_TYPE_SPECS && __PYX_LIMITED_VERSION_HEX < 0x030A0000) + r = Py_TYPE(o)->tp_as_mapping->mp_subscript(o, x); + #else + r = ((binaryfunc)PyType_GetSlot(Py_TYPE(o), Py_mp_subscript))(o, x); + #endif + Py_DECREF(x); + return r; +} + +static int __pyx_mp_ass_subscript_memoryview(PyObject *o, PyObject *i, PyObject *v) { + if (v) { + return __pyx_memoryview___setitem__(o, i, v); + } + else { + __Pyx_TypeName o_type_name; + o_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(o)); + PyErr_Format(PyExc_NotImplementedError, + "Subscript deletion not supported by " __Pyx_FMT_TYPENAME, o_type_name); + __Pyx_DECREF_TypeName(o_type_name); + return -1; + } +} + +static PyObject *__pyx_getprop___pyx_memoryview_T(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_1T_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_base(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4base_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_shape(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_5shape_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_strides(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_7strides_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_suboffsets(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_10suboffsets_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_ndim(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4ndim_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_itemsize(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_8itemsize_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_nbytes(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_6nbytes_1__get__(o); +} + +static PyObject *__pyx_getprop___pyx_memoryview_size(PyObject *o, CYTHON_UNUSED void *x) { + return __pyx_pw_15View_dot_MemoryView_10memoryview_4size_1__get__(o); +} + +static PyMethodDef __pyx_methods_memoryview[] = { + {"is_c_contig", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_c_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"is_f_contig", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_is_f_contig, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"copy", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"copy_fortran", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_memoryview_copy_fortran, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryview_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; + +static struct PyGetSetDef __pyx_getsets_memoryview[] = { + {"T", __pyx_getprop___pyx_memoryview_T, 0, 0, 0}, + {"base", __pyx_getprop___pyx_memoryview_base, 0, 0, 0}, + {"shape", __pyx_getprop___pyx_memoryview_shape, 0, 0, 0}, + {"strides", __pyx_getprop___pyx_memoryview_strides, 0, 0, 0}, + {"suboffsets", __pyx_getprop___pyx_memoryview_suboffsets, 0, 0, 0}, + {"ndim", __pyx_getprop___pyx_memoryview_ndim, 0, 0, 0}, + {"itemsize", __pyx_getprop___pyx_memoryview_itemsize, 0, 0, 0}, + {"nbytes", __pyx_getprop___pyx_memoryview_nbytes, 0, 0, 0}, + {"size", __pyx_getprop___pyx_memoryview_size, 0, 0, 0}, + {0, 0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +#if !CYTHON_COMPILING_IN_LIMITED_API + +static PyBufferProcs __pyx_tp_as_buffer_memoryview = { + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; +#endif +static PyType_Slot __pyx_type___pyx_memoryview_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc_memoryview}, + {Py_tp_repr, (void *)__pyx_memoryview___repr__}, + {Py_sq_length, (void *)__pyx_memoryview___len__}, + {Py_sq_item, (void *)__pyx_sq_item_memoryview}, + {Py_mp_length, (void *)__pyx_memoryview___len__}, + {Py_mp_subscript, (void *)__pyx_memoryview___getitem__}, + {Py_mp_ass_subscript, (void *)__pyx_mp_ass_subscript_memoryview}, + {Py_tp_str, (void *)__pyx_memoryview___str__}, + #if defined(Py_bf_getbuffer) + {Py_bf_getbuffer, (void *)__pyx_memoryview_getbuffer}, + #endif + {Py_tp_traverse, (void *)__pyx_tp_traverse_memoryview}, + {Py_tp_clear, (void *)__pyx_tp_clear_memoryview}, + {Py_tp_methods, (void *)__pyx_methods_memoryview}, + {Py_tp_getset, (void *)__pyx_getsets_memoryview}, + {Py_tp_new, (void *)__pyx_tp_new_memoryview}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_memoryview_spec = { + "cssm.memoryview", + sizeof(struct __pyx_memoryview_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, + __pyx_type___pyx_memoryview_slots, +}; +#else + +static PySequenceMethods __pyx_tp_as_sequence_memoryview = { + __pyx_memoryview___len__, /*sq_length*/ + 0, /*sq_concat*/ + 0, /*sq_repeat*/ + __pyx_sq_item_memoryview, /*sq_item*/ + 0, /*sq_slice*/ + 0, /*sq_ass_item*/ + 0, /*sq_ass_slice*/ + 0, /*sq_contains*/ + 0, /*sq_inplace_concat*/ + 0, /*sq_inplace_repeat*/ +}; + +static PyMappingMethods __pyx_tp_as_mapping_memoryview = { + __pyx_memoryview___len__, /*mp_length*/ + __pyx_memoryview___getitem__, /*mp_subscript*/ + __pyx_mp_ass_subscript_memoryview, /*mp_ass_subscript*/ +}; + +static PyBufferProcs __pyx_tp_as_buffer_memoryview = { + __pyx_memoryview_getbuffer, /*bf_getbuffer*/ + 0, /*bf_releasebuffer*/ +}; + +static PyTypeObject __pyx_type___pyx_memoryview = { + PyVarObject_HEAD_INIT(0, 0) + "cssm.""memoryview", /*tp_name*/ + sizeof(struct __pyx_memoryview_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc_memoryview, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + __pyx_memoryview___repr__, /*tp_repr*/ + 0, /*tp_as_number*/ + &__pyx_tp_as_sequence_memoryview, /*tp_as_sequence*/ + &__pyx_tp_as_mapping_memoryview, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + __pyx_memoryview___str__, /*tp_str*/ + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + &__pyx_tp_as_buffer_memoryview, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC, /*tp_flags*/ + 0, /*tp_doc*/ + __pyx_tp_traverse_memoryview, /*tp_traverse*/ + __pyx_tp_clear_memoryview, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods_memoryview, /*tp_methods*/ + 0, /*tp_members*/ + __pyx_getsets_memoryview, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new_memoryview, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif +static struct __pyx_vtabstruct__memoryviewslice __pyx_vtable__memoryviewslice; + +static PyObject *__pyx_tp_new__memoryviewslice(PyTypeObject *t, PyObject *a, PyObject *k) { + struct __pyx_memoryviewslice_obj *p; + PyObject *o = __pyx_tp_new_memoryview(t, a, k); + if (unlikely(!o)) return 0; + p = ((struct __pyx_memoryviewslice_obj *)o); + p->__pyx_base.__pyx_vtab = (struct __pyx_vtabstruct_memoryview*)__pyx_vtabptr__memoryviewslice; + __Pyx_default_placement_construct(&(p->from_slice)); + p->from_object = Py_None; Py_INCREF(Py_None); + p->from_slice.memview = NULL; + return o; +} + +static void __pyx_tp_dealloc__memoryviewslice(PyObject *o) { + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + #if CYTHON_USE_TP_FINALIZE + if (unlikely(__Pyx_PyObject_GetSlot(o, tp_finalize, destructor)) && !__Pyx_PyObject_GC_IsFinalized(o)) { + if (__Pyx_PyObject_GetSlot(o, tp_dealloc, destructor) == __pyx_tp_dealloc__memoryviewslice) { + if (PyObject_CallFinalizerFromDealloc(o)) return; + } + } + #endif + PyObject_GC_UnTrack(o); + { + PyObject *etype, *eval, *etb; + PyErr_Fetch(&etype, &eval, &etb); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) + 1); + __pyx_memoryviewslice___dealloc__(o); + __Pyx_SET_REFCNT(o, Py_REFCNT(o) - 1); + PyErr_Restore(etype, eval, etb); + } + __Pyx_call_destructor(p->from_slice); + Py_CLEAR(p->from_object); + PyObject_GC_Track(o); + __pyx_tp_dealloc_memoryview(o); +} + +static int __pyx_tp_traverse__memoryviewslice(PyObject *o, visitproc v, void *a) { + int e; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + e = __pyx_tp_traverse_memoryview(o, v, a); if (e) return e; + if (p->from_object) { + e = (*v)(p->from_object, a); if (e) return e; + } + return 0; +} + +static int __pyx_tp_clear__memoryviewslice(PyObject *o) { + PyObject* tmp; + struct __pyx_memoryviewslice_obj *p = (struct __pyx_memoryviewslice_obj *)o; + __pyx_tp_clear_memoryview(o); + tmp = ((PyObject*)p->from_object); + p->from_object = Py_None; Py_INCREF(Py_None); + Py_XDECREF(tmp); + __PYX_XCLEAR_MEMVIEW(&p->from_slice, 1); + return 0; +} + +static PyMethodDef __pyx_methods__memoryviewslice[] = { + {"__reduce_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_1__reduce_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {"__setstate_cython__", (PyCFunction)(void(*)(void))(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw___pyx_memoryviewslice_3__setstate_cython__, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0}, + {0, 0, 0, 0} +}; +#if CYTHON_USE_TYPE_SPECS +static PyType_Slot __pyx_type___pyx_memoryviewslice_slots[] = { + {Py_tp_dealloc, (void *)__pyx_tp_dealloc__memoryviewslice}, + {Py_tp_doc, (void *)PyDoc_STR("Internal class for passing memoryview slices to Python")}, + {Py_tp_traverse, (void *)__pyx_tp_traverse__memoryviewslice}, + {Py_tp_clear, (void *)__pyx_tp_clear__memoryviewslice}, + {Py_tp_methods, (void *)__pyx_methods__memoryviewslice}, + {Py_tp_new, (void *)__pyx_tp_new__memoryviewslice}, + {0, 0}, +}; +static PyType_Spec __pyx_type___pyx_memoryviewslice_spec = { + "cssm._memoryviewslice", + sizeof(struct __pyx_memoryviewslice_obj), + 0, + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, + __pyx_type___pyx_memoryviewslice_slots, +}; +#else + +static PyTypeObject __pyx_type___pyx_memoryviewslice = { + PyVarObject_HEAD_INIT(0, 0) + "cssm.""_memoryviewslice", /*tp_name*/ + sizeof(struct __pyx_memoryviewslice_obj), /*tp_basicsize*/ + 0, /*tp_itemsize*/ + __pyx_tp_dealloc__memoryviewslice, /*tp_dealloc*/ + 0, /*tp_vectorcall_offset*/ + 0, /*tp_getattr*/ + 0, /*tp_setattr*/ + 0, /*tp_as_async*/ + #if CYTHON_COMPILING_IN_PYPY || 0 + __pyx_memoryview___repr__, /*tp_repr*/ + #else + 0, /*tp_repr*/ + #endif + 0, /*tp_as_number*/ + 0, /*tp_as_sequence*/ + 0, /*tp_as_mapping*/ + 0, /*tp_hash*/ + 0, /*tp_call*/ + #if CYTHON_COMPILING_IN_PYPY || 0 + __pyx_memoryview___str__, /*tp_str*/ + #else + 0, /*tp_str*/ + #endif + 0, /*tp_getattro*/ + 0, /*tp_setattro*/ + 0, /*tp_as_buffer*/ + Py_TPFLAGS_DEFAULT|Py_TPFLAGS_HAVE_VERSION_TAG|Py_TPFLAGS_CHECKTYPES|Py_TPFLAGS_HAVE_NEWBUFFER|Py_TPFLAGS_BASETYPE|Py_TPFLAGS_HAVE_GC|Py_TPFLAGS_SEQUENCE, /*tp_flags*/ + PyDoc_STR("Internal class for passing memoryview slices to Python"), /*tp_doc*/ + __pyx_tp_traverse__memoryviewslice, /*tp_traverse*/ + __pyx_tp_clear__memoryviewslice, /*tp_clear*/ + 0, /*tp_richcompare*/ + 0, /*tp_weaklistoffset*/ + 0, /*tp_iter*/ + 0, /*tp_iternext*/ + __pyx_methods__memoryviewslice, /*tp_methods*/ + 0, /*tp_members*/ + 0, /*tp_getset*/ + 0, /*tp_base*/ + 0, /*tp_dict*/ + 0, /*tp_descr_get*/ + 0, /*tp_descr_set*/ + #if !CYTHON_USE_TYPE_SPECS + 0, /*tp_dictoffset*/ + #endif + 0, /*tp_init*/ + 0, /*tp_alloc*/ + __pyx_tp_new__memoryviewslice, /*tp_new*/ + 0, /*tp_free*/ + 0, /*tp_is_gc*/ + 0, /*tp_bases*/ + 0, /*tp_mro*/ + 0, /*tp_cache*/ + 0, /*tp_subclasses*/ + 0, /*tp_weaklist*/ + 0, /*tp_del*/ + 0, /*tp_version_tag*/ + #if CYTHON_USE_TP_FINALIZE + 0, /*tp_finalize*/ + #else + NULL, /*tp_finalize*/ + #endif + #if !CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800 + 0, /*tp_vectorcall*/ + #endif + #if __PYX_NEED_TP_PRINT_SLOT == 1 + 0, /*tp_print*/ + #endif + #if PY_VERSION_HEX >= 0x030C0000 + 0, /*tp_watched*/ + #endif + #if PY_VERSION_HEX >= 0x030d00A4 + 0, /*tp_versions_used*/ + #endif + #if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000 + 0, /*tp_pypy_flags*/ + #endif +}; +#endif + +static PyMethodDef __pyx_methods[] = { + {0, 0, 0, 0} +}; +/* #### Code section: initfunc_declarations ### */ +static CYTHON_SMALL_CODE int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitGlobals(void); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate); /*proto*/ +static CYTHON_SMALL_CODE int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate); /*proto*/ +/* #### Code section: init_module ### */ + +static int __Pyx_modinit_global_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0); + /*--- Global init code ---*/ + __pyx_collections_abc_Sequence = Py_None; Py_INCREF(Py_None); + generic = Py_None; Py_INCREF(Py_None); + strided = Py_None; Py_INCREF(Py_None); + indirect = Py_None; Py_INCREF(Py_None); + contiguous = Py_None; Py_INCREF(Py_None); + indirect_contiguous = Py_None; Py_INCREF(Py_None); + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_variable_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0); + /*--- Variable export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_export_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0); + /*--- Function export code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_type_init_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0); + /*--- Type init code ---*/ + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4cssm___pyx_defaults_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 515, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4cssm___pyx_defaults_spec, __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults) < (0)) __PYX_ERR(0, 515, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults = &__pyx_type_4cssm___pyx_defaults; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_4cssm___pyx_defaults) < (0)) __PYX_ERR(0, 515, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_4cssm___pyx_defaults); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_4cssm___pyx_defaults->tp_dictoffset && __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults->tp_getattro = PyObject_GenericGetAttr; + } + #endif + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults1 = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type_4cssm___pyx_defaults1_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_ptype_4cssm___pyx_defaults1)) __PYX_ERR(0, 682, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type_4cssm___pyx_defaults1_spec, __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults1) < (0)) __PYX_ERR(0, 682, __pyx_L1_error) + #else + __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults1 = &__pyx_type_4cssm___pyx_defaults1; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_ptype_4cssm___pyx_defaults1) < (0)) __PYX_ERR(0, 682, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_ptype_4cssm___pyx_defaults1); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_ptype_4cssm___pyx_defaults1->tp_dictoffset && __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults1->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_ptype_4cssm___pyx_defaults1->tp_getattro = PyObject_GenericGetAttr; + } + #endif + __pyx_vtabptr_array = &__pyx_vtable_array; + __pyx_vtable_array.get_memview = (PyObject *(*)(struct __pyx_array_obj *))__pyx_array_get_memview; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_array_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_array_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_array_type)) __PYX_ERR(1, 110, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_mstate->__pyx_array_type->tp_as_buffer = &__pyx_tp_as_buffer_array; + if (!__pyx_mstate->__pyx_array_type->tp_as_buffer->bf_releasebuffer && __pyx_mstate->__pyx_array_type->tp_base->tp_as_buffer && __pyx_mstate->__pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer) { + __pyx_mstate->__pyx_array_type->tp_as_buffer->bf_releasebuffer = __pyx_mstate->__pyx_array_type->tp_base->tp_as_buffer->bf_releasebuffer; + } + #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) + /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ + #elif defined(_MSC_VER) + #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") + #else + #warning "The buffer protocol is not supported in the Limited C-API < 3.11." + #endif + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_array_spec, __pyx_mstate->__pyx_array_type) < (0)) __PYX_ERR(1, 110, __pyx_L1_error) + #else + __pyx_mstate->__pyx_array_type = &__pyx_type___pyx_array; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_array_type) < (0)) __PYX_ERR(1, 110, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_array_type); + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_array_type, __pyx_vtabptr_array) < (0)) __PYX_ERR(1, 110, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_array_type) < (0)) __PYX_ERR(1, 110, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_array_type) < (0)) __PYX_ERR(1, 110, __pyx_L1_error) + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_MemviewEnum_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_MemviewEnum_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_MemviewEnum_type)) __PYX_ERR(1, 299, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_MemviewEnum_spec, __pyx_mstate->__pyx_MemviewEnum_type) < (0)) __PYX_ERR(1, 299, __pyx_L1_error) + #else + __pyx_mstate->__pyx_MemviewEnum_type = &__pyx_type___pyx_MemviewEnum; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_MemviewEnum_type) < (0)) __PYX_ERR(1, 299, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_MemviewEnum_type); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_MemviewEnum_type->tp_dictoffset && __pyx_mstate->__pyx_MemviewEnum_type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_MemviewEnum_type->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_MemviewEnum_type) < (0)) __PYX_ERR(1, 299, __pyx_L1_error) + __pyx_vtabptr_memoryview = &__pyx_vtable_memoryview; + __pyx_vtable_memoryview.get_item_pointer = (char *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_get_item_pointer; + __pyx_vtable_memoryview.is_slice = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_is_slice; + __pyx_vtable_memoryview.setitem_slice_assignment = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_slice_assignment; + __pyx_vtable_memoryview.setitem_slice_assign_scalar = (PyObject *(*)(struct __pyx_memoryview_obj *, struct __pyx_memoryview_obj *, PyObject *))__pyx_memoryview_setitem_slice_assign_scalar; + __pyx_vtable_memoryview.setitem_indexed = (PyObject *(*)(struct __pyx_memoryview_obj *, PyObject *, PyObject *))__pyx_memoryview_setitem_indexed; + __pyx_vtable_memoryview.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryview_convert_item_to_object; + __pyx_vtable_memoryview.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryview_assign_item_from_object; + __pyx_vtable_memoryview._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryview__get_base; + #if CYTHON_USE_TYPE_SPECS + __pyx_mstate->__pyx_memoryview_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryview_spec, NULL); if (unlikely(!__pyx_mstate->__pyx_memoryview_type)) __PYX_ERR(1, 334, __pyx_L1_error) + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_mstate->__pyx_memoryview_type->tp_as_buffer = &__pyx_tp_as_buffer_memoryview; + if (!__pyx_mstate->__pyx_memoryview_type->tp_as_buffer->bf_releasebuffer && __pyx_mstate->__pyx_memoryview_type->tp_base->tp_as_buffer && __pyx_mstate->__pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer) { + __pyx_mstate->__pyx_memoryview_type->tp_as_buffer->bf_releasebuffer = __pyx_mstate->__pyx_memoryview_type->tp_base->tp_as_buffer->bf_releasebuffer; + } + #elif defined(Py_bf_getbuffer) && defined(Py_bf_releasebuffer) + /* PY_VERSION_HEX >= 0x03090000 || Py_LIMITED_API >= 0x030B0000 */ + #elif defined(_MSC_VER) + #pragma message ("The buffer protocol is not supported in the Limited C-API < 3.11.") + #else + #warning "The buffer protocol is not supported in the Limited C-API < 3.11." + #endif + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryview_spec, __pyx_mstate->__pyx_memoryview_type) < (0)) __PYX_ERR(1, 334, __pyx_L1_error) + #else + __pyx_mstate->__pyx_memoryview_type = &__pyx_type___pyx_memoryview; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_memoryview_type) < (0)) __PYX_ERR(1, 334, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_memoryview_type); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_memoryview_type->tp_dictoffset && __pyx_mstate->__pyx_memoryview_type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_memoryview_type->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_memoryview_type, __pyx_vtabptr_memoryview) < (0)) __PYX_ERR(1, 334, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_memoryview_type) < (0)) __PYX_ERR(1, 334, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_memoryview_type) < (0)) __PYX_ERR(1, 334, __pyx_L1_error) + __pyx_vtabptr__memoryviewslice = &__pyx_vtable__memoryviewslice; + __pyx_vtable__memoryviewslice.__pyx_base = *__pyx_vtabptr_memoryview; + __pyx_vtable__memoryviewslice.__pyx_base.convert_item_to_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *))__pyx_memoryviewslice_convert_item_to_object; + __pyx_vtable__memoryviewslice.__pyx_base.assign_item_from_object = (PyObject *(*)(struct __pyx_memoryview_obj *, char *, PyObject *))__pyx_memoryviewslice_assign_item_from_object; + __pyx_vtable__memoryviewslice.__pyx_base._get_base = (PyObject *(*)(struct __pyx_memoryview_obj *))__pyx_memoryviewslice__get_base; + #if CYTHON_USE_TYPE_SPECS + __pyx_t_1 = PyTuple_Pack(1, (PyObject *)__pyx_mstate_global->__pyx_memoryview_type); if (unlikely(!__pyx_t_1)) __PYX_ERR(1, 951, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_memoryviewslice_type = (PyTypeObject *) __Pyx_PyType_FromModuleAndSpec(__pyx_m, &__pyx_type___pyx_memoryviewslice_spec, __pyx_t_1); + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + if (unlikely(!__pyx_mstate->__pyx_memoryviewslice_type)) __PYX_ERR(1, 951, __pyx_L1_error) + if (__Pyx_fix_up_extension_type_from_spec(&__pyx_type___pyx_memoryviewslice_spec, __pyx_mstate->__pyx_memoryviewslice_type) < (0)) __PYX_ERR(1, 951, __pyx_L1_error) + #else + __pyx_mstate->__pyx_memoryviewslice_type = &__pyx_type___pyx_memoryviewslice; + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + __pyx_mstate_global->__pyx_memoryviewslice_type->tp_base = __pyx_mstate_global->__pyx_memoryview_type; + #endif + #if !CYTHON_USE_TYPE_SPECS + if (__Pyx_PyType_Ready(__pyx_mstate->__pyx_memoryviewslice_type) < (0)) __PYX_ERR(1, 951, __pyx_L1_error) + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount((PyObject*)__pyx_mstate->__pyx_memoryviewslice_type); + #endif + #if !CYTHON_COMPILING_IN_LIMITED_API + if ((CYTHON_USE_TYPE_SLOTS && CYTHON_USE_PYTYPE_LOOKUP) && likely(!__pyx_mstate->__pyx_memoryviewslice_type->tp_dictoffset && __pyx_mstate->__pyx_memoryviewslice_type->tp_getattro == PyObject_GenericGetAttr)) { + __pyx_mstate->__pyx_memoryviewslice_type->tp_getattro = PyObject_GenericGetAttr; + } + #endif + if (__Pyx_SetVtable(__pyx_mstate->__pyx_memoryviewslice_type, __pyx_vtabptr__memoryviewslice) < (0)) __PYX_ERR(1, 951, __pyx_L1_error) + if (__Pyx_MergeVtables(__pyx_mstate->__pyx_memoryviewslice_type) < (0)) __PYX_ERR(1, 951, __pyx_L1_error) + if (__Pyx_setup_reduce((PyObject *) __pyx_mstate->__pyx_memoryviewslice_type) < (0)) __PYX_ERR(1, 951, __pyx_L1_error) + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_type_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + PyObject *__pyx_t_1 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0); + /*--- Type import code ---*/ + __pyx_t_1 = PyImport_ImportModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_t_1)) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_ptype_7cpython_4type_type = __Pyx_ImportType_3_2_0(__pyx_t_1, __Pyx_BUILTIN_MODULE_NAME, "type", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyTypeObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + 0, 0, + #else + sizeof(PyHeapTypeObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyHeapTypeObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_7cpython_4type_type) __PYX_ERR(3, 9, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __pyx_t_1 = PyImport_ImportModule("numpy"); if (unlikely(!__pyx_t_1)) __PYX_ERR(2, 228, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_1); + __pyx_mstate->__pyx_ptype_5numpy_dtype = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "dtype", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArray_Descr), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArray_Descr), + #else + sizeof(PyArray_Descr), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArray_Descr), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_dtype) __PYX_ERR(2, 228, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_flatiter = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "flatiter", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArrayIterObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArrayIterObject), + #else + sizeof(PyArrayIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArrayIterObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_flatiter) __PYX_ERR(2, 273, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_broadcast = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "broadcast", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArrayMultiIterObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArrayMultiIterObject), + #else + sizeof(PyArrayMultiIterObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArrayMultiIterObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_broadcast) __PYX_ERR(2, 277, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_ndarray = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "ndarray", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArrayObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArrayObject), + #else + sizeof(PyArrayObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyArrayObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_ndarray) __PYX_ERR(2, 316, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_generic = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "generic", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_generic) __PYX_ERR(2, 825, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_number = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "number", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_number) __PYX_ERR(2, 827, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_integer = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "integer", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_integer) __PYX_ERR(2, 829, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_signedinteger = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "signedinteger", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_signedinteger) __PYX_ERR(2, 831, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_unsignedinteger = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "unsignedinteger", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_unsignedinteger) __PYX_ERR(2, 833, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_inexact = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "inexact", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_inexact) __PYX_ERR(2, 835, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_floating = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "floating", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_floating) __PYX_ERR(2, 837, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_complexfloating = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "complexfloating", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_complexfloating) __PYX_ERR(2, 839, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_flexible = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "flexible", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_flexible) __PYX_ERR(2, 841, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_character = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "character", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #else + sizeof(PyObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyObject), + #endif + __Pyx_ImportType_CheckSize_Warn_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_character) __PYX_ERR(2, 843, __pyx_L1_error) + __pyx_mstate->__pyx_ptype_5numpy_ufunc = __Pyx_ImportType_3_2_0(__pyx_t_1, "numpy", "ufunc", + #if defined(PYPY_VERSION_NUM) && PYPY_VERSION_NUM < 0x050B0000 + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyUFuncObject), + #elif CYTHON_COMPILING_IN_LIMITED_API + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyUFuncObject), + #else + sizeof(PyUFuncObject), __PYX_GET_STRUCT_ALIGNMENT_3_2_0(PyUFuncObject), + #endif + __Pyx_ImportType_CheckSize_Ignore_3_2_0); if (!__pyx_mstate->__pyx_ptype_5numpy_ufunc) __PYX_ERR(2, 907, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_1); + __Pyx_RefNannyFinishContext(); + return -1; +} + +static int __Pyx_modinit_variable_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0); + /*--- Variable import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +static int __Pyx_modinit_function_import_code(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0); + /*--- Function import code ---*/ + __Pyx_RefNannyFinishContext(); + return 0; +} + +#if CYTHON_PEP489_MULTI_PHASE_INIT +static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/ +static int __pyx_pymod_exec_cssm(PyObject* module); /*proto*/ +static PyModuleDef_Slot __pyx_moduledef_slots[] = { + {Py_mod_create, (void*)__pyx_pymod_create}, + {Py_mod_exec, (void*)__pyx_pymod_exec_cssm}, + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + {Py_mod_gil, Py_MOD_GIL_USED}, + #endif + #if PY_VERSION_HEX >= 0x030C0000 && CYTHON_USE_MODULE_STATE + {Py_mod_multiple_interpreters, Py_MOD_MULTIPLE_INTERPRETERS_NOT_SUPPORTED}, + #endif + {0, NULL} +}; +#endif + +#ifdef __cplusplus +namespace { + struct PyModuleDef __pyx_moduledef = + #else + static struct PyModuleDef __pyx_moduledef = + #endif + { + PyModuleDef_HEAD_INIT, + "cssm", + 0, /* m_doc */ + #if CYTHON_USE_MODULE_STATE + sizeof(__pyx_mstatetype), /* m_size */ + #else + (CYTHON_PEP489_MULTI_PHASE_INIT) ? 0 : -1, /* m_size */ + #endif + __pyx_methods /* m_methods */, + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_moduledef_slots, /* m_slots */ + #else + NULL, /* m_reload */ + #endif + #if CYTHON_USE_MODULE_STATE + __pyx_m_traverse, /* m_traverse */ + __pyx_m_clear, /* m_clear */ + NULL /* m_free */ + #else + NULL, /* m_traverse */ + NULL, /* m_clear */ + NULL /* m_free */ + #endif + }; + #ifdef __cplusplus +} /* anonymous namespace */ +#endif + +/* PyModInitFuncType */ +#ifndef CYTHON_NO_PYINIT_EXPORT + #define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC +#else + #ifdef __cplusplus + #define __Pyx_PyMODINIT_FUNC extern "C" PyObject * + #else + #define __Pyx_PyMODINIT_FUNC PyObject * + #endif +#endif + +__Pyx_PyMODINIT_FUNC PyInit_cssm(void) CYTHON_SMALL_CODE; /*proto*/ +__Pyx_PyMODINIT_FUNC PyInit_cssm(void) +#if CYTHON_PEP489_MULTI_PHASE_INIT +{ + return PyModuleDef_Init(&__pyx_moduledef); +} +/* ModuleCreationPEP489 */ +#if CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\ + || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000)) +static PY_INT64_T __Pyx_GetCurrentInterpreterId(void) { + { + PyObject *module = PyImport_ImportModule("_interpreters"); // 3.13+ I think + if (!module) { + PyErr_Clear(); // just try the 3.8-3.12 version + module = PyImport_ImportModule("_xxsubinterpreters"); + if (!module) goto bad; + } + PyObject *current = PyObject_CallMethod(module, "get_current", NULL); + Py_DECREF(module); + if (!current) goto bad; + if (PyTuple_Check(current)) { + PyObject *new_current = PySequence_GetItem(current, 0); + Py_DECREF(current); + current = new_current; + if (!new_current) goto bad; + } + long long as_c_int = PyLong_AsLongLong(current); + Py_DECREF(current); + return as_c_int; + } + bad: + PySys_WriteStderr("__Pyx_GetCurrentInterpreterId failed. Try setting the C define CYTHON_PEP489_MULTI_PHASE_INIT=0\n"); + return -1; +} +#endif +#if !CYTHON_USE_MODULE_STATE +static CYTHON_SMALL_CODE int __Pyx_check_single_interpreter(void) { + static PY_INT64_T main_interpreter_id = -1; +#if CYTHON_COMPILING_IN_GRAAL && defined(GRAALPY_VERSION_NUM) && GRAALPY_VERSION_NUM > 0x19000000 + PY_INT64_T current_id = GraalPyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_GRAAL + PY_INT64_T current_id = PyInterpreterState_GetIDFromThreadState(PyThreadState_Get()); +#elif CYTHON_COMPILING_IN_LIMITED_API && (__PYX_LIMITED_VERSION_HEX < 0x03090000\ + || ((defined(_WIN32) || defined(WIN32) || defined(MS_WINDOWS)) && __PYX_LIMITED_VERSION_HEX < 0x030A0000)) + PY_INT64_T current_id = __Pyx_GetCurrentInterpreterId(); +#elif CYTHON_COMPILING_IN_LIMITED_API + PY_INT64_T current_id = PyInterpreterState_GetID(PyInterpreterState_Get()); +#else + PY_INT64_T current_id = PyInterpreterState_GetID(PyThreadState_Get()->interp); +#endif + if (unlikely(current_id == -1)) { + return -1; + } + if (main_interpreter_id == -1) { + main_interpreter_id = current_id; + return 0; + } else if (unlikely(main_interpreter_id != current_id)) { + PyErr_SetString( + PyExc_ImportError, + "Interpreter change detected - this module can only be loaded into one interpreter per process."); + return -1; + } + return 0; +} +#endif +static CYTHON_SMALL_CODE int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name, int allow_none) +{ + PyObject *value = PyObject_GetAttrString(spec, from_name); + int result = 0; + if (likely(value)) { + if (allow_none || value != Py_None) { + result = PyDict_SetItemString(moddict, to_name, value); + } + Py_DECREF(value); + } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) { + PyErr_Clear(); + } else { + result = -1; + } + return result; +} +static CYTHON_SMALL_CODE PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def) { + PyObject *module = NULL, *moddict, *modname; + CYTHON_UNUSED_VAR(def); + #if !CYTHON_USE_MODULE_STATE + if (__Pyx_check_single_interpreter()) + return NULL; + #endif + if (__pyx_m) + return __Pyx_NewRef(__pyx_m); + modname = PyObject_GetAttrString(spec, "name"); + if (unlikely(!modname)) goto bad; + module = PyModule_NewObject(modname); + Py_DECREF(modname); + if (unlikely(!module)) goto bad; + moddict = PyModule_GetDict(module); + if (unlikely(!moddict)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__", 1) < 0)) goto bad; + if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__", 0) < 0)) goto bad; + return module; +bad: + Py_XDECREF(module); + return NULL; +} + + +static CYTHON_SMALL_CODE int __pyx_pymod_exec_cssm(PyObject *__pyx_pyinit_module) +#endif +{ + int stringtab_initialized = 0; + #if CYTHON_USE_MODULE_STATE + int pystate_addmodule_run = 0; + #endif + __pyx_mstatetype *__pyx_mstate = NULL; + PyObject *__pyx_t_1 = NULL; + PyObject *__pyx_t_2 = NULL; + PyObject *__pyx_t_3 = NULL; + PyObject *__pyx_t_4 = NULL; + PyObject *__pyx_t_5 = NULL; + size_t __pyx_t_6; + static PyThread_type_lock __pyx_t_7[8]; + int __pyx_t_8; + PyObject *__pyx_t_9 = NULL; + PyObject *__pyx_t_10 = NULL; + PyObject *__pyx_t_11 = NULL; + int __pyx_lineno = 0; + const char *__pyx_filename = NULL; + int __pyx_clineno = 0; + __Pyx_RefNannyDeclarations + #if CYTHON_PEP489_MULTI_PHASE_INIT + if (__pyx_m) { + if (__pyx_m == __pyx_pyinit_module) return 0; + PyErr_SetString(PyExc_RuntimeError, "Module 'cssm' has already been imported. Re-initialisation is not supported."); + return -1; + } + #else + if (__pyx_m) return __Pyx_NewRef(__pyx_m); + #endif + /*--- Module creation code ---*/ + #if CYTHON_PEP489_MULTI_PHASE_INIT + __pyx_t_1 = __pyx_pyinit_module; + Py_INCREF(__pyx_t_1); + #else + __pyx_t_1 = PyModule_Create(&__pyx_moduledef); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 1, __pyx_L1_error) + #endif + #if CYTHON_USE_MODULE_STATE + { + int add_module_result = __Pyx_State_AddModule(__pyx_t_1, &__pyx_moduledef); + __pyx_t_1 = 0; /* transfer ownership from __pyx_t_1 to "cssm" pseudovariable */ + if (unlikely((add_module_result < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + pystate_addmodule_run = 1; + } + #else + __pyx_m = __pyx_t_1; + #endif + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + PyUnstable_Module_SetGIL(__pyx_m, Py_MOD_GIL_USED); + #endif + __pyx_mstate = __pyx_mstate_global; + CYTHON_UNUSED_VAR(__pyx_t_1); + __pyx_mstate->__pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_mstate->__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error) + Py_INCREF(__pyx_mstate->__pyx_d); + __pyx_mstate->__pyx_b = __Pyx_PyImport_AddModuleRef(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_mstate->__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_cython_runtime = __Pyx_PyImport_AddModuleRef("cython_runtime"); if (unlikely(!__pyx_mstate->__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error) + if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_mstate->__pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error) + /* ImportRefnannyAPI */ + #if CYTHON_REFNANNY + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny"); + if (!__Pyx_RefNanny) { + PyErr_Clear(); + __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny"); + if (!__Pyx_RefNanny) + Py_FatalError("failed to import 'refnanny' module"); + } + #endif + +__Pyx_RefNannySetupContext("PyInit_cssm", 0); + __Pyx_init_runtime_version(); + if (__Pyx_check_binary_version(__PYX_LIMITED_VERSION_HEX, __Pyx_get_runtime_version(), CYTHON_COMPILING_IN_LIMITED_API) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_mstate->__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error) + __pyx_mstate->__pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_mstate->__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Library function declarations ---*/ + /*--- Initialize various global constants etc. ---*/ + if (__Pyx_InitConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + stringtab_initialized = 1; + if (__Pyx_InitGlobals() < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (__pyx_module_is_main_cssm) { + if (PyObject_SetAttr(__pyx_m, __pyx_mstate_global->__pyx_n_u_name_2, __pyx_mstate_global->__pyx_n_u_main) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + } + { + PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error) + if (!PyDict_GetItemString(modules, "cssm")) { + if (unlikely((PyDict_SetItemString(modules, "cssm", __pyx_m) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + /*--- Builtin init code ---*/ + if (__Pyx_InitCachedBuiltins(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Constants init code ---*/ + if (__Pyx_InitCachedConstants(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + if (__Pyx_CreateCodeObjects(__pyx_mstate) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + /*--- Global type/function init code ---*/ + (void)__Pyx_modinit_global_init_code(__pyx_mstate); + (void)__Pyx_modinit_variable_export_code(__pyx_mstate); + (void)__Pyx_modinit_function_export_code(__pyx_mstate); + if (unlikely((__Pyx_modinit_type_init_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + if (unlikely((__Pyx_modinit_type_import_code(__pyx_mstate) < 0))) __PYX_ERR(0, 1, __pyx_L1_error) + (void)__Pyx_modinit_variable_import_code(__pyx_mstate); + (void)__Pyx_modinit_function_import_code(__pyx_mstate); + /*--- Execution code ---*/ + + /* "View.MemoryView":100 + * + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * except: +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "View.MemoryView":101 + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence # <<<<<<<<<<<<<< + * except: + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_collections_abc}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_builtin___import__, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_4); + } + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_abc); if (unlikely(!__pyx_t_5)) __PYX_ERR(1, 101, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_t_5, __pyx_mstate_global->__pyx_n_u_Sequence); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 101, __pyx_L2_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_XGOTREF(__pyx_collections_abc_Sequence); + __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, __pyx_t_4); + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":100 + * + * cdef object __pyx_collections_abc_Sequence "__pyx_collections_abc_Sequence" + * try: # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * except: +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L7_try_end; + __pyx_L2_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":102 + * try: + * __pyx_collections_abc_Sequence = __import__("collections.abc").abc.Sequence + * except: # <<<<<<<<<<<<<< + * + * __pyx_collections_abc_Sequence = None +*/ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + + /* "View.MemoryView":104 + * except: + * + * __pyx_collections_abc_Sequence = None # <<<<<<<<<<<<<< + * + * +*/ + __Pyx_INCREF(Py_None); + __Pyx_XGOTREF(__pyx_collections_abc_Sequence); + __Pyx_DECREF_SET(__pyx_collections_abc_Sequence, Py_None); + __Pyx_GIVEREF(Py_None); + goto __pyx_L3_exception_handled; + } + __pyx_L3_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L7_try_end:; + } + + /* "View.MemoryView":239 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + /*try:*/ { + + /* "View.MemoryView":240 + * + * try: + * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< + * index = __pyx_collections_abc_Sequence.index + * except: +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_mstate_global->__pyx_n_u_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 240, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_array_type, __pyx_mstate_global->__pyx_n_u_count, __pyx_t_4) < (0)) __PYX_ERR(1, 240, __pyx_L10_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":241 + * try: + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< + * except: + * pass +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 241, __pyx_L10_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_array_type, __pyx_mstate_global->__pyx_n_u_index, __pyx_t_4) < (0)) __PYX_ERR(1, 241, __pyx_L10_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":239 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index +*/ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L15_try_end; + __pyx_L10_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":242 + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + * except: # <<<<<<<<<<<<<< + * pass + * +*/ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L11_exception_handled; + } + __pyx_L11_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); + __pyx_L15_try_end:; + } + + /* "View.MemoryView":307 + * return self.name + * + * cdef generic = Enum("") # <<<<<<<<<<<<<< + * cdef strided = Enum("") # default + * cdef indirect = Enum("") +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_strided_and_direct_or_indirect}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 307, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(generic); + __Pyx_DECREF_SET(generic, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":308 + * + * cdef generic = Enum("") + * cdef strided = Enum("") # default # <<<<<<<<<<<<<< + * cdef indirect = Enum("") + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_strided_and_direct}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 308, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(strided); + __Pyx_DECREF_SET(strided, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":309 + * cdef generic = Enum("") + * cdef strided = Enum("") # default + * cdef indirect = Enum("") # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_strided_and_indirect}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 309, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(indirect); + __Pyx_DECREF_SET(indirect, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":312 + * + * + * cdef contiguous = Enum("") # <<<<<<<<<<<<<< + * cdef indirect_contiguous = Enum("") + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_contiguous_and_direct}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 312, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(contiguous); + __Pyx_DECREF_SET(contiguous, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":313 + * + * cdef contiguous = Enum("") + * cdef indirect_contiguous = Enum("") # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_5 = NULL; + __pyx_t_6 = 1; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_mstate_global->__pyx_kp_u_contiguous_and_indirect}; + __pyx_t_4 = __Pyx_PyObject_FastCall((PyObject*)__pyx_mstate_global->__pyx_MemviewEnum_type, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (__pyx_t_6*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 313, __pyx_L1_error) + __Pyx_GOTREF((PyObject *)__pyx_t_4); + } + __Pyx_XGOTREF(indirect_contiguous); + __Pyx_DECREF_SET(indirect_contiguous, ((PyObject *)__pyx_t_4)); + __Pyx_GIVEREF((PyObject *)__pyx_t_4); + __pyx_t_4 = 0; + + /* "View.MemoryView":321 + * + * + * cdef int __pyx_memoryview_thread_locks_used = 0 # <<<<<<<<<<<<<< + * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ + * PyThread_allocate_lock(), +*/ + __pyx_memoryview_thread_locks_used = 0; + + /* "View.MemoryView":322 + * + * cdef int __pyx_memoryview_thread_locks_used = 0 + * cdef PyThread_type_lock[8] __pyx_memoryview_thread_locks = [ # <<<<<<<<<<<<<< + * PyThread_allocate_lock(), + * PyThread_allocate_lock(), +*/ + __pyx_t_7[0] = PyThread_allocate_lock(); + __pyx_t_7[1] = PyThread_allocate_lock(); + __pyx_t_7[2] = PyThread_allocate_lock(); + __pyx_t_7[3] = PyThread_allocate_lock(); + __pyx_t_7[4] = PyThread_allocate_lock(); + __pyx_t_7[5] = PyThread_allocate_lock(); + __pyx_t_7[6] = PyThread_allocate_lock(); + __pyx_t_7[7] = PyThread_allocate_lock(); + memcpy(&(__pyx_memoryview_thread_locks[0]), __pyx_t_7, sizeof(__pyx_memoryview_thread_locks[0]) * (8)); + + /* "View.MemoryView":983 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_1, &__pyx_t_2, &__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_3); + /*try:*/ { + + /* "View.MemoryView":984 + * + * try: + * count = __pyx_collections_abc_Sequence.count # <<<<<<<<<<<<<< + * index = __pyx_collections_abc_Sequence.index + * except: +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_mstate_global->__pyx_n_u_count); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 984, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_memoryviewslice_type, __pyx_mstate_global->__pyx_n_u_count, __pyx_t_4) < (0)) __PYX_ERR(1, 984, __pyx_L18_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":985 + * try: + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index # <<<<<<<<<<<<<< + * except: + * pass +*/ + __pyx_t_4 = __Pyx_PyObject_GetAttrStr(__pyx_collections_abc_Sequence, __pyx_mstate_global->__pyx_n_u_index); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 985, __pyx_L18_error) + __Pyx_GOTREF(__pyx_t_4); + if (__Pyx_SetItemOnTypeDict(__pyx_mstate_global->__pyx_memoryviewslice_type, __pyx_mstate_global->__pyx_n_u_index, __pyx_t_4) < (0)) __PYX_ERR(1, 985, __pyx_L18_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":983 + * + * + * try: # <<<<<<<<<<<<<< + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index +*/ + } + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + goto __pyx_L23_try_end; + __pyx_L18_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":986 + * count = __pyx_collections_abc_Sequence.count + * index = __pyx_collections_abc_Sequence.index + * except: # <<<<<<<<<<<<<< + * pass + * +*/ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L19_exception_handled; + } + __pyx_L19_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_ExceptionReset(__pyx_t_1, __pyx_t_2, __pyx_t_3); + __pyx_L23_try_end:; + } + + /* "View.MemoryView":989 + * pass + * + * try: # <<<<<<<<<<<<<< + * if __pyx_collections_abc_Sequence: + * +*/ + { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + __Pyx_ExceptionSave(&__pyx_t_3, &__pyx_t_2, &__pyx_t_1); + __Pyx_XGOTREF(__pyx_t_3); + __Pyx_XGOTREF(__pyx_t_2); + __Pyx_XGOTREF(__pyx_t_1); + /*try:*/ { + + /* "View.MemoryView":990 + * + * try: + * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< + * + * +*/ + __pyx_t_8 = __Pyx_PyObject_IsTrue(__pyx_collections_abc_Sequence); if (unlikely((__pyx_t_8 < 0))) __PYX_ERR(1, 990, __pyx_L26_error) + if (__pyx_t_8) { + + /* "View.MemoryView":994 + * + * + * __pyx_collections_abc_Sequence.register(_memoryviewslice) # <<<<<<<<<<<<<< + * __pyx_collections_abc_Sequence.register(array) + * except: +*/ + __pyx_t_5 = __pyx_collections_abc_Sequence; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, ((PyObject *)__pyx_mstate_global->__pyx_memoryviewslice_type)}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_register, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 994, __pyx_L26_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":995 + * + * __pyx_collections_abc_Sequence.register(_memoryviewslice) + * __pyx_collections_abc_Sequence.register(array) # <<<<<<<<<<<<<< + * except: + * pass # ignore failure, it's a minor issue +*/ + __pyx_t_5 = __pyx_collections_abc_Sequence; + __Pyx_INCREF(__pyx_t_5); + __pyx_t_6 = 0; + { + PyObject *__pyx_callargs[2] = {__pyx_t_5, ((PyObject *)__pyx_mstate_global->__pyx_array_type)}; + __pyx_t_4 = __Pyx_PyObject_FastCallMethod((PyObject*)__pyx_mstate_global->__pyx_n_u_register, __pyx_callargs+__pyx_t_6, (2-__pyx_t_6) | (1*__Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET)); + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 995, __pyx_L26_error) + __Pyx_GOTREF(__pyx_t_4); + } + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "View.MemoryView":990 + * + * try: + * if __pyx_collections_abc_Sequence: # <<<<<<<<<<<<<< + * + * +*/ + } + + /* "View.MemoryView":989 + * pass + * + * try: # <<<<<<<<<<<<<< + * if __pyx_collections_abc_Sequence: + * +*/ + } + __Pyx_XDECREF(__pyx_t_3); __pyx_t_3 = 0; + __Pyx_XDECREF(__pyx_t_2); __pyx_t_2 = 0; + __Pyx_XDECREF(__pyx_t_1); __pyx_t_1 = 0; + goto __pyx_L31_try_end; + __pyx_L26_error:; + __Pyx_XDECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_XDECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "View.MemoryView":996 + * __pyx_collections_abc_Sequence.register(_memoryviewslice) + * __pyx_collections_abc_Sequence.register(array) + * except: # <<<<<<<<<<<<<< + * pass # ignore failure, it's a minor issue + * +*/ + /*except:*/ { + __Pyx_ErrRestore(0,0,0); + goto __pyx_L27_exception_handled; + } + __pyx_L27_exception_handled:; + __Pyx_XGIVEREF(__pyx_t_3); + __Pyx_XGIVEREF(__pyx_t_2); + __Pyx_XGIVEREF(__pyx_t_1); + __Pyx_ExceptionReset(__pyx_t_3, __pyx_t_2, __pyx_t_1); + __pyx_L31_try_end:; + } + + /* "(tree fragment)":4 + * int __Pyx_CheckUnpickleChecksum(long, long, long, long, const char*) except -1 + * int __Pyx_UpdateUnpickledDict(object, object, Py_ssize_t) except -1 + * def __pyx_unpickle_Enum(__pyx_type, long __pyx_checksum, tuple __pyx_state): # <<<<<<<<<<<<<< + * cdef object __pyx_result + * __Pyx_CheckUnpickleChecksum(__pyx_checksum, 0x82a3537, 0x6ae9995, 0xb068931, b'name') +*/ + __pyx_t_4 = PyCFunction_NewEx(&__pyx_mdef_15View_dot_MemoryView_1__pyx_unpickle_Enum, NULL, __pyx_mstate_global->__pyx_n_u_View_MemoryView); if (unlikely(!__pyx_t_4)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_pyx_unpickle_Enum, __pyx_t_4) < (0)) __PYX_ERR(1, 4, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":13 + * from libc.time cimport time + * + * import numpy as np # <<<<<<<<<<<<<< + * cimport numpy as np + * import numbers +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numpy, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 13, __pyx_L1_error) + __pyx_t_4 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_np, __pyx_t_4) < (0)) __PYX_ERR(0, 13, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":15 + * import numpy as np + * cimport numpy as np + * import numbers # <<<<<<<<<<<<<< + * + * DTYPE = np.float32 +*/ + __pyx_t_1 = __Pyx_Import(__pyx_mstate_global->__pyx_n_u_numbers, 0, 0, NULL, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 15, __pyx_L1_error) + __pyx_t_4 = __pyx_t_1; + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_numbers, __pyx_t_4) < (0)) __PYX_ERR(0, 15, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":17 + * import numbers + * + * DTYPE = np.float32 # <<<<<<<<<<<<<< + * + * cdef set_seed(random_state): +*/ + __Pyx_GetModuleGlobalName(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_np); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __pyx_t_5 = __Pyx_PyObject_GetAttrStr(__pyx_t_4, __pyx_mstate_global->__pyx_n_u_float32); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_DTYPE, __pyx_t_5) < (0)) __PYX_ERR(0, 17, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":196 + * np.ndarray[float, ndim = 1] deadline, # = 0.0, + * np.ndarray[float, ndim = 1] s, # = 1, + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_5 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 196, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "cssm.pyx":197 + * np.ndarray[float, ndim = 1] s, # = 1, + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_4 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 197, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":198 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * random_state = None, +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 198, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "cssm.pyx":199 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * random_state = None, + * smooth_unif = False, +*/ + __pyx_t_10 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 199, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "cssm.pyx":187 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm_hddm_base(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + __pyx_t_11 = PyTuple_Pack(7, __pyx_t_5, __pyx_t_4, __pyx_t_9, __pyx_t_10, Py_None, ((PyObject*)Py_False), ((PyObject*)__pyx_mstate_global->__pyx_n_u_full)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_1full_ddm_hddm_base, 0, __pyx_mstate_global->__pyx_n_u_full_ddm_hddm_base, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[0])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_10); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_10, __pyx_t_11); + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_full_ddm_hddm_base, __pyx_t_10) < (0)) __PYX_ERR(0, 187, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "cssm.pyx":375 + * np.ndarray[float, ndim = 1] s, # noise sigma + * max_t = 20, # maximum rt allowed + * float delta_t = 0.001, # timesteps fraction of seconds # <<<<<<<<<<<<<< + * int n_samples = 20000, # number of samples considered + * int n_trials = 10, +*/ + __pyx_t_10 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 375, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "cssm.pyx":376 + * max_t = 20, # maximum rt allowed + * float delta_t = 0.001, # timesteps fraction of seconds + * int n_samples = 20000, # number of samples considered # <<<<<<<<<<<<<< + * int n_trials = 10, + * random_state = None, +*/ + __pyx_t_11 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 376, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + + /* "cssm.pyx":377 + * float delta_t = 0.001, # timesteps fraction of seconds + * int n_samples = 20000, # number of samples considered + * int n_trials = 10, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', # 'full' or 'minimal' +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(((int)10)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 377, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "cssm.pyx":368 + * #@cython.wraparound(False) + * + * def ddm(np.ndarray[float, ndim = 1] v, # drift by timestep 'delta_t' # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # boundary separation + * np.ndarray[float, ndim = 1] z, # between 0 and 1 +*/ + __pyx_t_4 = PyTuple_Pack(7, ((PyObject*)__pyx_mstate_global->__pyx_int_20), __pyx_t_10, __pyx_t_11, __pyx_t_9, Py_None, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full), ((PyObject*)Py_False)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_3ddm, 0, __pyx_mstate_global->__pyx_n_u_ddm, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[1])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm, __pyx_t_9) < (0)) __PYX_ERR(0, 368, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":515 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_5ddm_flexbound, 0, __pyx_mstate_global->__pyx_n_u_ddm_flexbound, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[2])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 515, __pyx_L1_error) + + /* "cssm.pyx":527 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 527, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_48__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_flexbound, __pyx_t_9) < (0)) __PYX_ERR(0, 515, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":682 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flex(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_7ddm_flex, 0, __pyx_mstate_global->__pyx_n_u_ddm_flex, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[3])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 682, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults1)) __PYX_ERR(0, 682, __pyx_L1_error) + + /* "cssm.pyx":695 + * drift_fun = None, + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * drift_params = {}, + * random_state = None, +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 695, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + + /* "cssm.pyx":696 + * boundary_multiplicative = True, + * boundary_params = {}, + * drift_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 696, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults1, __pyx_t_9)->arg1 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_50__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_flex, __pyx_t_9) < (0)) __PYX_ERR(0, 682, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":864 + * # @cythonwraparound(False) + * + * def levy_flexbound(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_9levy_flexbound, 0, __pyx_mstate_global->__pyx_n_u_levy_flexbound, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[4])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 864, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 864, __pyx_L1_error) + + /* "cssm.pyx":877 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 877, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_52__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_levy_flexbound, __pyx_t_9) < (0)) __PYX_ERR(0, 864, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":1027 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm_rv(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_11full_ddm_rv, 0, __pyx_mstate_global->__pyx_n_u_full_ddm_rv, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[5])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1027, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 1027, __pyx_L1_error) + + /* "cssm.pyx":1042 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1042, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_54__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_full_ddm_rv, __pyx_t_9) < (0)) __PYX_ERR(0, 1027, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":1233 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def full_ddm(np.ndarray[float, ndim = 1] v, # = 0, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # = 1, + * np.ndarray[float, ndim = 1] z, # = 0.5, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_13full_ddm, 0, __pyx_mstate_global->__pyx_n_u_full_ddm, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[6])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1233, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 1233, __pyx_L1_error) + + /* "cssm.pyx":1248 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1248, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_56__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_full_ddm, __pyx_t_9) < (0)) __PYX_ERR(0, 1233, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":1430 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_sdv(np.ndarray[float, ndim = 1] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, + * np.ndarray[float, ndim = 1] z, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_15ddm_sdv, 0, __pyx_mstate_global->__pyx_n_u_ddm_sdv, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[7])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1430, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 1430, __pyx_L1_error) + + /* "cssm.pyx":1443 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1443, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_58__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_sdv, __pyx_t_9) < (0)) __PYX_ERR(0, 1430, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":1611 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ornstein_uhlenbeck(np.ndarray[float, ndim = 1] v, # drift parameter # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] a, # initial boundary separation + * np.ndarray[float, ndim = 1] z, # starting point bias +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_17ornstein_uhlenbeck, 0, __pyx_mstate_global->__pyx_n_u_ornstein_uhlenbeck, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[8])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1611, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 1611, __pyx_L1_error) + + /* "cssm.pyx":1624 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_60__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ornstein_uhlenbeck, __pyx_t_9) < (0)) __PYX_ERR(0, 1611, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":1819 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def race_model(np.ndarray[float, ndim = 2] v, # np.array expected, one column of floats # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # initial boundary separation + * np.ndarray[float, ndim = 2] z, # np.array expected, one column of floats +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_19race_model, 0, __pyx_mstate_global->__pyx_n_u_race_model, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[9])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 1819, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 1819, __pyx_L1_error) + + /* "cssm.pyx":1831 + * boundary_fun = None, + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1831, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_62__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_race_model, __pyx_t_9) < (0)) __PYX_ERR(0, 1819, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":2008 + * + * # Simulate (rt, choice) tuples from: Leaky Competing Accumulator Model ----------------------------- + * def lca(np.ndarray[float, ndim = 2] v, # drift parameters (np.array expect: one column of floats) # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # criterion height + * np.ndarray[float, ndim = 2] z, # initial bias parameters (np.array expect: one column of floats) +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_21lca, 0, __pyx_mstate_global->__pyx_n_u_lca, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[10])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2008, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 2008, __pyx_L1_error) + + /* "cssm.pyx":2022 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2022, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_64__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_lca, __pyx_t_9) < (0)) __PYX_ERR(0, 2008, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":2229 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_seq2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_23ddm_flexbound_seq2, 0, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_seq2, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[11])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2229, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 2229, __pyx_L1_error) + + /* "cssm.pyx":2246 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_66__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_seq2, __pyx_t_9) < (0)) __PYX_ERR(0, 2229, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":2543 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_par2(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_25ddm_flexbound_par2, 0, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_par2, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[12])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2543, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 2543, __pyx_L1_error) + + /* "cssm.pyx":2560 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2560, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_68__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_par2, __pyx_t_9) < (0)) __PYX_ERR(0, 2543, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":2825 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_27ddm_flexbound_mic2_ornstein, 0, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_ornstein, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[13])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 2825, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 2825, __pyx_L1_error) + + /* "cssm.pyx":2845 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 2845, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_70__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_ornstein, __pyx_t_9) < (0)) __PYX_ERR(0, 2825, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":3166 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_29ddm_flexbound_mic2_multinoise, 0, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_multinoise, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[14])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3166, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 3166, __pyx_L1_error) + + /* "cssm.pyx":3184 + * boundary_fun = None, + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3184, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_72__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_multinoise, __pyx_t_9) < (0)) __PYX_ERR(0, 3166, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":3514 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_31ddm_flexbound_mic2_ornstein_multinoise, 0, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_ornstein_mult, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[15])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3514, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 3514, __pyx_L1_error) + + /* "cssm.pyx":3533 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3533, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_74__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_ornstein_mult, __pyx_t_9) < (0)) __PYX_ERR(0, 3514, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":3863 + * np.ndarray[float, ndim = 2] sd, # noise sigma + * np.ndarray[float, ndim = 1] t, # non-decision time + * int nact = 3, # <<<<<<<<<<<<<< + * int n_samples = 2000, + * int n_trials = 1, +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(((int)3)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3863, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "cssm.pyx":3864 + * np.ndarray[float, ndim = 1] t, # non-decision time + * int nact = 3, + * int n_samples = 2000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * float max_t = 20, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)0x7D0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3864, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":3865 + * int nact = 3, + * int n_samples = 2000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * float max_t = 20, + * **kwargs +*/ + __pyx_t_11 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3865, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + + /* "cssm.pyx":3866 + * int n_samples = 2000, + * int n_trials = 1, + * float max_t = 20, # <<<<<<<<<<<<<< + * **kwargs + * ): +*/ + __pyx_t_10 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3866, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "cssm.pyx":3857 + * + * # Simulate (rt, choice) tuples from: Vanilla LBA Model without ndt ----------------------------- + * def lba_vanilla(np.ndarray[float, ndim = 2] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, + * np.ndarray[float, ndim = 2] z, +*/ + __pyx_t_5 = PyTuple_Pack(4, __pyx_t_9, __pyx_t_4, __pyx_t_11, __pyx_t_10); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3857, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_33lba_vanilla, 0, __pyx_mstate_global->__pyx_n_u_lba_vanilla, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[16])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3857, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_10); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_10, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_lba_vanilla, __pyx_t_10) < (0)) __PYX_ERR(0, 3857, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "cssm.pyx":3965 + * np.ndarray[float, ndim = 2] sd, # noise sigma + * np.ndarray[float, ndim = 1] t, # non-decision time + * int nact = 3, # <<<<<<<<<<<<<< + * int n_samples = 2000, + * int n_trials = 1, +*/ + __pyx_t_10 = __Pyx_PyLong_From_int(((int)3)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 3965, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "cssm.pyx":3966 + * np.ndarray[float, ndim = 1] t, # non-decision time + * int nact = 3, + * int n_samples = 2000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * float max_t = 20, +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(((int)0x7D0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 3966, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "cssm.pyx":3967 + * int nact = 3, + * int n_samples = 2000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * float max_t = 20, + * **kwargs +*/ + __pyx_t_11 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 3967, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + + /* "cssm.pyx":3968 + * int n_samples = 2000, + * int n_trials = 1, + * float max_t = 20, # <<<<<<<<<<<<<< + * **kwargs + * ): +*/ + __pyx_t_4 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3968, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":3958 + * + * # Simulate (rt, choice) tuples from: Collapsing bound angle LBA Model ----------------------------- + * def lba_angle(np.ndarray[float, ndim = 2] v, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, + * np.ndarray[float, ndim = 2] z, +*/ + __pyx_t_9 = PyTuple_Pack(4, __pyx_t_10, __pyx_t_5, __pyx_t_11, __pyx_t_4); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 3958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_35lba_angle, 0, __pyx_mstate_global->__pyx_n_u_lba_angle, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[17])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 3958, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_lba_angle, __pyx_t_4) < (0)) __PYX_ERR(0, 3958, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":4070 + * np.ndarray[float, ndim = 2] sd, # std dev + * np.ndarray[float, ndim = 1] t, # ndt is supposed to be 0 by default because of parameter identifiability issues + * int nact = 3, # <<<<<<<<<<<<<< + * int n_samples = 2000, + * int n_trials = 1, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)3)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4070, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":4071 + * np.ndarray[float, ndim = 1] t, # ndt is supposed to be 0 by default because of parameter identifiability issues + * int nact = 3, + * int n_samples = 2000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * float max_t = 20, +*/ + __pyx_t_9 = __Pyx_PyLong_From_int(((int)0x7D0)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4071, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "cssm.pyx":4072 + * int nact = 3, + * int n_samples = 2000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * float max_t = 20, + * **kwargs +*/ + __pyx_t_11 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4072, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + + /* "cssm.pyx":4073 + * int n_samples = 2000, + * int n_trials = 1, + * float max_t = 20, # <<<<<<<<<<<<<< + * **kwargs + * ): +*/ + __pyx_t_5 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4073, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "cssm.pyx":4062 + * + * # Simulate (rt, choice) tuples from LBA piece-wise model ----------------------------- + * def rlwm_lba_pw_v1(np.ndarray[float, ndim = 2] v_RL, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] v_WM, + * np.ndarray[float, ndim = 2] a, +*/ + __pyx_t_10 = PyTuple_Pack(4, __pyx_t_4, __pyx_t_9, __pyx_t_11, __pyx_t_5); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __pyx_t_5 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_37rlwm_lba_pw_v1, 0, __pyx_mstate_global->__pyx_n_u_rlwm_lba_pw_v1, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[18])); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4062, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_5); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_5, __pyx_t_10); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_rlwm_lba_pw_v1, __pyx_t_5) < (0)) __PYX_ERR(0, 4062, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + + /* "cssm.pyx":4152 + * np.ndarray[float, ndim = 2] sd, # noise sigma + * np.ndarray[float, ndim = 1] t, # non-decision time + * int nact = 3, # <<<<<<<<<<<<<< + * int n_samples = 2000, + * int n_trials = 1, +*/ + __pyx_t_5 = __Pyx_PyLong_From_int(((int)3)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4152, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "cssm.pyx":4153 + * np.ndarray[float, ndim = 1] t, # non-decision time + * int nact = 3, + * int n_samples = 2000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * float max_t = 20, +*/ + __pyx_t_10 = __Pyx_PyLong_From_int(((int)0x7D0)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4153, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "cssm.pyx":4154 + * int nact = 3, + * int n_samples = 2000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * float max_t = 20, + * **kwargs +*/ + __pyx_t_11 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4154, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + + /* "cssm.pyx":4155 + * int n_samples = 2000, + * int n_trials = 1, + * float max_t = 20, # <<<<<<<<<<<<<< + * **kwargs + * ): +*/ + __pyx_t_9 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4155, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "cssm.pyx":4145 + * + * # Simulate (rt, choice) tuples from: RLWM LBA Race Model without ndt ----------------------------- + * def rlwm_lba_race(np.ndarray[float, ndim = 2] v_RL, # RL drift parameters (np.array expect: one column of floats) # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] v_WM, # WM drift parameters (np.array expect: one column of floats) + * np.ndarray[float, ndim = 2] a, # criterion height +*/ + __pyx_t_4 = PyTuple_Pack(4, __pyx_t_5, __pyx_t_10, __pyx_t_11, __pyx_t_9); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_39rlwm_lba_race, 0, __pyx_mstate_global->__pyx_n_u_rlwm_lba_race, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[19])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4145, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_9, __pyx_t_4); + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_rlwm_lba_race, __pyx_t_9) < (0)) __PYX_ERR(0, 4145, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":4263 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_mic2_unnormalized_ornstein_multinoise(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_41ddm_flexbound_mic2_unnormalized_ornstein_multinoise, 0, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_unnormalized, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[20])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4263, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 4263, __pyx_L1_error) + + /* "cssm.pyx":4282 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4282, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_76__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_mic2_unnormalized, __pyx_t_9) < (0)) __PYX_ERR(0, 4263, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":4606 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def ddm_flexbound_tradeoff(np.ndarray[float, ndim = 1] vh, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 1] vl1, + * np.ndarray[float, ndim = 1] vl2, +*/ + __pyx_t_9 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_43ddm_flexbound_tradeoff, 0, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_tradeoff, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[21])); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4606, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_9); + #endif + if (!__Pyx_CyFunction_InitDefaults(__pyx_t_9, __pyx_mstate_global->__pyx_ptype_4cssm___pyx_defaults)) __PYX_ERR(0, 4606, __pyx_L1_error) + + /* "cssm.pyx":4624 + * boundary_fun = None, # function of t (and potentially other parameters) that takes in (t, *args) + * boundary_multiplicative = True, + * boundary_params = {}, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4624, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + __Pyx_CyFunction_Defaults(struct __pyx_defaults, __pyx_t_9)->arg0 = __pyx_t_4; + __Pyx_GIVEREF(__pyx_t_4); + __pyx_t_4 = 0; + __Pyx_CyFunction_SetDefaultsGetter(__pyx_t_9, __pyx_pf_4cssm_78__defaults__); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_ddm_flexbound_tradeoff, __pyx_t_9) < (0)) __PYX_ERR(0, 4606, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + + /* "cssm.pyx":4884 + * np.ndarray[float, ndim = 2] tau, + * np.ndarray[float, ndim = 1] p, # choice probability + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_9 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 4884, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + + /* "cssm.pyx":4885 + * np.ndarray[float, ndim = 1] p, # choice probability + * float delta_t = 0.001, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * random_state = None, +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 4885, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":4886 + * float delta_t = 0.001, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_11 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 4886, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + + /* "cssm.pyx":4889 + * random_state = None, + * return_option = 'full', + * float max_t = -1, # <<<<<<<<<<<<<< + * race = False, + * **kwargs): +*/ + __pyx_t_10 = PyFloat_FromDouble(((float)-1.0)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4889, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "cssm.pyx":4880 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def exgauss(np.ndarray[float, ndim = 2] mu, # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] sigma, + * np.ndarray[float, ndim = 2] tau, +*/ + __pyx_t_5 = PyTuple_Pack(7, __pyx_t_9, __pyx_t_4, __pyx_t_11, Py_None, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full), __pyx_t_10, ((PyObject*)Py_False)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 4880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __pyx_t_10 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_45exgauss, 0, __pyx_mstate_global->__pyx_n_u_exgauss, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[22])); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 4880, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_10); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_10, __pyx_t_5); + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_exgauss, __pyx_t_10) < (0)) __PYX_ERR(0, 4880, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + + /* "cssm.pyx":5027 + * np.ndarray[float, ndim = 1] p, # choice probability + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, # <<<<<<<<<<<<<< + * float max_t = 20, + * int n_samples = 20000, +*/ + __pyx_t_10 = PyFloat_FromDouble(((double)0.001)); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 5027, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_10); + + /* "cssm.pyx":5028 + * np.ndarray[float, ndim = 1] s, # noise sigma + * float delta_t = 0.001, + * float max_t = 20, # <<<<<<<<<<<<<< + * int n_samples = 20000, + * int n_trials = 1, +*/ + __pyx_t_5 = PyFloat_FromDouble(((float)20.0)); if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 5028, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_5); + + /* "cssm.pyx":5029 + * float delta_t = 0.001, + * float max_t = 20, + * int n_samples = 20000, # <<<<<<<<<<<<<< + * int n_trials = 1, + * random_state = None, +*/ + __pyx_t_11 = __Pyx_PyLong_From_int(((int)0x4E20)); if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 5029, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_11); + + /* "cssm.pyx":5030 + * float max_t = 20, + * int n_samples = 20000, + * int n_trials = 1, # <<<<<<<<<<<<<< + * random_state = None, + * return_option = 'full', +*/ + __pyx_t_4 = __Pyx_PyLong_From_int(((int)1)); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5030, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + + /* "cssm.pyx":5022 + * # @cythonboundscheck(False) + * # @cythonwraparound(False) + * def shifted_wald(np.ndarray[float, ndim = 2] v, # drift rate # <<<<<<<<<<<<<< + * np.ndarray[float, ndim = 2] a, # boundary separation + * np.ndarray[float, ndim = 2] t, # nondecision time +*/ + __pyx_t_9 = PyTuple_Pack(8, __pyx_t_10, __pyx_t_5, __pyx_t_11, __pyx_t_4, Py_None, ((PyObject*)__pyx_mstate_global->__pyx_n_u_full), ((PyObject*)Py_False), ((PyObject*)Py_False)); if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 5022, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_9); + __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0; + __Pyx_DECREF(__pyx_t_5); __pyx_t_5 = 0; + __Pyx_DECREF(__pyx_t_11); __pyx_t_11 = 0; + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + __pyx_t_4 = __Pyx_CyFunction_New(&__pyx_mdef_4cssm_47shifted_wald, 0, __pyx_mstate_global->__pyx_n_u_shifted_wald, NULL, __pyx_mstate_global->__pyx_n_u_cssm, __pyx_mstate_global->__pyx_d, ((PyObject *)__pyx_mstate_global->__pyx_codeobj_tab[23])); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 5022, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030E0000 + PyUnstable_Object_EnableDeferredRefcount(__pyx_t_4); + #endif + __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_4, __pyx_t_9); + __Pyx_DECREF(__pyx_t_9); __pyx_t_9 = 0; + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_shifted_wald, __pyx_t_4) < (0)) __PYX_ERR(0, 5022, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /* "cssm.pyx":1 + * # Globaly settings for cython # <<<<<<<<<<<<<< + * # cython: cdivision=True + * # cython: wraparound=False +*/ + __pyx_t_4 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_GOTREF(__pyx_t_4); + if (PyDict_SetItem(__pyx_mstate_global->__pyx_d, __pyx_mstate_global->__pyx_n_u_test, __pyx_t_4) < (0)) __PYX_ERR(0, 1, __pyx_L1_error) + __Pyx_DECREF(__pyx_t_4); __pyx_t_4 = 0; + + /*--- Wrapped vars code ---*/ + + goto __pyx_L0; + __pyx_L1_error:; + __Pyx_XDECREF(__pyx_t_4); + __Pyx_XDECREF(__pyx_t_5); + __Pyx_XDECREF(__pyx_t_9); + __Pyx_XDECREF(__pyx_t_10); + __Pyx_XDECREF(__pyx_t_11); + if (__pyx_m) { + if (__pyx_mstate->__pyx_d && stringtab_initialized) { + __Pyx_AddTraceback("init cssm", __pyx_clineno, __pyx_lineno, __pyx_filename); + } + #if !CYTHON_USE_MODULE_STATE + Py_CLEAR(__pyx_m); + #else + Py_DECREF(__pyx_m); + if (pystate_addmodule_run) { + PyObject *tp, *value, *tb; + PyErr_Fetch(&tp, &value, &tb); + PyState_RemoveModule(&__pyx_moduledef); + PyErr_Restore(tp, value, tb); + } + #endif + } else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_ImportError, "init cssm"); + } + __pyx_L0:; + __Pyx_RefNannyFinishContext(); + #if CYTHON_PEP489_MULTI_PHASE_INIT + return (__pyx_m != NULL) ? 0 : -1; + #else + return __pyx_m; + #endif +} +/* #### Code section: pystring_table ### */ +/* #### Code section: cached_builtins ### */ + +static int __Pyx_InitCachedBuiltins(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + __pyx_builtin___import__ = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_import); if (!__pyx_builtin___import__) __PYX_ERR(1, 101, __pyx_L1_error) + __pyx_builtin_enumerate = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_enumerate); if (!__pyx_builtin_enumerate) __PYX_ERR(1, 157, __pyx_L1_error) + __pyx_builtin_Ellipsis = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_Ellipsis); if (!__pyx_builtin_Ellipsis) __PYX_ERR(1, 409, __pyx_L1_error) + __pyx_builtin_id = __Pyx_GetBuiltinName(__pyx_mstate->__pyx_n_u_id); if (!__pyx_builtin_id) __PYX_ERR(1, 619, __pyx_L1_error) + + /* Cached unbound methods */ + __pyx_mstate->__pyx_umethod_PyDict_Type_items.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_items.method_name = &__pyx_mstate->__pyx_n_u_items; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_pop.method_name = &__pyx_mstate->__pyx_n_u_pop; + __pyx_mstate->__pyx_umethod_PyDict_Type_values.type = (PyObject*)&PyDict_Type; + __pyx_mstate->__pyx_umethod_PyDict_Type_values.method_name = &__pyx_mstate->__pyx_n_u_values; + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cached_constants ### */ + +static int __Pyx_InitCachedConstants(__pyx_mstatetype *__pyx_mstate) { + __Pyx_RefNannyDeclarations + CYTHON_UNUSED_VAR(__pyx_mstate); + __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0); + + /* "(tree fragment)":11 + * use_setstate = True + * else: + * use_setstate = ('self.name is not None',) # <<<<<<<<<<<<<< + * if use_setstate: + * return __pyx_unpickle_Enum, (type(self), 0x82a3537, None), state +*/ + __pyx_mstate_global->__pyx_tuple[0] = PyTuple_Pack(1, __pyx_mstate_global->__pyx_kp_u_self_name_is_not_None); if (unlikely(!__pyx_mstate_global->__pyx_tuple[0])) __PYX_ERR(1, 11, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[0]); + + /* "View.MemoryView":583 + * def suboffsets(self): + * if self.view.suboffsets == NULL: + * return (-1,) * self.view.ndim # <<<<<<<<<<<<<< + * + * return tuple([suboffset for suboffset in self.view.suboffsets[:self.view.ndim]]) +*/ + __pyx_mstate_global->__pyx_tuple[1] = PyTuple_New(1); if (unlikely(!__pyx_mstate_global->__pyx_tuple[1])) __PYX_ERR(1, 583, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[1]); + __Pyx_INCREF(__pyx_mstate_global->__pyx_int_neg_1); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_int_neg_1); + if (__Pyx_PyTuple_SET_ITEM(__pyx_mstate_global->__pyx_tuple[1], 0, __pyx_mstate_global->__pyx_int_neg_1) != (0)) __PYX_ERR(1, 583, __pyx_L1_error); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[1]); + + /* "View.MemoryView":680 + * tup = index if isinstance(index, tuple) else (index,) + * + * result = [slice(None)] * ndim # <<<<<<<<<<<<<< + * have_slices = False + * seen_ellipsis = False +*/ + __pyx_mstate_global->__pyx_slice[0] = PySlice_New(Py_None, Py_None, Py_None); if (unlikely(!__pyx_mstate_global->__pyx_slice[0])) __PYX_ERR(1, 680, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_slice[0]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_slice[0]); + + /* "cssm.pyx":246 + * # Data-structs for trajectory storage + * traj = np.zeros((int(max_t / delta_t) + 1, 1), dtype = DTYPE) + * traj[:, :] = -999 # <<<<<<<<<<<<<< + * cdef float[:, :] traj_view = traj + * +*/ + __pyx_mstate_global->__pyx_tuple[2] = PyTuple_Pack(2, __pyx_mstate_global->__pyx_slice[0], __pyx_mstate_global->__pyx_slice[0]); if (unlikely(!__pyx_mstate_global->__pyx_tuple[2])) __PYX_ERR(0, 246, __pyx_L1_error) + __Pyx_GOTREF(__pyx_mstate_global->__pyx_tuple[2]); + __Pyx_GIVEREF(__pyx_mstate_global->__pyx_tuple[2]); + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_tuple; + for (Py_ssize_t i=0; i<3; ++i) { + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL); + #else + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_slice; + for (Py_ssize_t i=0; i<1; ++i) { + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL); + #else + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + __Pyx_RefNannyFinishContext(); + return 0; + __pyx_L1_error:; + __Pyx_RefNannyFinishContext(); + return -1; +} +/* #### Code section: init_constants ### */ + +static int __Pyx_InitConstants(__pyx_mstatetype *__pyx_mstate) { + CYTHON_UNUSED_VAR(__pyx_mstate); + { + const struct { const unsigned int length: 12; } index[] = {{2},{68},{35},{54},{37},{60},{24},{52},{26},{34},{29},{33},{45},{22},{15},{179},{37},{30},{59},{32},{1},{1},{1},{1},{1},{8},{5},{6},{15},{23},{25},{7},{6},{2},{6},{35},{9},{30},{50},{39},{34},{8},{48},{41},{21},{12},{20},{32},{22},{30},{37},{5},{5},{8},{8},{20},{8},{1},{15},{1},{6},{3},{3},{3},{15},{5},{19},{10},{6},{6},{6},{7},{6},{18},{1},{6},{4},{10},{13},{18},{13},{18},{15},{8},{12},{17},{23},{15},{19},{13},{1},{10},{7},{11},{12},{9},{17},{18},{8},{5},{4},{1},{6},{3},{8},{13},{22},{29},{27},{38},{51},{18},{18},{22},{7},{8},{12},{13},{14},{11},{7},{13},{12},{8},{5},{9},{14},{15},{12},{16},{10},{5},{15},{5},{6},{9},{5},{7},{12},{10},{11},{5},{7},{6},{7},{4},{8},{18},{11},{8},{1},{6},{15},{12},{1},{2},{10},{5},{4},{13},{5},{8},{2},{3},{7},{3},{7},{4},{6},{1},{1},{3},{4},{6},{9},{11},{3},{14},{1},{8},{5},{7},{8},{3},{7},{4},{10},{2},{6},{8},{1},{9},{11},{9},{8},{4},{4},{8},{4},{7},{11},{6},{2},{9},{9},{7},{5},{3},{18},{1},{6},{4},{9},{21},{26},{13},{14},{3},{16},{10},{14},{11},{10},{19},{14},{12},{4},{10},{6},{12},{10},{10},{17},{13},{8},{6},{13},{14},{13},{3},{13},{6},{3},{8},{13},{7},{12},{8},{1},{23},{28},{6},{2},{7},{12},{10},{12},{19},{5},{12},{17},{5},{9},{4},{9},{4},{8},{11},{4},{7},{12},{2},{13},{18},{7},{5},{4},{4},{6},{2},{13},{18},{7},{2},{13},{18},{7},{1},{4},{9},{6},{3},{3},{4},{4},{5},{10},{11},{11},{3},{5},{6},{3},{3},{7},{8},{5},{10},{11},{4},{9},{10},{7},{6},{6},{1},{2},{4},{5},{9},{4},{5},{9},{6},{6},{3},{4},{4},{6},{6},{2},{7},{3},{8},{3},{8},{2},{5},{5},{1},{3},{6},{6},{1},{3},{3},{4},{4},{1},{6},{6},{6},{5},{2},{7},{3},{8},{3},{8},{2},{2261},{2214},{2221},{747},{964},{931},{2220},{1539},{1164},{1160},{984},{1025},{987},{1081},{1183},{1105},{887},{554},{398},{424},{551},{1276},{1758},{2057},{1}}; + #if (CYTHON_COMPRESS_STRINGS) == 2 /* compression: bz2 (7737 bytes) */ +const char* const cstring = "BZh91AY&SY\305\373(d\000\024k\177\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\377\300@@@@@@@@@@@@\000@\000`&\\_c\355\215<\2229\033\233\232\212s}\253u\345\273l}\274{<\207n\343{\261\351\343\254\236\337#D\372\324\222\202\004P\000=\333\256\336\343B\244\247y\364\225{\016\234\250\241B\224\n\240(\032\001\240r\346\2648\006\336\r]\357c\325}\232xI!\010\020b\r3$\332&\231#\301&ML\2326\223\324\364\324\311\352dbhh=M\000\r\000\000\032\000\000$\210\002\004\002\n\236d\315LSjiO\332F\251\340\215G\351A\243OP\365\017Q\246\200m@\000\031\032\r\r\r\r4\001\251\350ML\221OQ\352i\211\223@\014C\010\323!\240\000\0002\000\310\032hh2\006 \000\032h\000\205!\"B\223z\247\251\210\003@4\006\215=5\r='\250\323#\315Sjz\231= <\243@\r\000\036\240z\200hz\217D\004R\211\036\247\247\246\223F\202\t\225?j\247\250\374\224\366\2504\361?RcT\363TmG\250\362\200\364\207\352\207\224\320\031\036\324\322~\242dh\032\000\323\311\000T\220\205\021\246\214\221#\3114\003\336\352\311\326;\223\337\330\370\2769\021>BG\313\021\363\023\347!\364\017\331\225\303\006e\022\364\230\031\201\010I\301-\246\372\023N\267\300\r1\311\\\272\006@\340\257Z\r\204,\223k\240Nl \332\222\260\353M\230Z\272\023\207\013[\367mc\220\304/\324?\247\372\336\317?\344\366\317s?\303\221,Lb8\221\306\242\\#\221\311\201\365}\337z\373\361\337}\345\375]\335\324F\351#l\215\330\215\320n\244\335C\351\375\312T\025A+\010CKM@SL\322\314\0225\004\010D\244\314B\241,\224 EB\302\022)D\310\223CI\003\022\224\nP\025(\324!P5US\244Ps\242\310\222\326\205u\035UA8+\303\207,b\231:d\310\304\014v\031\000pFa\320\203\361CAp\311`7\"I\221\242H\202\026\217\244\030ww@B\206\355\205\251:\005\007\035!T)\320\231\"\256\206\337I\327O\323\265\017\211\360>5\344\360\262\312\325\217\206\276\273\300i\314!\221\235n\242tq#\371'\333\r\035""\t(Z\216\214\205\306\210\303A\200\003R\241\250_@\007P\254\235JQN\262\205\202\024*\331\261}\2444\322\341f\221y\223\361z\240;!\020\247@\364t\032\355p\355\325\301\016h\3507d\224R\367\013\277\335\373\3210\317\216\242q\222l \363^'::\215\302\250\255\322+\253\026%\224/\322\351\310\230\213\201\306S\3423b\034H\026\370\246\315\002\320H\034\372\314!j\241\200%\232B\314\314\016\007\260#\223E\241qb\215\256\342\014@11#h\332\374\235\0375\343\033Cp:5\027-\021\270m\006\324M\251a\214\374<\233w\263\0030\005\366\264(X\026\017\253\324\354\357s\364\353\032l\261\312\206l\306C\206&\324s\tr\\6X*U\014\222\330\034\000\207*\360\366\213*\010l\316\204r\032\213\346\032\302`bY\025C\301\013/\235f\202\272d\260\346\356\327\325I\235mD~\342\013\377~\363\237p\006eN\000.\010W9\204\034\302=\335\314m\2336\243\207\347\233\260\315\272\356}Y\253N\253V[^\304\253\005\350\221BQ5\0248\214\r\334\001\036z.\200\335\024\271\035\325\271\007\205-\261-\004w\221w\220\330\241[\275w\264\021\240\027Q#\243Q\t\004\232\360]\220\277t.\366\033\r\373\353F\016`\233\r\271\210=&\240\354/@AVqvpq\322\235\010`\007b\343\332\353\276m\326dhe|D\323\006W\251\271\3257+\246}\377\243\334\313\035Z:hmB\035$\033\001\260S>T\306\251p&0\010\323ZV-b5\241P\032\353Qx'\261\317\233nH\022$\262B\333\001,BKPT\"\240\024\020S\300\255Pdz\355k ,\001Jx\246\211\240'5\317:W4\026\333d\005\220\225\221A\005Of\251 \220HQ5\240\366\227\333\301u\321y\275\273\205\330\276H'z\024F\210T\337\353\033\321S\220\362\207t\303\356V\243\212\024jj\002\360\352\354\031\312\366\323\240=\355\366H6AC\270\023\022f\213y\315\010\367\373\030\000)\013\256[\256\314\217A\336\307\315\227(\033\231T2\252e\024\014\250\230\305n\004\271\016w&\320)}\342\3545\324B\216`\270\030\231\342@\361hN\266oV\374J\035\t\321Z\333\244\222\210\310S\010\3154\340H\375\252\314\2114\322j\324\024dI1\265|\031\232A\2402\204\232\r!\260t\243\244\235#h\230\361=\317\017[\305\363\337\327\237\030.4P\306\253\214P\306\2115w@\306\006\340dC?\356\333\027\217%\266\240Z\201h%\242\005\252\232N\331\357t~\316""\352\014\220\222\022$JHn\206To\002\363<\220d\210II\004\244\222=x\206+qq\"\341{\205\212\005\0228ttt^\213*$\2277\317\230\226\276{\366\247\205`\r0\371\351\241\030+\260,\032\200UU@\313 (\320\244Z%\200\233H6p\375?\336\315S9\223m\r\247\032lW\360\317\037\354\376\271\323\372\366:\001\\.lGHi\327\310F\3776\032\360\000\276\363\263\356\337\021\010\304\301!\320\013\220\270\310E\322\021\242\014\0034#\212\341\232\3560g\020\3008\216!\3105D\030\002X8\237\010\030\275BF3\305\246\2234\247G-6\212*V\373'Z$\356\220p\325\243\244\r\246\241<\010\010\031D\313R\305U,\026\210L\n5&\221h\330\034\204Uc\"c\212i\246\335\253Dh$\216\351\321\025\020\024H\252E\321\220\031\tAC\356j1\320\030\226\032T\200|\226\200\037O-\252\243h\010Z\213`\245\2006\253n\021\336B\3051P\023@9!=\250\036\033KT\265mU4\005\347\315$0\2616\022\2040\240\036\014\350\262I\022BI\272n\272\251\267'\301\023\244)N\236\335\320\333$}\233V\334\206\336\3343FJ\0230\201\375\244$\"n-\202\273\001ukX\025\213q\376\332\003\013j\030F\003$\\\025\313\227@\254yh[(\017T\n\210)\367R\344\022\251HM\t\3107P\240$\260\021\204\256\030\237\357a\304\242RS\017K\245Z\205s\377ULh\010O\356P\t\256\253\256\227\002T&S\020\345]\303|\377\005\311\227@\230\213\340\016|\271q\210\030\r\345>\003nT\033\302_\273\200&\026\306\327\003\373+\235\007339\317D]w\"\0170\267/\245\333\240Q\223\212O\245)\332 \365\217\325\204Fk\343\225#J\311\367\207\312\377V\364\220F\324+-K\3375@\224\021\253\376\346\211Q\250\250 \026\000_\023A\212I\0038P\321E\210,\206\301`\223u\n\253@\356\212\323\016\3571\244\200\232W\321\010\250\240\301\314\243\007b]\311\001\217}\315\225C\263\321\310\r,\246\324\206\032\235\3365\240I[)\020\221x\222,\324!\034\233\3623\215\242\212\265\236#\006\223\203\356\373\332\177^\237\302c\253\r\037<\334\373Z\265Ot\336\337_~Xl\331H\rA\215z\341\247\333\341\272S\276\275s\204!\277Y\351\360\360\360;\373x\236\361\366\210\210d)\320\214\242OG4\272\031\014\206\033W\226\243\225\307\315\010\\v\027>\372a\256\266\n\240\030~\310,;\t\366\026\373\327\312\273&\260;\331|f\311\205\376\374\010v\224\330l\234I""\354:\331\341\347~\032\360\325?\361k\262\334\215(\202\201\267\345zd\203H#\013\314>h\334\260r#g\016\347\307.}\032\202-\275)\013_9\276|\201\177Fo\241\341\201\036\003d\235\266\r\002\230\352M\023\210\337efN\241!\334*3\307\262\341\003\205$\267\304\006D%\276\214\251eK(\267\314\177\320\223b3o\024\350\014\201R\025\001\301J\025\000{$a\206CD\004\020\233@\216dy\007q\304\235b\265\022g\261\032g\305\024n\214I\303\223\261\333\260\026/a\330\345\034\263\021h/\354\313\0007p\365b?``\212\260w\201\177by\267\232\32332,\346\246\352I/\240\222\\\210Z\302\225$J\211T\037*\n%\260\030\246\001\232m\234W\365\221r\316\007ONe\036<\334\251[\250%!3\014\347\212\n\000\314y\246Y\333\241\274c+V\265g\032;s$\202\023\247\375\374\207I%\370\033`S\353C$\213\2143\0312\327\002\205\217 \217\032\004`\022S\210\327\002q\023\210\237t\304\214E\203J\252\031\036\235Vp\346zy\\q\010#3\335;8i\240\361\236\226\234\222av&\213nN\203\350\254d\364-\034\315\227w\024\313\325-\024\265ud\360\206\277e\260\241@\363\004\023\325\231\030\270\351\223\037$Th\022\332\0011\324\232\363\336\372JDxOF\025t\226g\020\342\010\342\205\304\016)^I]\345\034\341\221[^~\206\241\006~\223\335m\365bf\231\353\004\220\222\314\230\311\n\214\314\323%\013\220\253\217\t;Lny\272\036N\355U\"\253\246\220\032D\237\030\317\014\340\270\2603\023| \353\032.\271\036,e\255\3072ZBx\030\n0\275'\017\\Uz\304(\326\220\030+\321\204\265\224\255\221U-\247\3042\2006\311\352\256\377W\242\024KKS\027\305\207\277\305\217t\230\334\317~XGa,%\263\211\201\311\221\266\346\264\314\372\341&\305\244\2328\273T\243mbz\26549\331\233j\221V\342\006\014\204\342a%\231\331\004\207\244\216\257a\233\242\326\013\367\357\211+\352\375\364d6q\tU\021d\306h\235m\316l\341\322\261\251\2462\276(\247\013XP\2114\022%\232\222\315&\365\31211\001\035\350\2664*R\250\216}\301+\210E\300E\305q\034\024\201\033{\203\205f\242\301\266nE\003Ai\006\231\006\021\007\233C\032\247F8\252G\032\256\253\"\261X\272I\230\013\211)Uq\206\315\2270BpcM\260\260\371\311l\230ABk\327p\301\266\344\251\331\345A\334$zC\322\007i\331\250\325\243\263\014\303\337\2260\212\035\2709\232\340F\017\264\204'\003\362lOw\r\333\332\323\250\336\303B\350\"\000\360\367\235Fp\200J)\223\207#d\3157\223,\334i\217\000\222kF(x*SK\301\331\230f\031\232\0240\2625PW\206\001x3RX\264\323r\364\353!\216\250P\247xr\2029s\240kai\325\263i\226\350/A\345c\250\230l\354\003\025<\246\261)7Sq\330cw\303/\234\212,\214\t\352\321u\225Z\310\273\320\317%\002\207CH\245\202C\334\031\224\002\276+\0030\314\226|\206\357a \303\304\264\261\301k\231\227\006\360\323\273M\240K\307\027\207{e\014\330\325\344L\261lYC@\306\023Td\034\244i\214L\333\034\345\034\355\266f\224\303BWd\356M\227S\242$f\037\013\355\362\010]\251:U\r*>\202\251\302p\200\361)\246\255z\220\367\312\253\006\250\036\230\362\007\027\260\032\300\314\327\206\207JK\036)c\260l\"\006*\320\242C\315\302)\005\"\003\325\202\220q\246\340\300\306:&`a\232k\300\346U\201\221y\360\007\351\277]\360g\230.\243V\2211h\274:Q\031\347\320\031JU\363\372\362\276i\322\311,\362\353\217\037UQ\326\264\254\001\274\231\274\014P\343\260\336\264h\301I\233\005(C\305M\256\266\215~\210\335\004\353L\013\001\321\337E4\252\263\000\213ik\244\225\344\202\362W@x\016\002\370\265K""\244\332n,\214WD\026\226\304:,^0bZ\3703-\202\270b\031\024\030k\205\210\202\013W}\203i`\023z6/Y\\\347\262\253&\360yb:\354\202\355\217\222*8\345\"\316\367\231\254.\313\216\213\257\277*X\337\200a\262\366\216\r\246\343\204\007mJ\267q\215\317\334AH\235h\305\236\004\031\240\014\3731\323\361\323\017*H\301\244sI=\371\250\357z\303\334\226\214\374x\361HW\220\202\362\024\345\344\205u\005B\231g9\326\223-a\202+E\222\020#a\344\311y\333\207\307\275\355\026\346\307\031G\207\214\253x\351\346\363j\221\357$\331n\370\344FN\327e2\347J\036\021\342\213\353\311\003\247\320e\260\240\330\300\324\361\266\266J\026\304Fs\"H\017L\251z\220\244\352/m\262\275\021\006\033\004\360\274m%\347\024\243F\231\033\260\301\303\236\350\241u]\234Jq\004\346$f\321\026\266\227+%CDQ\263\354,\207\334m\215U? \256\240+\363&\366\334q\224$zd\346h\006c\247\002m\017B\311\265M\224\024U\024\211\376\253\334[2JJ\204\214\202\022\230&S\031\020[\266\255\225EW\252\306V\277\023Es#\265Lm\222\201pdPi\361\033DYhCh\272\250!\\d%\236\030\265v3\313\023\234\022\347\020\271\320\271\317h\353\366\351\324\310<\356\345\306\223$\266\034\303\203\311\303\213\t\035Y\231\2133\246G r\016\316\336-\367\217\204\224&\"S\221\310xF\341\\\317\003U\005\342\274\203\r\235;\330\325;Q<\272\306\204z\363\304&\326\346\323\246\263\306SA?\313\360\013\004\363dl\347@s\200\266\207\253\r\023pY\365\276\311m\217\026\203>\000,\0229\016^\210\305\001\036\324|SF\242\016\"\210\251\250\016\222\351G\251_\007\027\020\206\023\na\020\260\340\302\001\3759^h\365\"\212(p\220\367\376\340?\337\t\177uC\004D\245\010_k\377\037\366M\024R\021 W^\267\266l\200\246\032\230*\377l\017m\205\304\252u\304\363\252\013\024\360\306\372L\252+\337\211<\244-\265C\344\237\356\231\tT'\370\315\000D\205\n\177\316z\001\372\270\030\026\322G\323\203\334\234\025\224O\255\212d\0179\240\212\244\237R\313*\213I\035\250Oz\367\210\246)\305\022s\335\343\241\343x\367#\342\223\363\302Y-X(\213;\360{\266y2|\325,\217?\254\322\206\217`CJ{d)T""\016a\206\370\021\203\252[\006/E$\265\326U\"\222xj8\253\344\304\030\242\377\312\242\341/\333\342\374s!\t4\350\215\021\220\224)\240\034q\357\270\020\310\330\004c\0200\201]\206\004!\355\200p\347\210_\307F5\276\304\213\304\236\027\330\\Q\360Yaz\226\211\346)\206\026\375N\331\362\336\017\275\366\320\274\222\244\243\365\346\314\274\210\327\244T\226C\t\235\325k\243D\025\214J\203\t{\327\227\025\036\272\036_Y\016\212\037\r$\236\301\030\271-!/Pu\356\\*\213.\305\222\300\220\201\203\003Q\036\274.\267\230:\352\276\210\205JxNo[\317\200\0374\014\316\247\237\240\245\224w\312\221\031\021y\370c9\002\315\234\260`\214/\025R[\320~S\360F\304\036z\025IO\r\302\364\032\372~\350`v?%0\353\006\314|n\363\322<\0031\370\336\217\322O\021\356U\351A\220+\351\022\211\373\362&\006\203\347\343\362\006$6J|\200\361n\014`)qO\220\364\333\322M\224>\224z\213E&!\363\235\"h,\n\017\312\322\256\240`b\2206\310|\223\345Qd)PL\203<\362aee2\300\265\202\310='\251\337lI*Q'\247C\014z\227\226\036\354\365\263\306\220d\271\032.\225\002\361\353?n{,\221k-\023B\353\013\254\237\210\365\236\266\222}9C%\310hO\224\022>\231\017\000\3650\315\237\373\250\0376\214Z\305\005\364\312\013\314-\246\225\007eD\377_W\261%\236\326\363\242\310ovnR\362\254\367\351\022\312\207\177\375\203=\020\254\250L\221\245\244\3215\254FQJ\203`\312\361\025x\250>\0014\322\353!\376SD\232\347\017\305-\254(\301\275\rDp\334eD\327)\2606\004\221\tB\031\241\321\202\034\266\2735\2373\232\332\270\2655oWZk\251'\005O\272\241X%\211\024kF\271Z8\021\301\005\231e\236.R\2520\264\223\005Q.\033\013\354\014\331T\213US)t3V\267\002\273\033\313\3118\315\230\033\321*D\340\317\206\266\005\342\323\255d-\234\244\226\330\224\213U\325M5\301d\317[\332\307\312\324\001y\247\0016\222\342\2770\321\265\375\031\003\217\003\345\313\352\314\261\205k\250\226\214\306\201h\374p/\275\364\326\243\254\225t\277\374*\333\321\251\025R\331\305\322\250\275\014Af\020\361,\216\217W\020:Ld\355:b\372!\267\346\246\366q\202W\004=F\251\361)\347~eI=\360\256\006\352\320\312IGiQ,p\261r\356,\230\205J;s9\024\254\316""\214\230\272T\375\273:P\274\206-\275\333qI\271=\020\324\225U1$\341\277\014Z\325\034J\271)v\301i,i\023\022\344\242\222^6*\r\211\014\354\311Ho\233\3746\211\255A}\177\206\031k\372\230F%\325\032\261b\246\034:es91\203$c\022\242p\263\341A\200\312\343~=\026\241\273\370\345/\033\341'3\315M\241%7\240\371|\336z\275\006\307D\034\016\004\r\331Z\351/^\023\377(\301\377pb\354\273s\277\257\363#\344\226J\221\304\355RL\030\271\207\321\337\256\223\324a\030\001|\326=s\260\230%\353\233\022\377\362%f\312U4\231_\210\365\307qN\345#\343\213r_\332C\2232\270\312\345\321\026_\013\013\332h\226Y\210\345\246\033\021-\304v\307\347\207\031i'\262\301\307=;\2579oi\225N9\031\346\214\371\013\277\211\241\244\272\221\201\224\\\305%\245.\266\212R\215\212\016\017f\234\274\244S\225\307\307\227w\366//\311|K\263\311\034\301tR\221\225\344\275\346.RO\230\301\355\307\0374\347\356;\261\315Z\226\275H\2460\216I\314\205\230O\236$\240\305/\315%(\251.%\357\317H\342\346\370\371}_\005s\207\261\356\235\365\333\331\366\016\210\322\333\352\223\230t\373$q\356\346{\361\017\235\354\230N\357\317\311aNh)9\273\322w\221\263URL-dU\231\260\303\277\316\237\014sG~\216[r#\274\212Kw\220\330\273\031\231\241g{5\243L.\244\310.\2542\222?\372v\242\203\330\251Ub\274\310\267m%\255\305\334\344_)\314\261\210\344g\315t\357f\322J\2113\222\222]\316\350FRZ\031}\256)\317\335\347C\220\234\301HU\354\2164UB[\225\2272\366\243\030\331\213,\250\256Y\016\343\215\355\245\350\360\005\234\267\234\242\353\220\307-\020\234\260!\254}\347\001\n\307+\376y_\231\367W\224\r\324O\tNGvN:\272<\013\245\262P]\014\2719\230h\347\227\226h\313\300q\211\365\234\353r\277\006;\207\031\307V\024\221y\013\014-\304w\035\255JB\3665\270\2511\3331\335N\352\331x\003\210\342\211ig\274+\316\3558\007\t\332ZE\331\3772\026R\354\257\227a\331\016\004\236\003\2008*)\n'\r\031!i>\255Ff!i\032-\307\241\300k\327\035\230\324\251a*\244\327\274\300{9I\303t\226Q\213T}\003\300\340\260\337G\344\303\rqcR\032\357-%U\270\014\226\214!\274\223\331\246\251V\246\247\350b\322N\301;0\242j\026\220\276\376\266\014""\277>\003\326\220\352\216\031\235\200\372\017\246\227\363\236d\017\314\235\032\315^\246\032\265cEK\261'\014X/8G\002\371\212\214\367\336g\264\207\342\250\263\261.;4\216\376\374\366\362\213$\366\326\317\021\236\271=\247\007e\337\2176I\215m\374\246\247\005\252Y\214J\r\232ea\255\330\373\305I\354\357\267\306\370\255\3717\331\311\327}W\275\274\336'bo\303Ti\35652a\014\347\345\366\036L\357\226_\202\375\235\366q\"\226M\367\0055\337\022\302\366\331\303\205\207\220}n\006\372=|T\244\263\177\374=\213\367xV\355+4\235\241z\366<\221\274P\355-c\261\275\275\001\310\353\2147\354\235D\021\001\027!\351\027\370o\240\033\211\233\205\003\227\266NC\210Ai\344s\207_\273t\267](\226h\036\257\220\217J\210\364\252\317J\242=\354\036\231\035\227\362\301\332\355\322\003\363\210R\221\356t@\243\000\035\265\3706\273\235\2728\330\001\245!\243\270A\307\327_\020\036\301\330\020\244\270\275\365\3367u\372<\257\215\350\307\241\027u-\030\205X\177\037\272T\371E\035j$\324\276\357cF\313\003\036\244 \365\316\357\317\021\317\252\217EME\305\007Z\200\030:\326 \301\t\267\341\002\000\205?\360\007{y/\264\236UN\204l\355\236s\315\370\022\203\300\0074\"yT5\325|\342\006\320\207\302\211\306\211\300\017\002\037\0304\202\363\000\371\001\345\035\245>R\031\327\207\337~OP\017\220?r}\017X\371\377;\342\006&\244\311(\301\177#\037\201\274\365\240\301\2459\235\000kA\276\2728\035h\341\3075\326\006a\024\231\016OQ\213\024\0369\315c\306\203:\300\321\321\001\034\026\027\211\310iu\276\t\255\235\203H\355:\213\230dj\326sK\250\016\242L\272\346Y\333\255\232\\z\330JRi\014\014L\343\236y\355\005O\265\202\374\023\261\333\250\263;y\373\362K\343\347% \244\230\017\036\034\007\221\2744\236H5\017\371~\021\361\243\260Gt\361\227\200Bw\255'|\337I\300\320r""\0105\264\322o\3000\215\013\007\261{\241\273\337b=\276/\231}\0106\371V/G\2772\200\307\313!\260nG\033e=\357\243(p\2257\n\254\"{w\356\260(D\240\354\316\343\261Q\224\036\305\004D\221\316w\322\033\203\256`t\023N\321\320]3\316E$\2512l\201\365}\031\0143$}A\301^\241K2U#\0220(mA\220k<*\002#\017&\265\361k6w\000\341\350\036`TLH\002\323f\022\246\014\004\346\202\005@G\004\262rJ\001\274u\245\250R\003\210\032\025\254}s\021y0\302\032L\364\205\004\021f\036\n\200}1[\247\006dN\023\371u \367\377:9\344\261a\354;5\263\210@O\034\341BG\004'\212\276\3630\331\310\353{\357`\370UUFh\302_\t\352\016\270\365\264rR6\330\200P\214\243\032\225\214\234gy\241\245s\306\311\233\234\200H\261\213+\263\264\020]\2104\225\331\344\020\270G\222A8N\025\367\244\250\014&\213\252\010g\014\316p\366\005\200\213\027/.\304O\334\311\271M\250\204F~=\217\374]\311\024\341BC\027\354\241\220"; + PyObject *data = __Pyx_DecompressString(cstring, 7737, 2); + if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) + const char* const bytes = __Pyx_PyBytes_AsString(data); + #if !CYTHON_ASSUME_SAFE_MACROS + if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } + #endif + #elif (CYTHON_COMPRESS_STRINGS) != 0 /* compression: zlib (7637 bytes) */ +const char* const cstring = "x\332\355]\313\177\323F\327NB\200\000\t\215s\241\241$\305I\010\241-\244u\022\n\364#\241\316\005J\013-I\270\266PU\266\345\304\340Kl\311\316\245oy\273\314\322K-\265\324\322K/\275\364RK-\375'\344O\370\236s$\313\262\343\334 P\350\033~\2164\222F\232\2313\347<\3472G\342;\257?\032\365\206\"1).G\022q\331\273\234\222\202R(\022_\254\234\364\016\205\274\261\264\254x\003\2227\022\017I\253R\310+\306C\336xB\361\312\321\010\252O\245\303a)\345\315D\244\025o(!\311|IZ]N\310\222WVR\221\220$O\213qo\"\036]\363\006S\222\250H^\321\033\260nR\226D\305\033\221\275\301D\\\211,\246\023i\031\215xcR,\221Z\033\301]\364(Q\226#\213q\257\222\360\342\346\320\025~\216U\203\232\264+\331\017^IE\0241\020\225\354\nV\247\302\251Dl\247{yX\336\225\210\262\344U\326\226%\357\260}^I\211q\231\207Q\271\305\252\206;\" \225\342\242\335\214\233`\021\213\010V\245\331\330\262\262\346\225\227D\316l\221\222^\242y\031\275\013\004\243\2309\260\003\215)\035\211*h\214\310+\217x\357\206\275k\211\2647.\241\233\230\326e\324s\337\240,Iq\257,)T\360\016\363\\\210\n\306-\340v\360\346\260M\327HF\242\273o\213QY\032\371\245\212x\350\262\315`b0(\311ej.(\322\2627&\2561\375\300\317\353R*Q!\364\303%\354\345H,\035\025\025\020\316a\3455\364D\214F\023+\252\256;g\323\016s\020\027\005\031\377\230,!Q\021G\352\\\265d\223\236a\303\347\210\177a\372\356\335\231\207\317\036\314\316F\243\221e9\"\337\215+\322bJ\214\n\302\203\265U\374\315@\036\205\2371\333\363RxAJ\246\245xPzH\362q\n\3140\326Q$\016\253\002\230i\327\262\330\302]\346N\3611\367\210\357\244\215\020\221\005\013\300$\322\375\220E\250f\t\250\307\372SJ\245\000|\253\213b\032\332\316\332\t\304\016\320\334\202,\306` \220\361\024G\273\300\326pT\\\224\303\321\204\250\214\215\206\211\344\212\255\317\t\322\350O\000\301\312{a\2116$m\316\231TF\240Q\005\005aq\221{\311\355E\304\270-\334\0021'8\020( D\"!l\030\177\261'\233$\002\236\244\3018\022m)\014[kDV#\253>\374\210\014\221\325Q\374\254\222\020\305\037J/_\275\222\326\360\223_\0019\026\345h@\024\200\037Q\211\n\0311""\036\211F\305hP\214J\231\265\n\037@Hb\"X\t[z\206\024\243>\307$E$\260\004\340\330\370M\266\016\352$B\351(\355\323\2614\215\307\026\357\265x\\\260\3451N3\245D\202Q*Z\304\225I\372@Y9.\006\025\322\000P[\326\026\n\022[\222_bn\273\272\305\347\361e\314\036XF\\\221\251\000v_\246\002\014\"\231\225\031f\333\221\202\364\022\356\nH\301W\313\313L\361e\210\271\323\013\247`+T\210\002\356\257w\322\276\267|\245\252\032_J\300\376\303T\022P\333\243]\206\312'\266\r'\004\001*\014\247\321\013z\024\037\331\263LEfR.\245\343\313\221\340+\036\t\023\2521\262\311\345\235\325Q4m3\361\n \271\352\300\256`\357\300W\314\321J\002\177\2514\354\367\214\234q\337\232\331rk\306\332\255\313\353\356z\353[\352\255\363NQ\204'\367\351\317:\002\002\3138\265\244\010\240W\324\207\277Q\206T\305\221\326J\311W)\216\362\320\000,V\277Im\212i\374,\266Sh\204\002\014C\320\2336V\235\330\262\000)\021B\3222\031\356\364g\235w\254x\" D\034r\0001M/\023We08a\376\036\375\t\326\006wd\320\373\014\217\240<\214\014+\222\014\017&#D\361\363\341o\324\242\214\205\256\231\245\214\305\211\031\\\263\355\233\014\252\330\266\014\250,SC2\036\271\n\251\304\017\207\264}r\177mMXZ\023\242\370\371\3607\272\276\316\255\255sk\026Q\311{\221\327\227\326\255\026\326\243\276u\273\205uT\267[X\227\377n\334\374\254\241\177\300\364\366\327\376F\307\234\362f\264\261\341h\333\206\177c\256\324\334\253\372\315\346>u\316\336\234S}f\335s5\033_\316c6\017h\375\233\307\032\216\236\332\030\330\270\235\035\310\376\244\256\353]\372\323""\034n9\275\021\310\036\313\006\324S\332w\372\303\\O\276#\357\333z\022O\370d#\225=\223M\251\347\264\037\365P\356R\276\277\324<\250\241\352%\275\321l\036\326\222f\363\220\206N\236\332\030\335x\234\035\315.\250\215\352\0315\245\235\325\007\364i]\311]\247\307\266l\234\314\366\233\315\375\232\247\324\374\271\032\322\3725\337fK\303\321\317\324NuJ\rkSZDOQoO\242\233w\262\276\354t6\243\316\253kzK\356x.\231o,w\"\251\036Q\257k\327u\2373\256\356\354T6\254\372\325\337P\025\325\272\252\017\271w\330l\2666\034=\253\342\304\005\355~\316\223\303\010Z6\216n<\312\366g}\245\226\317UQMk\277\344|\271\231|c\2763?S8^\370\257\361\3707\343\267\347h\341D\353\206\317l\355\312\336V\007\324\273\332\234\026\326\375 Lo~.\037*\014\033w\1777~\227\014)l\204\027Kv\245\031\255Q;\243%\365f\375\036\036\327\225\177b\314<3\236\375a\374!\032b\240\324\362\231\332\257^\323\256\350\311\334\221\334h\356q\336\227\367\233-\035\331+\240\030\335\325Xji\335\230\315vg\305l\322l\355\001-;\325it\317o\266v\200\202\326\2463\353\2637\236\254\247r\001\024m\353\006\351Rj\237&j\262>\250?\311\371s\013\371\246\374@~:\377W\321_\234+\265\322hW\264\020&\347~\336\223\277\220\017\026:\n\243\205\027\306\374\202\261\360\320l\265\2101\2437\031_\336\314\373\363\270\201(\337\231\365\233\355\235\326\344\232]`85\250uk\"\310\323\326\225\035\307\\-hM<\246c\2710\350w\2440a<\2303\346\236\030O\236\033\3171\364\240\021\014\231\355=\352q5\251\035\321F\265gz\220\031\356V\261\277\3503\3331\227\230\324q\260@_^\314\247\013\323\205T\261\2438a<\005\341~\265.\177\013\256\2357\276\366\027<\205~\263\375S\020\247\375LV4\333\273\263s\256\236]\324b\230F\277\331\005\302\225*\247?\005I:!/=\340?\355\202&\351\276\315\323\rm\355\033\177\201S\036j\235\032\017n\022\205i\360K\227\027\023H\305\214>W\362\234WemHS\364Q\375E\276?\177\025C\033-\314\027\3762\036>2\036=6\333!\205\030\373\021t\317Sj=\223\r\252\035\352\204\336\250w\202\363W\301\270G\362\243\371\371\274\\\270RL\202 \346\2565\210\332\377Q}\230qY\033\324\026\300\r\355\237\251\203\220\004\036\356\222\032\320x""\220\242\366g\256\337U8\257&1\367\236s{\254\212Y\363d[\355\236\217iAtf&\327\224\033\004\253Pw\026\n\215D\341\264z\033}\230\327\376\002\017=\311\317\026\272\013\301b\237\361\030s\372\302x\0210\002\213\306\342K\343\345+\320\332\350\371R\357\327\257\362#\036\031\337\335\003\243=2\346\037\202F\245\236A\222V\2145e\370\246\013\276\302l\261\2638U\014\030\017\036\363\223\300\035\202!X\002\0241\"\257\214W)#\245\030J\272\204\251\352\321;\364[ \372x>e\370\321&DM@\337\317\016\340\212\007\314=\257'\335\325\010P\272\3730\313]\004~]gU\217k\342\277\324\2570\216\364`\302J\225\323\347\324Q\020\241\321\354\005\202\201-\256\346\032\377\265\3049\366N\210\343\261\305\2207\220\312R\315!\3709I\3025\236\225U\346\276\327\372\002Hq!\027@{\335\350\206:\004\270\231\322D\022\273f\024\342\000\341&\250\030b\324R;:K\260\352\207\030\037Q\257\242\202_{\244\017\001'\316p\207[\351\001\203\350\314Q\355!\006\372-A\273\0334\001c\372\305\\c\316\363\206\342~\2550\010aO\3313\373\264F\334\333\263-vK$\254/r\375\271\361\234\234\277RH\026\217\024\307\212\"\341\235u9C\352\361\370\337\257\031\214Z\332\263\307\301>?ik\271\326\374\217\205W\306\334\274\365\334\307\320\251\275\203\316\006Pe\366\002\371\266\234\343\r\351\336\336k\271\244u\370\371y\263\227T\035\315\224\331\373\205^\256\300%\037)+\263\367\033\320\24137\215\036\342\221`I\253\312\211Oyb\352v\252O}\201j}\260\"l\356\367\231}\243\271\313y\321\354\243\373\373\360t\322\217\237l\274\3048=0j\3164\014^0\007\006k\177\343W\235\362\346\177\336\306\25094e\016M\231CS\346\320\224\371 M\031<\t\332\372\217\262\016vig\342F<\340\177\311t\371\020\211\361\3576Uv\026\347\177\334T\371\200\254\224\236\206\033\337\231\327o\324\376~\374\311)o\276~K+\205K%\266\000\016\r\225CC\245\216\241\342)\233'\367\231o\347\215kw\213\236b\377?d\242$\313\206I_N\314)\371Qc\342\027K\313\357\311:94@\336\211\316\275\222O\026\216\025$\343'\313\273\307\244\022\323\037\\\320`/\232\370\330\207m\226\374{Ith\254\034\032+d\254\2646\2348i\266\234\250\371m~\347\330'\365\326}\334\301\222\326\275Z\010{5V\330""\014a\343\243lS\234n8\332\001\225\330|\226\330\033\344\036\325\236\222\230\324W\374\273\251b\323\255\212\333\321\274\010j\016\000\033\320\022\363%\353\337]\365d'FB\366\014\235\352\002\252\310\030\366L\356T~,\317\252\3541\353\205\024\213\361u\364C(\370\013PoP\311\266\242\203\240\355\350t\227\266Q\205\255$\017,\231\377\207\226=[$\323\013\315\335\277'\231<\005Yy\214\007O\347R0\010\253\204\257\221\271\004\210\361Vr\262\016\365/\025|\346M?\254\021\327\346\207b\243]\272\003\303\340\346,\010s\023\306\211}\201Ks\304\3147\037\030\017\346\215y\026\340\233?\026\373\2670>5\020\203\3011\201\352@R\002_s\002w,\230\023T}\002\217*\265\234v\261zg\227\331\321Y\365\2730\344\224\035\236'\256&\304\335\316\3566\367d\025\003\235\366\312\363\245:<\3776v\364\346I6\214Ke\371pd\365\304\236\354c\263\345\324\373\265\216\253D\262#;\230\235\317\376\005\205\261\240\037a\315\000\353\025,\332\231\277O\006lED\211C\333w3fG\263\217\330\316\372\013Cx\224\033r\2363TL\033\017\241\244\241\367\203$\214a\326\017M\332\027\372\230\276\004I\372\004L\336h\313k\331:\305\023=];\204\311\334\227\253\202ke]z\240\022K\343;[-\263o\255\331\326y\222If'\247\353lH\250\276\367\233\223$\242\223$\273\223?\025\355\323V\tBHQ\031sr\236\2438\274\2441y\257\350\347:\245\275\212/\2554U$\270Z]u4\364\2345?\355\251\371UD\267\245\276\350\262C]\331T<\350S\007\253\275\352I\362\261\275K2u\237=Z2\020\312\322[#\270\373\020\246\022\304\304\202\20514\356\327\210\203\333\2744\3670\000;\364k`\2171\233\327\233a\277\212\226\314\367\243vP\353\200\225\030gN\353\316\007\200\r\020\007\272\273#\333\221\035\313\306au\245\364n=`w\233/@*\035\2359\300\035\204\000\201yK\373U\252)\265\013D\221\265\213\354yU\224\252\321=\004Lh\201\344|mE\266\253\244sGm\272\235cy\354\200\265\351h\316^\004\350\200\037\357\030\235W\3115t\035\034\200n]\313\265\345\037\201\006^\262\036]\033\270\216\356\315e\335o_\370\nD\360\222m\351\275\242\317\331\027\2704\316\321\204F\323{\025<\355\035\321\305:\366e[\376\005I#ie[\037;\342i)\\\267\232\355i\270|\305\374\352r\355ob\322)o~\337t\030""\376:\014\177\035\256\323\355{\235\3560\022\366\221%\316\374\017.\315\035F\277\016\243_\037K\364\353LCo\237y\256\267\366we\304)\277\261\255R6S\366\236Pt\320a\000\307\236 \243\375[\260\334W\332SX|\260\027\374\216\243\361\357\260\035\354h\300.v\202\331\212\351P\357h\343\360]\254u\2501\2706M\266\016;(\275\017\000\320Z0\330)=\206\261\314\026:\013S\205@\261\rrH\376\355\336\264\374I\022\373\327\016@L\200n\3355FM\265L\327\250_\263\375,3M\214aZ&\373\326\036\353`\345\001\244mEV\253\036\213\305\030\000\027Y\025w\201\023a\031\003\336\300\014\225\032\007\371<\317\226\253\241\334@\356\027\350\023\177\271\226\345Tv\326L\212\004\345a\033\036@\267_\215_\301r\304JdJx\3015\235\332mh\2561\314\312\371Bc\241\0138\270R\014r\204\001\325\211\211\215\347/JpL\177A\243\204\264\203\372#v(/`\232\032KP47\301>\027\340\3336\232|\220\322{r\035\271[\205\376\202\255\215f,\247\360\034\244lT\023\300e\360=\253\246u\233\330\355\273\325*\373g\232\003P\004\376\374c\n\360N;\033\016\353N\301\234\255=W\035\371\235\274\265s\360\227\226\3338\376\213\262\025H\302<\377fE\201\271\346\356>\352S\343)\0073w\213(\235\254\257\002\200\374\227\035\340\247@\203kS\006\371\355\375\303o\311\307<\230\305\217\226-\213\037\317\2307+\301\335\366l#\303~\243\013\305\267\203P\233\007)\256A\341\225s\271\333P\256\020\206Y\265\233\204\227\371\324\354\"\rM\306\326vVUP\357&Y\246s\363v8\251\013R\364\025\233\231=\237s\260\211\242\267\243\372\263\\0\337\003\036\274es`\017\205%z\210\212=\244/+\217\035a\270\364\233\275\0247\257\234>\317\002\355\347\320\005\204R\312\371\350\242\217.\374\t\311\345\300\306$t\324\024\264\317\000\220\243\3772\200\227\003\037d\375\216\024\232\201\276b\211\242\037%\2667hh\260\224\376\004\324\334f\020#\001\361\225\332?\207\343q\234\303g\256@\315Q\3759\036\375\003\036\333^Q<\345\230\234\247\233\374G\032\304N\321\247A\210h\177\t\325\310\200\233\242P\224\356/\207\233\254p\235c\310\245q\205\272Wr\233v|\206Z\353\301S;\324o\371\221/rC\271?\001\275\270\372\231z\221+\337\303h\277\300p\226\000b\237\030O\300\374\317\314.2AP""\243\377M\014\347\020\220%I\243\362\321\215\177\242U\314\326\2406\t\213l*\027\202R\365\233g/0V\365\\`\030\035\3117c\026D\362\016|6`U\210\366\223\215RG\3627\341\006\203\233\217\377\235\244e\206In\271\265\315\326\2134\263\355\314z\235\352,F5\013/f\026&\217\305\220^\255\314\232\227\030\266\347\330-d\327\235\307\n2\235\356U\307T\216c\336\341\230\334\r@\257o\022\366\3377\023\260(\277\201\367o~3\003\226\010\026\201\177\035\331/1\325s\245\017\244\037\274B\205V?i\257\372\365\0178\345\315\357\033\267\203\244\312\006\035p\300\203@&\206Y\265\214>^\313\265\027:\353\001\322\240\346\333\006\225\030\220\332\263M\331\213j\223:b\205\241\310\212\334v\371\367u\376)\270\323\205\200u\242\340\245}\032\262\345E\255\263\352g\000\301\271\203\262]\027r\315\271{l(<1\356\301\216X2\226\340\265\276\254\265^\217\350\343\372\177\200Px\240q\007&\004Y\201FH\252g\277N\347\223\245\352E\346\243\331G\250\345\343\2105\272W\266O:r\023h\330\263s\200\274G=\252>\3429s\000\345\0132)\254x\371\205l\\\363\033CWs/`\237\\%3\023\2665:\006G~\251\n\327)\336t\215\275\312N\216\352\237\005\\\336s\351W\334f\217\334\252{\025&,-\231\215P\017k\001\244\327\215\"\2560\374V\014\354\205\374t\303 OVPe\r\023\3439\2005\261\207,\234\347\010\357\231\370c|\253\313E\230\322\026\3659]\334o\264\035\032\367\004i\334\026\232\220\352\225\311~\230n)[\017\223\361\330X\367$\361zK=k\t\214Q1\177\312\006Qi\177\006\321C\366\3511ad\323\360\372e\302H,\357\3212\332a\225\255\305m\023\235\256\263\312\366\305\227\225\345\266\251\n\016\355q)|\2735\365\003q\225\0030y\3474\361\000\234\345\217\324-\336n\315\274#?Ql\004\007\355o\005n\326\361\365f\200\215S\260\340\372\nbA)\216\027\3774~eF\204\226\2642_\312\276V\200+F\362\251BO\261\243x\013\266:\231\336\373X\240\333\315ez\267\311.o\354\013y\262\237\002\236\177\323O8\013\347\265\311.o\350\367T\345\275\324\225\3537Y=?\335\320v\232\254\034\367\357\363\363N\371\000\345\272f\231\375\344?\030\000\253\267\246\276W\301.\275\357T\230*W\2553;\006\002\265\261\336\034t\330\267\013^V[q\256(\356\262\232\277eU\276F\262\016""\032\023\336f}\376\037\023\177\333%{\207\000\300\301\220\017\007\000\272\272\315\316\256\252\337\320E\247\\\001\200:rM>N\355\n\374\201'\302\361\243\311\2658y`r\177\311\270\364\035\\\375\377+\274dsw\276J\366{\324c\220~Y\033\240E\025\314b\027\364\346:s\357?\257\357Ko\224\026g\036\2208W\347\304\305\363S\306\244\025[[\250\021ls\217\2117_Z\253\357\277\025O\332\261\240\217A\301W\007;)\343\246V\276Y\220?\000\321nm8\375\211\t\365^\363;\3575{\373\234\303\315\231\306\035\023\273\337\241d\037\264jo\335\230\332\010\363\364\267h-z9u\256:\347\225A\253*\177\216\374\234^\325\007\307\261\027\276a\210uf(?\\\350\245\325\355\005\263\245\215\007\375P\365p\\\255K{\006\347R\311]\243\005\360;\316j\365\211\363\207\311\263\356\344\331\227L\252y\010\311\021\360\307h^\340\325\266\0179y\366\340\001b}[\003\300\255\373\367\206\021?\027\243\274\332\261\005+\370\256\375\003\306/\305\377\360J\310v)\265\236\016\212v\272\177\003\203Ny\363v\243+\271\266w\007\320(g\252M\251/\365\326\334\017\340\323]O\224\232i]\336\331\274\203\367I\336\237Oa\255\264\237e\340\350\321\317\345~\314\213f\263g\227\023UK6\273[\034\245\275\000\213\265\024\276\007hq\241\010=\277\255\342y\270q\244Y\277m\271\026\306u0\020d!\304y@\326\372\232\0353\254rE\214\257&\320\251 /\275&\313\235\241\254\342\200\341\035\345G\211\246\235\262\027sg\263\177,\316\212\371^\234\225Q0\364\001:*\273\0332\267\013\242{\363\241\270,\035u\354\032\0305\216ES\005O\373\310\375\377\350\261\346\304?\007\034\3571\212q`\357$\034\002\312\373\006\024\216|T6\037\n\240\264\324M\370\330\274h\255=\334\311\336T\223\344\327\234\330\350\330\270\016!\235\241\010\201\345n,\201\241W(\271\301\022\341\037@\340G\244\314\t+\2326.A\026\307\310i6\355\245R4G\364Jm\234\331\220\201$\360-\3467V\360\010\205P\351\370\337i \312 \334\347\026\252=\014\217cX\343\205qy\343b\366\010I5!\314q\240\301Qun?+#.\203\242:\355\243\264C\332G\037%biG\000_`\250\243,\214\036J\303\n\362\222#\265\337=\210\302\023@\007\265\334\325\3179\007\215\264&\336\247>\207\340\372(\221`\205\323\267{xm\334J\264HR\212""\304<4=-\001\322\342:\277\214$iW\365S\220\363\245LR&\307\254\325}\223\323\321I\2509\227\342<\n\237\202\014=\350>\272\267\240\265R\303\2244\327\013/\206\263\036\256\001\004\375\326\222\276\253\203\311\322.\211\013\237\251\027\324\210\266\242/Z4\3329Y\240n\236\300\375B\237\3613\330\367\225\361*\263\331\320\260\3228\335\204\335t\323}\332\335o\022i'6\005i\027l\n\323.\334\264\330\264\227d\206\003\351[\361\225\361\014\252\"i$\377B\323\257\033\177\240\036\374\320\364\234v\317\233~\247\335\357\345N\006\232\334\271\r\247\335/\232o\316Ck\323\334YZ\255*\265\252T\361\334O\327\345zJ0\3316O\201\324\245\353m9\227o\354\201\232\270\246^\002/\215\331*\260;\267\010%(\022TNeCP2\243\352\023\355\016P\361nn\216\243\002\204\343;]\244w'D^\n\013\201!Sz'\363Q\275\223\226\232\351\312\316e\227X\221\215[\271Fn8\016\351\375\374\252\270\245N]iHM\3720\257Y\354\253\266\345\340\257\332\002G+uVX\244j\245\033\250rz\203\3634\034\3108\275!\342\256\362z\366\270\246\350\365O\226\200\210w\262WA\377\033\260\021(\323\372\006\345\267\2706\204\3567n\345\223\366!\031\2257\010\366o\334/>\344@\"\234\010+\035\323~]\300\274\001=Q\373I\002\346\224\363u\362\357\312LR\332&\225\345`X\304S\342\223\343\240c\023\000\232P\343\014\314\236\346\334\035\216\320\322\013Kl\236\214\363\244\0004u0\305\226\024\004\323\245\214\233\240\363E-\255O\351aJ\035}\233yJ\2033\203N\250jn\307)y\343\3318\275\333lTb\206\0074%\346\333L\211\271eJ:x}\232\314&\221C\373\203\205\271w0E'\337~\212\310Jz\363yj\257\232\247\223\365\341\225\017\2531\266\375c\304\330r\370\322\002\324\200v\202\004\317\376\250\306\231l\204M\031\202\330c\034\276\275\n\323x\220rS\013g\213\3750\332\323\234C\0033\023\336\314\242\261h\245{\275/\241}kp%\023\272V\246\337\220M\354\337g\347*\214\023\336C\212a\225\354\3238{+y\205\247\366\226\017\270\177\210(9Vu\237\266\204\331\261j\367\262g\355\207\333r\t\026m\363\327z\262*\3711\200[\372\235\\E\270\321u""\374\361}\346!~\034\t\210U\266\377\273I@$\343n\247\364Cr7\232\355\257\016x\272+\256\306\010dr\025\036\346@\376g\016'\006\350\025\323.\353u\331o\2357\267\276e\244^(6\025G\370\225Yv\n\373\350E\221i\372\326\216q\031,_H\027\247\212\021~7\200\302\027\374\356b\314\210%\214\304k\343\365\177a\203~\337\344o\332.\235\261\264M>\264\343\267\227\336_:\343\216\330SY\270 \232\355\323awP\250\315Z\323?Q\rF\212#\251I\232\253\272'\267\361\371\267&3\356#\337\211\035\372\367\221\326X\345\371w\325\375xHUf\343\313\375\177\230\323\t(\266\274]@q\313'\t\352~\270`\373\260c\315\247\013\266\017@\226\376W\222\"\253\276*\260\217\027\005\367\364}\2004\177\337\253\017`\226\316\315:\341L\311Xxj<\265\324\356\037;\274%\370!~\224\233Fv\006\3555\251WX\337\320\227\220D\006\235\251|\020\256\277X\004U\273w\256\260\247\367\320\355\327\254\323\374n\305\024\217\370v~\210\277\221`\365\013\354\2039\007o\220.$\332?\265\303\3037\200\202\253\371T\341\274\225\312cv\365\276\227\027\347?\354\016W\275\314\316\261\346\352\303w\371\332!\221h\356c\177\241\375T\376\006\277\013\261\277\027\332\337\311\273\354\225\256\354\373]\366w\253\335\314}\257\201\261\213\260\257U\266\203^3+}l*\213\310^\225\242\3636\212\312\262\317%Zw\327\3328\331\351\002|\352A\262\232\340\003+\306\202\375\336\364\016Zj\273%\254\275k)v\224\377\244\340;\325\233\340(\010\275\240\216\272\2579G\311G\357\017:\351Jf\367 M\332\366\2639\356\272\264P\320\305\2535e\334\366W\036{\235\373\347\256^\332\341\232;\020\013Z\332\257\\v\355\336\337\322.\375\255\0025\327K\3713\234)E\236Z\252\320Q\030+\304\254\3342s\367*6\270Wf\306~\241\276\206\022%v\333\026x\342%\340a:\177\233\377\253\2412\202B\261L\242\336\024k\360$\243\021\177\333'\003\261\356\001\264\354\370Z(-\274\234}\247\217\207\277x\317\246\0341\376\202\275\352\332\311\324\350,\260\n\275\252\035c\025K/\272\177Z8ZxT\034,\276\3407O\300\325\220\320\224\221J\033\351\214\311\237\223\261\276-\263\006\030\275\016M\"\224\273I\260\335Ck\036o\3606\362\020\014?\377\307\335\327\271\312\253\336\374\242p\251\346\360m\274Z\013""\276\266\375t\345no\344u\271\rS\266\032\224,/\224\037\254L\276\355g\r\366\271\250\315\356\354\326\317\032\034\340\027\r~\371\177\022\005s\375"; + PyObject *data = __Pyx_DecompressString(cstring, 7637, 1); + if (unlikely(!data)) __PYX_ERR(0, 1, __pyx_L1_error) + const char* const bytes = __Pyx_PyBytes_AsString(data); + #if !CYTHON_ASSUME_SAFE_MACROS + if (likely(bytes)); else { Py_DECREF(data); __PYX_ERR(0, 1, __pyx_L1_error) } + #endif + #else /* compression: none (33760 bytes) */ +const char* const bytes = ": All dimensions preceding dimension %d must be indexed and not slicedBuffer view does not expose stridesCan only create a buffer that is contiguous in memory.Cannot assign to read-only memoryviewCannot create writable memory view from read-only memoryviewCannot index with type 'Cannot transpose memoryview with indirect dimensionsDimension %d is not directEmpty shape tuple for cython.arrayIndex out of bounds (axis %d)Indirect dimensions not supportedInvalid mode, expected 'c' or 'fortran', got Invalid shape in axis ')?add_note and at 0xcollections.abcdisableenablegc (got got differing extents in dimension isenableditemsize <= 0 for cython.arrayno default __reduce__ due to non-trivial __cinit__numpy._core.multiarray failed to importnumpy._core.umath failed to import object>return_option must be either \"full\" or \"minimal\"return_option must be 'full' or 'minimal'self.name is not Nonesrc/cssm.pyxunable to allocate array data.unable to allocate shape and strides.ASCIIDTYPEEllipsisIntegral__Pyx_PyDict_NextRefSequenceTView.MemoryViewaa_viewabcabsaddallocate_bufferalphaalpha_stable_valuesalpha_viewarangeargmaxargminasarrayastypeasyncio.coroutinesbb_viewbasebias_tracebias_trace_l1bias_trace_l1_viewbias_trace_l2bias_trace_l2_viewbias_trace_viewboundaryboundary_funboundary_fun_typeboundary_multiplicativeboundary_paramsboundary_params_tmpboundary_viewcchoice_idxchoiceschoices_idxchoices_view__class____class_getitem__cline_in_tracebackconstantcountcssmdd_viewddmddm_flexddm_flexboundddm_flexbound_mic2_adjddm""_flexbound_mic2_multinoiseddm_flexbound_mic2_ornsteinddm_flexbound_mic2_ornstein_multinoiseddm_flexbound_mic2_unnormalized_ornstein_multinoiseddm_flexbound_par2ddm_flexbound_seq2ddm_flexbound_tradeoffddm_sdvdeadlinedeadline_tmpdeadline_viewdecision_takendefault_rngdelta_tdelta_t_alphadelta_t_sqrt__dict__driftdrift_fundrift_fun_typedrift_incrementdrift_paramsdrift_params_tmpdrift_viewdtypedtype_is_objectemptyencodeenumerateerrorexgaussexgauss_raceexp_sampleexponentialflagsfloat32formatfortranfullfull_ddmfull_ddm_hddm_basefull_ddm_rv__func__gg_viewgaussian_values__getstate__iid__import__indexintc_is_coroutineitemsitemsizeixix1ix1_tmpix2ix2_tmpix_lix_tmpjkkeykeyskwargslba_anglelba_vanillalcalevy_flexboundm__main__max_tmemviewmetadataminminimalmode__module__mumu_valmultiplynn_choicesn_particlesn_samplesn_trialsnactname__name__ndim__new__norm_samplenormalnpnum_drawsnum_stepsnumbersnumpyobjornstein_uhlenbeckpp_viewpackparticlesparticles_reduced_sumparticles_reduced_sum_viewparticles_sumparticles_viewpoppossible_choicesprint_info__pyx_checksum__pyx_state__pyx_type__pyx_unpickle_Enum__pyx_vtable____qualname__racerace_modelrandomrandom_staterandom_val__reduce____reduce_cython____reduce_ex__registerrepeatreturn_optionrlwm_lba_pw_v1rlwm_lba_racerngrt_candidatesrt_valrtsrts_highrts_high_viewrts_lowrts_low_viewrts_viewss_pre_high_level_choices_pre_high_level_choice_views_viewsdsd_view__set_name__setdefault__setstate____setstate_cython__shapeshifted_waldshifted_wald_racesigmasigma_valsignsimulatorsizesmooth_usmooth_unifsqrtsqrt_stsqrt_st_viewstst_samplewisest_samplewise_viewst_viewstartstepstopstructsvsv_samplewisesv_samplewise_viewsv_viewszsz_samplewisesz_samplewise_viewsz_viewtt_WMt_WM_viewt_distt_ht_lt_l1t_l2t_part_particlet_particle1t_particle2t_st_tmpt_viewtantautau_val__test__thetatheta_viewtmp_pos_deptrajtraj_viewtrajectoryuniformunpackupdatevv_v_RLv_RL_v_RL_viewv_WMv_WM_v_WM_viewv_dictv_distv_lv_l1v_l2v_viewvaluesvhvh_viewvl1vl1_viewvl2vl2_viewvsvs_RLvs_WMxx_tx_t_RLx_t_WM""yy_hy_ly_l1y_l2zz_dictz_distz_viewzeroszhzh_viewzl1zl1_viewzl2zl2_viewzs\200\001\360\032\000!\"\330 !\330 !\330 !\330 !\330 !\330 !\33023\330 !\330 !\330 !\360l\001\000\005\r\210A\210Q\340\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\033\2301\330\004\033\2301\330\004\033\2301\330\0041\260\021\330\004\"\240!\360\006\000\005\013\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\021\330\004\017\210r\220\026\220r\230\033\240J\250d\260(\270!\340\004#\2401\330\004(\250\001\330\004'\240q\330\004%\240Q\340\004\013\2102\210V\2202\220S\230\001\230\026\230r\240\031\250\"\250C\250t\2608\2701\330\004\010\210\n\220!\330\004!\240\021\340\004\036\230d\240!\2401\360\010\000\005\032\230\023\230B\230f\240B\240i\250r\260\021\330\004\n\210\"\210G\2201\220C\220v\230R\230y\250\010\260\007\260q\270\001\330\004\017\210r\220\026\220q\230\003\2308\2408\2501\330\004\"\240!\360\006\000\005\025\220B\220f\230A\230[\250\010\260\001\330\004\024\220B\220f\230A\230[\250\010\260\001\330\004'\240q\330\004'\240q\360\014\000\005\031\230\001\330\004$\240M\260\021\260!\340\004\010\210\005\210U\220!\2201\340\010\036\230a\230u\240O\2601\260D\270\001\270\023\270D\300\007\300\177\320V[\320[\\\360\006\000\t\014\2101\330\014\024\220F\230\"\230I\240Q\240f\250A\250T\260\034\270Q\270d\300'\320I^\320^e\320ef\320fg\340\014\024\220F\230\"\230D\240\001\240\026\240q\250\004\250L\270\001\270\024\270W\320DY\320Y`\320`a\320ab\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270A\330\010\022\220-\230r\240\026\240q\250\001\340\010\014\210E\220\025\220a\220q\330\014\030\230\001\230\023\230C\230u\240A\330\014\022\220!\330\014\022\220!\330\014\023\2201\330\014\023\2201\330\014\021\220\021\330\014\022\220!\330\014\022\220!\360\010\000\r\025\220C\220r\230\035\240a\240s\250#\250W\260A\260S\270\002\270\"\270C""\270}\310A\310Q\340\014\036\230a\230w\240d\250\"\250M\270\021\270$\270c\300\022\3002\300]\320RS\320ST\330\014\036\230a\230u\240D\250\002\320*<\270A\270Q\340\014\017\210r\220\023\220A\330\020\023\2202\220S\230\001\330\024\035\230Q\230c\240\025\240a\360\006\000\r\024\2204\220v\230S\240\002\240-\250q\260\006\260f\270D\300\003\300=\320PQ\320QW\320W\\\320\\`\320`c\320cd\330\020\030\230\007\230q\240\003\2402\240Y\250c\260\030\270\022\270?\310!\3101\330\020\"\240!\2408\2504\250r\260\035\270a\270u\300C\300r\310\022\310=\320XY\320YZ\330\020\"\240!\2406\250\024\250R\320/A\300\021\300!\330\020\027\220q\330\020\026\220a\330\020\025\220Q\330\020\023\2202\220S\230\001\330\024&\240m\2601\260A\330\024\030\230\001\340\020\023\2202\220S\230\001\330\024\027\220r\230\023\230A\330\030!\240\021\240$\240e\2501\360\016\000\r\020\210}\230A\230T\240\023\240A\330\020\023\220>\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]\270!\2705\300\003\3002\300R\300}\320TU\320UV\330\020\034\230A\230S\240\003\2406\250\021\340\014\026\220c\230\022\230=\250\001\250\023\250C\250x\260q\270\003\2702\270R\270s\300-\310q\320PQ\330\014\026\220c\230\022\230=\250\001\250\023\250C\250x\260q\270\003\2702\270R\270s\300-\310q\320PQ\340\014\017\210|\2301\230C\230s\240#\240S\250\001\340\020\032\230#\230R\230q\330\020\026\220h\230b\240\001\330\024&\240a\240{\260!\330\024&\240a\240{\260!\330\024\037\230q\360\010\000\021\033\230#\230R\230q\330\020\026\220h\230b\240\001\330\024&\240a\240{\260!\330\024&\240a\240{\260!\330\024\037\230q\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\027\220u\230F\240#\240R\240}\260A\260W\270E\300\025\300c\310\035\320VW\320W]\320]b\320bg\320gj\320jk\330\024\030\320\030*\250!\2505\260\002\260#\260U\320:L\310A\310U\320RT\320TU\340\030#\2408\2501\250C\250r\3201C\3001\300E\310\023\310B\310b\320PV\320VW\320W\\\320\\_\320_e\320ef\320fi\320ik\320kr\320rt\320tu\340\030!\240\030\250\022""\250?\270!\2704\270r\320A]\320]^\320^_\360\006\000\031\"\240\030\250\021\250#\250R\250q\340\030!\240\030\250\022\250?\270!\2701\360\010\000\025\035\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\027\220u\230F\240#\240R\240}\260A\260W\270E\300\025\300c\310\035\320VW\320W]\320]b\320bg\320gj\320jk\330\024\030\320\030*\250!\2505\260\002\260#\260U\320:L\310A\310U\320RT\320TU\340\030#\2408\2501\250C\250r\3201C\3001\300E\310\023\310B\310b\320PV\320VW\320W\\\320\\_\320_e\320ef\320fi\320ik\320kr\320rt\320tu\340\030!\240\030\250\022\250?\270!\2704\270r\320A]\320]^\320^_\360\006\000\031\"\240\030\250\021\250#\250R\250q\340\030!\240\030\250\022\250?\270!\2701\360\006\000\025\035\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\021\330\020\026\220a\330\020\026\220a\330\020\027\220q\340\020\026\220a\330\020\026\220a\330\020\027\220q\340\014\017\210q\330\020\023\2204\220s\230!\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025\031\230\021\230%\230u\240B\240a\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220S\230\003\2305\240\004\240A\240U\250%\250r\260\026\260q\270\001\330\014\031\230\021\230#\230S\240\005\240T\250\022\2506\260\021\260!\330\014\030\230\001\230\023\230C\230u\240D\250\002\250&\260\001\260\021\360\016\000\r\020\210}\230A\230T\240\023\240A\330\020\023\220>\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]\270!\2707\300#\300R\300r\310\035\320VW\320WX\330\020\034\230A\230S\240\003""\2406\250\021\340\014\020\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\014\270J\300k\320QR\330\020\034\230A\230V\2401\330\034#\2401\330\034#\2401\330\034!\240\021\330\034\"\240!\330\034#\2401\330\034#\2401\330\034!\240\021\330\034!\240\021\330\034(\250\001\330\0347\260q\330\034!\240\021\330\036\037\330\034'\240q\330\034%\240Q\330\034)\250\021\330\034(\250\001\330\034)\250\021\330\0341\260\034\270Q\330\0340\260\001\260\023\260C\260s\270!\330\034*\250!\330\034(\250\001\330\t\027\220s\230!\330\010\020\220\007\220u\230K\240y\260\014\270J\300k\320QR\330\020\035\230]\250!\330\0351\260\021\260#\260S\270\003\2701\330\0352\260,\270a\330\035*\250!\330\035)\250\021\360\006\000\t\017\210j\230\001\230\021\200\001\360\026\000#$\330\"#\330\"#\330\"#\330\"#\330\"#\330\"#\33045\330\"#\330\"#\330\"#\360|\001\000\005\r\210A\210Q\340\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\033\2301\330\004\033\2301\330\004\"\240!\360\006\000\005\013\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\021\330\004\017\210r\220\026\220r\230\033\240J\250d\260(\270!\340\004#\2401\330\004(\250\001\330\004'\240q\330\004%\240Q\340\004\013\2102\210V\2202\220S\230\001\230\026\230r\240\031\250\"\250C\250t\2608\2701\330\004\010\210\n\220!\330\004!\240\021\340\004\036\230d\240!\2401\360\010\000\005\032\230\023\230B\230f\240B\240i\250r\260\021\330\004\n\210\"\210G\2201\220C\220v\230R\230y\250\010\260\007\260q\270\001\330\004\017\210r\220\026\220q\230\003\2308\2408\2501\330\004\"\240!\360\006\000\005\025\220B\220f\230A\230[\250\010\260\001\330\004\024\220B\220f\230A\230[\250\010\260\001\330\004'\240q\330\004'\240q\360\014\000\005\031\230\001\330""\004$\240M\260\021\260!\340\004\010\210\005\210U\220!\2201\340\010\036\230a\230u\240O\2601\260D\270\001\270\023\270D\300\007\300\177\320V[\320[\\\360\006\000\t\014\2101\330\014\024\220F\230\"\230I\240Q\240f\250A\250T\260\034\270Q\270d\300'\320I^\320^e\320ef\320fg\340\014\024\220F\230\"\230D\240\001\240\026\240q\250\004\250L\270\001\270\024\270W\320DY\320Y`\320`a\320ab\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270A\330\010\022\220-\230r\240\026\240q\250\001\340\010\014\210E\220\025\220a\220q\330\014\030\230\001\230\023\230C\230u\240A\330\014\022\220!\330\014\022\220!\330\014\023\2201\330\014\023\2201\330\014\021\220\021\330\014\022\220!\330\014\022\220!\360\010\000\r\025\220C\220r\230\035\240a\240s\250#\250W\260A\260S\270\002\270\"\270C\270}\310A\310Q\340\014\036\230a\230w\240d\250\"\250M\270\021\270$\270c\300\022\3002\300]\320RS\320ST\330\014\036\230a\230u\240D\250\002\320*<\270A\270Q\340\014\017\210r\220\023\220A\330\020\023\2202\220S\230\001\330\024\035\230Q\230c\240\025\240a\360\006\000\r\024\2204\220v\230S\240\002\240-\250q\260\006\260f\270D\300\003\300=\320PQ\320QW\320W\\\320\\`\320`c\320cd\330\020\030\230\007\230q\240\003\2402\240Y\250c\260\030\270\022\270?\310!\3101\330\020\"\240!\2408\2504\250r\260\035\270a\270u\300C\300r\310\022\310=\320XY\320YZ\330\020\"\240!\2406\250\024\250R\320/A\300\021\300!\330\020\027\220q\330\020\026\220a\330\020\025\220Q\330\020\023\2202\220S\230\001\330\024&\240m\2601\260A\330\024\030\230\001\340\020\023\2202\220S\230\001\330\024\027\220r\230\023\230A\330\030!\240\021\240$\240e\2501\360\016\000\r\020\210}\230A\230T\240\023\240A\330\020\023\220>\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]\270!\2705\300\003\3002\300R\300}\320TU\320UV\330\020\034\230A\230S\240\003\2406\250\021\340\014\026\220c\230\022\230=\250\001\250\023\250C\250x\260q\270\003\2702\270R\270s\300-\310q\320PQ\330\014\026\220c\230\022\230=\250\001\250\023\250C\250x\260q\270\003\2702\270R\270s\300-\310q""\320PQ\340\014\017\210|\2301\230C\230s\240#\240S\250\001\340\020\032\230#\230R\230q\330\020\026\220h\230b\240\001\330\024&\240a\240{\260!\330\024&\240a\240{\260!\330\024\037\230q\360\010\000\021\033\230#\230R\230q\330\020\026\220h\230b\240\001\330\024&\240a\240{\260!\330\024&\240a\240{\260!\330\024\037\230q\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\027\220u\230F\240#\240R\240}\260A\260W\270E\300\025\300c\310\035\320VW\320W]\320]b\320bg\320gj\320jk\330\024\030\320\030*\250!\2505\260\002\260#\260U\320:L\310A\310U\320RT\320TU\340\030#\2408\2501\250C\250r\3201C\3001\300E\310\023\310B\310b\320PV\320VW\320W]\320]_\320_`\360\006\000\031\"\240\030\250\022\250?\270!\2704\270r\320AS\320ST\320TU\360\006\000\031\"\240\030\250\021\250#\250R\250q\340\030!\240\030\250\022\250?\270!\2701\360\010\000\025\035\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\027\220u\230F\240#\240R\240}\260A\260W\270E\300\025\300c\310\035\320VW\320W]\320]b\320bg\320gj\320jk\330\024\030\320\030*\250!\2505\260\002\260#\260U\320:L\310A\310U\320RT\320TU\340\030#\2408\2501\250C\250r\3201C\3001\300E\310\023\310B\310b\320PV\320VW\320W]\320]_\320_`\360\006\000\031\"\240\030\250\022\250?\270!\2704\270r\320AS\320ST\320TU\360\006\000\031\"\240\030\250\021\250#\250R\250q\340\030!\240\030\250\022\250?\270!\2701\360\010\000\025\035\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\021\330\020\026\220a\330\020\026\220a\330\020\027\220q\340\020\026\220a""\330\020\026\220a\330\020\027\220q\340\014\017\210q\330\020\023\2204\220s\230!\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025\031\230\021\230%\230u\240B\240a\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220S\230\003\2305\240\004\240A\240U\250%\250r\260\026\260q\270\001\330\014\031\230\021\230#\230S\240\005\240T\250\022\2506\260\021\260!\330\014\030\230\001\230\023\230C\230u\240D\250\002\250&\260\001\260\021\360\016\000\r\020\210}\230A\230T\240\023\240A\330\020\023\220>\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]\270!\2705\300\003\3002\300R\300}\320TU\320UV\330\020\034\230A\230S\240\003\2406\250\021\340\014\020\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\014\270J\300k\320QR\330\020\034\230A\230V\2401\330\034#\2401\330\034#\2401\330\034!\240\021\330\034\"\240!\330\034#\2401\330\034#\2401\330\034!\240\021\330\034!\240\021\330\034(\250\001\330\034!\240\021\330\036\037\330\034'\240q\330\034%\240Q\330\034)\250\021\330\034(\250\001\330\034)\250\021\330\0341\260\034\270Q\330\0340\260\001\260\023\260C\260s\270!\330\034*\250!\330\034(\250\001\330\t\027\220s\230!\330\010\020\220\007\220u\230K\240y\260\014\270J\300k\320QR\330\020\035\230]\250!\330\0351\260\021\260#\260S\270\003\2701\330\0352\260,\270a\330\035*\250!\330\035)\250\021\360\006\000\t\017\210j\230\001\230\021\200\001\360\030\0009:\33089\33089\33089\33089\33089\33089\330JK\33089\33089\33089\360~\001\000\005\r\210A\210Q\340\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\033\2301\330\004\033\2301\330\004\"\240!\330\004\033\2301\340\004\n\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004\016\210b""\220\006\220b\230\013\240:\250T\260\030\270\021\330\004\017\210r\220\026\220r\230\033\240J\250d\260(\270!\340\004#\2401\330\004(\250\001\330\004'\240q\330\004%\240Q\340\004\013\2102\210V\2202\220S\230\001\230\026\230r\240\031\250\"\250C\250t\2608\2701\330\004\010\210\n\220!\330\004!\240\021\340\004\036\230d\240!\2401\360\010\000\005\032\230\023\230B\230f\240B\240i\250r\260\021\330\004\n\210\"\210G\2201\220C\220v\230R\230y\250\010\260\007\260q\270\001\330\004\017\210r\220\026\220q\230\003\2308\2408\2501\330\004\"\240!\360\006\000\005\025\220B\220f\230A\230[\250\010\260\001\330\004\024\220B\220f\230A\230[\250\010\260\001\330\004'\240q\330\004'\240q\360\014\000\005\031\230\001\330\004$\240M\260\021\260!\340\004\010\210\005\210U\220!\2201\340\010\036\230a\230u\240O\2601\260D\270\001\270\023\270D\300\007\300\177\320V[\320[\\\360\006\000\t\014\2101\330\014\024\220F\230\"\230I\240Q\240f\250A\250T\260\034\270Q\270d\300'\320I^\320^e\320ef\320fg\340\014\024\220F\230\"\230D\240\001\240\026\240q\250\004\250L\270\001\270\024\270W\320DY\320Y`\320`a\320ab\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270A\330\010\022\220-\230r\240\026\240q\250\001\340\010\014\210E\220\025\220a\220q\330\014\030\230\001\230\023\230C\230u\240A\330\014\022\220!\330\014\022\220!\330\014\023\2201\330\014\023\2201\330\014\021\220\021\330\014\022\220!\330\014\022\220!\360\010\000\r\025\220C\220r\230\035\240a\240s\250#\250W\260A\260S\270\002\270\"\270C\270}\310A\310Q\340\014\036\230a\230w\240d\250\"\250M\270\021\270$\270c\300\021\330\014\036\230a\230u\240M\260\021\260#\260R\3207I\310\021\310!\340\014\017\210r\220\023\220A\330\020\023\2202\220S\230\001\330\024\035\230Q\230c\240\025\240a\360\006\000\r\024\2204\220v\230S\240\002\240-\250q\260\006\260f\270D\300\003\300=\320PQ\320QW\320W\\\320\\`\320`c\320cd\330\020\030\230\007\230q\240\003\2402\240Y\250c\260\030\270\022\270?\310!\3101\330\020\"\240!\2408\2504\250r\260\035\270a\270u\300C\300q\330\020\"\240!\2406\250\035\260a\260t\2702\320=O\310q\320PQ""\330\020\027\220q\330\020\026\220a\330\020\025\220Q\330\020\023\2202\220S\230\001\330\024&\240m\2601\260A\330\024\030\230\001\360\016\000\r\020\210}\230A\230T\240\023\240A\330\020\023\220>\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]\270!\2705\300\003\3002\300R\300}\320TU\320UV\330\020\034\230A\230S\240\003\2406\250\021\340\014\026\220c\230\022\230=\250\001\250\023\250C\250x\260q\270\003\2702\270R\270s\300-\310q\320PQ\330\014\026\220c\230\022\230=\250\001\250\023\250C\250x\260q\270\003\2702\270R\270s\300-\310q\320PQ\340\014\017\210|\2301\230C\230s\240#\240S\250\001\340\020\032\230#\230R\230q\330\020\026\220h\230b\240\001\330\024&\240a\240{\260!\330\024&\240a\240{\260!\330\024\037\230q\360\010\000\021\033\230#\230R\230q\330\020\026\220h\230b\240\001\330\024&\240a\240{\260!\330\024&\240a\240{\260!\330\024\037\230q\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\027\220u\230F\240#\240R\240}\260A\260W\270E\300\025\300c\310\035\320VW\320W]\320]b\320bg\320gj\320jk\330\024\030\320\030*\250!\2505\260\002\260-\270q\300\006\300e\320K]\320]^\320^c\320ce\320ef\340\030#\2408\2501\250C\250r\3201C\3001\300E\310\023\310B\310b\320PV\320VW\320W\\\320\\_\320_e\320ef\320fi\320ik\320kr\320rt\320tu\340\030!\240\030\250\022\250?\270!\2704\270r\320AS\320ST\320TU\360\006\000\031\"\240\030\250\021\250#\250R\250q\340\030!\240\030\250\022\250?\270!\2701\360\006\000\025\035\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\027\220u\230F\240#\240R\240}\260A\260W\270E\300\025\300c\310\035\320VW\320W]\320]b\320bg\320gj\320jk\330\024\030\320\030*\250!\2505\260\002\260-\270q\300\006\300e\320K]\320]^\320^c""\320ce\320ef\340\030#\2408\2501\250C\250r\3201C\3001\300E\310\023\310B\310b\320PV\320VW\320W\\\320\\_\320_e\320ef\320fi\320ik\320kr\320rt\320tu\340\030!\240\030\250\022\250?\270!\2704\270r\320AS\320ST\320TU\360\006\000\031\"\240\030\250\021\250#\250R\250q\340\030!\240\030\250\022\250?\270!\2701\360\006\000\025\035\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\021\330\020\026\220a\330\020\026\220a\330\020\027\220q\340\020\026\220a\330\020\026\220a\330\020\027\220q\340\014\017\210q\330\020\023\2204\220s\230!\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025\031\230\021\230%\230u\240B\240a\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220S\230\003\2305\240\004\240A\240U\250%\250r\260\026\260q\270\001\330\014\031\230\021\230#\230S\240\005\240T\250\022\2506\260\021\260!\330\014\030\230\001\230\023\230C\230u\240D\250\002\250&\260\001\260\021\360\016\000\r\020\210}\230A\230T\240\023\240A\330\020\023\220>\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]\270!\2705\300\003\3002\300R\300}\320TU\320UV\330\020\034\230A\230S\240\003\2406\250\021\340\014\020\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\014\270J\300k\320QR\330\020\034\230A\230V\2401\330\034#\2401\330\034#\2401\330\034!\240\021\330\034\"\240!\330\034#\2401\330\034#\2401\330\034!\240\021\330\034!\240\021\330\034(\250\001\330\034!\240\021\330\036\037\330\034'\240q\330\034%\240Q\330\034)\250\021\330\034(\250\001\330\034)\250\021\330\0341\260\034\270Q\330\0340\260\001\260\023\260C\260s\270!\330\034*\250!\330\034(\250\001\330\t\027\220s\230!\330\010\020""\220\007\220u\230K\240y\260\014\270J\300k\320QR\330\020\035\230]\250!\330\0351\260\021\260#\260S\270\003\2701\330\0352\260,\270a\330\035*\250!\330\035)\250\021\360\006\000\t\017\210j\230\001\230\021\200\001\360\014\000\t\n\330\010\t\330\010\t\330\010\t\330\010\t\330\010\t\330\010\t\360:\000\005\r\210A\210Q\340\004\033\2301\330\004\033\2301\330\004\033\2301\330\004\033\2301\330\004\033\2301\330\004\"\240!\360\006\000\005\014\2102\210V\2202\220S\230\001\230\026\230r\240\031\250\"\250C\250t\2608\2701\330\004\010\210\n\220!\330\004!\240\021\340\004\n\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004#\2401\330\004%\240Q\340\004\036\230d\240!\2401\360\016\000\005\022\220\021\330\004\031\230\023\230A\230V\2402\240X\250R\250q\330\004$\240M\260\021\260!\340\004\010\210\005\210U\220!\2201\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270A\330\010\022\220-\230r\240\026\240q\250\001\330\010\014\210E\220\025\220a\220q\330\014\020\220\006\220a\220s\230\"\230F\240!\2401\330\014\031\230\021\330\014\021\220\021\340\014\017\210r\220\023\220A\330\020\023\2202\220S\230\001\330\024\035\230Q\230c\240\025\240a\360\006\000\r\023\220\"\220C\220v\230Q\230c\240\024\240R\240s\250\"\250D\260\013\2703\270a\330\020\025\220V\2301\230C\230r\240\030\250\022\2508\2602\260_\300A\300Q\330\020\036\230a\330\020\025\220Q\330\020\026\220a\340\020\023\2202\220S\230\001\330\024\027\220r\230\023\230A\330\030!\240\021\240$\240e\2501\340\020\023\2202\220S\230\001\330\024&\240m\2601\260A\330\024\030\230\001\360\014\000\r\020\210q\330\020\023\220;\230c\240\021\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025 \240\002\240!\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220S\230\003\2305\240\013\2502\250V\2601\260C\260r\270\021\330\014\030\230\001\230\023\230C\230u\240D\250\001\250\021\360\006\000\r\021\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003""\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240z\260\035\270e\3001\330C\3001\330>C\3001\330>C\3001\330>C\3001\330>J\310!\330@A\330>I\310\021\330>G\300q\330>K\3101\330>J\310!\330>K\3101\330>S\320S_\320_`\330>R\320RT\320TW\320WX\330>L\310A\330>J\310!\340\t\027\220s\230!\330\010\020\220\007\220u\230K\240z\260\035\270m\3101\330=Q\320QS\320SV\320VW\330=R\320R^\320^_\330=J\310!\330=I\310\021\360\006\000\t\017\210j\230\001\230\021\200\001\360\022\000\030\031\330\027\030\330\027\030\330\027\030\330\027\030\330\027\030\330\027\030\360:\000\005\r\210A\210Q\360\010\000\005\035\230A\330\004\033\2301\330\004\033\2301\330\004\033\2301\330\004\034\230A\330\004\034\230A\330\004\034\230A\330\004\"\240!\330\004\033\2301\340\004\013\2102\210V\2202\220S\230\001\230\026\230r\240\031\250\"\250C\250t\2608\2701\330\004\010\210\n\220!\330\004!\240\021\340\004\n\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\340\004#\2401\330\004%\240Q\340\004\036\230d\240!\2401\360\006\000\005\032""\230\023\230B\230f\240B\240i\250r\260\021\330\004\n\210\"\210G\2201\220C\220v\230R\230y\250\010\260\007\260q\270\001\360\010\000\005\031\230\001\330\004!\240\021\330\004$\240M\260\021\260!\360\006\000\005\t\210\005\210U\220!\2201\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270A\330\010\022\220-\230r\240\026\240q\250\001\330\010\014\210E\220\025\220a\220q\340\014\021\220\026\220q\230\003\2303\230f\240A\240Q\360\006\000\r \230v\240Q\240c\250\022\2507\260!\2603\260b\270\017\300q\310\004\310B\310a\330\014\024\220F\230!\2303\230c\240\022\2403\240n\260C\260r\270\025\270b\300\007\300q\310\001\360\006\000\r\022\220\022\2203\220n\240C\240r\250\025\250b\260\007\260q\270\001\360\006\000\r\022\220\021\330\014\017\210r\220\023\220A\330\020\"\240-\250q\260\001\330\020\024\220A\340\014\031\230\021\330\014\021\220\021\340\014\017\210r\220\023\220A\330\020\023\2202\220S\230\001\330\024\035\230Q\230c\240\025\240a\360\006\000\r\023\220\"\220C\220r\230\024\230R\230s\240&\250\001\250\023\250D\260\013\2703\270a\330\020\025\320\025%\240S\250\010\260\002\260/\300\021\300!\330\020\036\230a\330\020\026\220a\330\020\025\220Q\340\020\023\2202\220S\230\001\330\024\027\220r\230\023\230A\330\030!\240\021\240$\240e\2501\330\020\023\2202\220S\230\001\330\024&\240m\2601\260A\330\024\030\230\001\360\006\000\r\020\210q\330\020\023\220;\230c\240\021\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025 \240\002\240!\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220S\230\003\2305\240\013\2502\250V\2602\260Q\340\014\017\210r\220\022\2201\330\020\034\230A\230S\240\003\2405\250\001\340\020\034\230A\230S\240\003\2405\250\001\360\006\000\r\021\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\r\270U\300!\330 %\240Q\330 %\240Q\330 %\240Q\330 &\240a\330 &\240a\330 &\240a\330 ,\250A\330 %\240Q\330 +""\2501\330 )\250\021\330 -\250Q\330 ,\250A\330 -\250Q\330 4\260A\260S\270\001\330 5\260Q\330 .\250a\330\t\027\220s\230!\330\010\020\220\007\220u\230K\240y\260\r\270]\310!\330=Q\320QR\320RU\320UV\330=J\310!\330=I\310\021\330=R\320RS\340\010\016\210j\230\001\230\021\200\001\360\030\000,-\330+,\330+,\330+,\330+,\330+,\330+,\330=>\330+,\330+,\330+,\360@\002\000\005\r\210A\210Q\340\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\033\2301\330\004\033\2301\330\004\"\240!\330\004\033\2301\340\004\n\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\021\330\004\017\210r\220\026\220r\230\033\240J\250d\260(\270!\340\004#\2401\330\004(\250\001\330\004'\240q\330\004%\240Q\340\004\013\2102\210V\2202\220S\230\001\230\026\230r\240\031\250\"\250C\250t\2608\2701\330\004\010\210\n\220!\330\004!\240\021\340\004\036\230d\240!\2401\360\010\000\005\032\230\023\230B\230f\240B\240i\250r\260\021\330\004\n\210\"\210G\2201\220C\220v\230R\230y\250\010\260\007\260q\270\001\330\004\017\210r\220\026\220q\230\003\2308\2408\2501\330\004\"\240!\360\006\000\005\025\220B\220f\230A\230[\250\010\260\001\330\004\024\220B\220f\230A\230[\250\010\260\001\330\004'\240q\330\004'\240q\360\014\000\005\031\230\001\330\004$\240M\260\021\260!\340\004\010\210\005\210U\220!\2201\340\010\036\230a\230u\240O\2601\260D\270\001\270\023\270D\300\007\300\177\320V[\320[\\\360\006\000\t\014\2101\330\014\024\220F\230\"\230I\240Q\240f\250A\250T\260\034\270Q\270d\300'\320I^\320^e\320ef\320fg\340\014\024\220F\230\"\230D\240\001\240\026\240q\250\004\250L\270\001\270\024\270W\320DY\320Y`\320`a\320ab\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270A\330\010\022\220-\230r\240\026\240q\250\001\340\010\014\210E\220\025\220a\220q\330\014\030\230\001\230\023\230C\230u\240A\330\014\022\220!\330\014\022\220!\330\014""\023\2201\330\014\023\2201\330\014\021\220\021\330\014\022\220!\330\014\022\220!\360\010\000\r\025\220C\220r\230\035\240a\240s\250#\250W\260A\260S\270\002\270\"\270C\270}\310A\310Q\340\014\036\230a\230w\240d\250\"\250M\270\021\270$\270c\300\022\3002\300]\320RS\320ST\330\014\036\230a\230u\240D\250\002\320*<\270A\270Q\340\014\017\210r\220\023\220A\330\020\023\2202\220S\230\001\330\024\035\230Q\230c\240\025\240a\360\006\000\r\024\2204\220v\230S\240\002\240-\250q\260\006\260f\270D\300\003\300=\320PQ\320QW\320W\\\320\\`\320`c\320cd\330\020\030\230\007\230q\240\003\2402\240Y\250c\260\030\270\022\270?\310!\3101\330\020\"\240!\2408\2504\250r\260\035\270a\270u\300C\300r\310\022\310=\320XY\320YZ\330\020\"\240!\2406\250\024\250R\320/A\300\021\300!\330\020\027\220q\330\020\026\220a\330\020\025\220Q\330\020\023\2202\220S\230\001\330\024&\240m\2601\260A\330\024\030\230\001\360\016\000\r\020\210}\230A\230T\240\023\240A\330\020\023\220>\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]\270!\2705\300\003\3002\300R\300}\320TU\320UV\330\020\034\230A\230S\240\003\2406\250\021\340\014\026\220c\230\022\230=\250\001\250\023\250C\250x\260q\270\003\2702\270R\270s\300-\310q\320PQ\330\014\026\220c\230\022\230=\250\001\250\023\250C\250x\260q\270\003\2702\270R\270s\300-\310q\320PQ\340\014\017\210|\2301\230C\230s\240#\240S\250\001\340\020\032\230#\230R\230q\330\020\026\220h\230b\240\001\330\024&\240a\240{\260!\330\024&\240a\240{\260!\330\024\037\230q\360\010\000\021\033\230#\230R\230q\330\020\026\220h\230b\240\001\330\024&\240a\240{\260!\330\024&\240a\240{\260!\330\024\037\230q\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\027\220u\230F\240#\240R\240}\260A\260W\270E\300\025\300c\310\035\320VW\320W]\320]b\320bg\320gj\320jk\330\024\030\320\030*\250!\2505\260\002\260#\260U\320:L\310A\310U\320RT\320TU\340\030#\2408\2501\250C\250r\3201C\3001\300E\310\023\310B\310b\320PV\320VW\320W""\\\320\\_\320_e\320ef\320fi\320ik\320kr\320rt\320tu\340\030!\240\030\250\022\250?\270!\2704\270r\320AS\320ST\320TU\360\006\000\031\"\240\030\250\021\250#\250R\250q\340\030!\240\030\250\022\250?\270!\2701\360\010\000\025\035\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\027\220u\230F\240#\240R\240}\260A\260W\270E\300\025\300c\310\035\320VW\320W]\320]b\320bg\320gj\320jk\330\024\030\320\030*\250!\2505\260\002\260#\260U\320:L\310A\310U\320RT\320TU\340\030#\2408\2501\250C\250r\3201C\3001\300E\310\023\310B\310b\320PV\320VW\320W\\\320\\_\320_e\320ef\320fi\320ik\320kr\320rt\320tu\340\030!\240\030\250\022\250?\270!\2704\270r\320AS\320ST\320TU\360\006\000\031\"\240\030\250\021\250#\250R\250q\340\030!\240\030\250\022\250?\270!\2701\360\006\000\025\035\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\021\330\020\026\220a\330\020\026\220a\330\020\027\220q\340\020\026\220a\330\020\026\220a\330\020\027\220q\340\014\017\210q\330\020\023\2204\220s\230!\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025\031\230\021\230%\230u\240B\240a\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220S\230\003\2305\240\004\240A\240U\250%\250r\260\026\260q\270\001\330\014\031\230\021\230#\230S\240\005\240T\250\022\2506\260\021\260!\330\014\030\230\001\230\023\230C\230u\240D\250\002\250&\260\001\260\021\360\016\000\r\020\210}\230A\230T\240\023\240A\330\020\023\220>\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]""\270!\2705\300\003\3002\300R\300}\320TU\320UV\330\020\034\230A\230S\240\003\2406\250\021\340\014\020\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\014\270J\300k\320QR\330\020\034\230A\230V\2401\330\034#\2401\330\034#\2401\330\034!\240\021\330\034\"\240!\330\034#\2401\330\034#\2401\330\034!\240\021\330\034!\240\021\330\034(\250\001\330\034!\240\021\330\036\037\330\034'\240q\330\034%\240Q\330\034)\250\021\330\034(\250\001\330\034)\250\021\330\0341\260\034\270Q\330\0340\260\001\260\023\260C\260s\270!\330\034*\250!\330\034(\250\001\330\t\027\220s\230!\330\010\020\220\007\220u\230K\240y\260\014\270J\300k\320QR\330\020\035\230]\250!\330\0351\260\021\260#\260S\270\003\2701\330\0352\260,\270a\330\035*\250!\330\035)\250\021\360\006\000\t\017\210j\230\001\230\021\200\001\360\026\000\034\035\330\033\034\330\033\034\330\033\034\330\033\034\330\033\034\330\033\034\330-.\330\033\034\330\033\034\330\033\034\360@\002\000\005\r\210A\210Q\340\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\033\2301\330\004\"\240!\330\004\033\2301\360\006\000\005\013\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\340\004#\2401\330\004%\240Q\340\004\036\230d\240!\2401\360\010\000\005\032\230\023\230B\230f\240B\240i\250r\260\021\330\004\n\210\"\210G\2201\220C\220v\230R\230y\250\010\260\007\260q\270\001\330\004\017\210r\220\026\220q\230\003\2308\2408\2501\330\004\"\240!\360\006\000\005\022\220\022\2206\230\021\230+\240X\250Q\330\004$\240A\360\010\000\005\031\230\001\330\004$\240M\260\021\260!\340\004\010\210\005\210U\220!\2201\340\010\036\230a\230u\240O\2601\260D\270\001\270\023\270D\300\007\300\177\320V[\320[\\\360\006\000\t\014\2101\330\014\024\220F\230\"\230I\240Q\240f\250A\250T\260\034\270Q""\270d\300'\320I^\320^e\320ef\320fg\340\014\024\220F\230\"\230D\240\001\240\026\240q\250\004\250L\270\001\270\024\270W\320DY\320Y`\320`a\320ab\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270A\330\010\022\220-\230r\240\026\240q\250\001\340\010\014\210E\220\025\220a\220q\330\014\030\230\001\230\023\230C\230u\240A\330\014\022\220!\330\014\022\220!\330\014\021\220\021\360\006\000\r\025\220C\220r\230\035\240a\240s\250#\250W\260A\260S\270\002\270\"\270C\270}\310A\310Q\330\014\033\2301\230G\2404\240r\250\035\260a\260t\2703\270b\300\002\300-\310q\320PQ\360\006\000\r\024\2204\220v\230S\240\002\240-\250q\260\006\260f\270D\300\003\300=\320PQ\320QW\320W\\\320\\`\320`c\320cd\330\020\030\230\007\230q\240\003\2402\240Y\250c\260\030\270\022\270?\310!\3101\330\020\037\230q\240\010\250\004\250B\250m\2701\270E\300\023\300B\300b\310\r\320UV\320VW\330\020\027\220q\330\020\026\220a\330\020\025\220Q\330\020\023\2202\220S\230\001\330\024&\240m\2601\260A\330\024\030\230\001\360\n\000\r\020\210~\230S\240\005\240T\250\022\250=\270\001\270\025\270c\300\022\3002\300]\320RS\320ST\330\020\034\230A\230S\240\003\2406\250\021\340\014\017\210|\2301\230C\230s\240#\240S\250\001\330\020\031\230\023\230B\230m\2501\250C\250s\260(\270!\2703\270b\300\002\300#\300]\320RS\320ST\330\020\026\220h\230a\230q\360\006\000\021\032\230\023\230B\230a\330\020\026\220g\230R\230q\330\024#\2401\240J\250a\330\024\036\230a\360\006\000\021\032\230\023\230B\230m\2501\250C\250s\260(\270!\2703\270b\300\002\300#\300]\320RS\320ST\330\020\026\220h\230a\230q\360\006\000\021\032\230\023\230B\230a\330\020\026\220g\230R\230q\330\024#\2401\240J\250a\330\024\036\230a\360\006\000\021\032\230\021\330\020\026\220g\230R\230q\330\024#\2401\240J\250d\260\"\260O\3001\300A\330\024\036\230a\360\006\000\r\022\220\021\330\014\023\2204\220v\230S\240\002\240-\250q\260\006\260e\2704\270s\300-\310q\320PU\320UZ\320Z^\320^a\320ab\360\010\000\021 \230r\240\023\240F\250!\2503\250c\260\037\300\001\300\024\300R\300w\310c\320QS\320SU\320U[\320[""\\\320\\]\340\020\024\220O\2401\240D\250\002\250#\250U\260/\300\021\300$\300b\310\001\340\024\033\230<\240s\250$\250b\260\001\330\024\033\230<\240r\250\030\260\022\260?\300!\3001\360\006\000\025\035\230D\240\002\240!\330\024\033\2308\2402\240_\260A\260Q\340\020\027\220q\330\020\026\220a\330\020\025\220Q\340\020\023\2202\220S\230\001\330\024&\240m\2601\260A\330\024\030\230\001\340\014\017\210q\330\020\023\2204\220s\230!\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025\031\230\021\230%\230u\240B\240a\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220S\230\003\2305\240\004\240A\240U\250%\250r\260\026\260q\270\001\360\n\000\r\020\210~\230S\240\005\240T\250\022\250=\270\001\270\025\270c\300\022\3002\300]\320RS\320ST\330\020\034\230A\230S\240\003\2406\250\021\340\014\020\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\014\270A\270V\3001\330?\330\270\023\270B\270d\300\"\300A\330!,\250B\250a\330 ,\250D\260\002\260.\300\004\300B\300a\340 +\2501\340\034'\240q\330\024!\240\021\240%\240{\260\"\260F\270!\2703\270c\300\022\3001\340\020\036\230b\240\007\240q\250\001\330\020\034\230A\230S\240\003\2405\250\005\250\\\270\023\270H\300A\330\020\030\230\001\230\023\230C\230u\240M\260\021\260!\360\006\000\021\025\220A\330\020\035\230Q\330\020\025\220Q\340\020\023\2202\220S\230\001\330\024\027\220r\230\023\230A\330\030!\240\021\240#\240U\250!\340\020\035\230T\240\023\240B\240e\2501\250A\330\020\023\220;\230c\240\026\240q\250\001\330\024 \240\001\240\023\240C\240u\250A\330\024!\240\021\340\024 \240\001\240\023\240C\240v\250Q\330\024!\240\021\360\006\000\021\030\220r\230\022\2306\240\021\240#\240]\260%\260{\300#\300Q\330\024\032\230&\240\001\240\023\240L\260\002\260)\2703\270h\300b\310\017\320WX\320XY\330\024\"\240!\330\024\032\230!\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302""\230S\240\001\330\034%\240Q\240d\250%\250q\340\020\023\2201\330\024\027\220{\240#\240Q\330\030#\240>\260\023\260B\260d\270\"\270A\330\031$\240B\240a\330\030$\240D\250\002\250.\270\004\270B\270a\340\030#\2401\340\024\037\230q\340\020\030\230\001\230\023\230C\230u\240K\250r\260\026\260q\270\003\270<\300r\310\021\330\004\007\200q\330\010\013\210>\230\023\230A\330\014\r\330\020\027\220q\330\020\033\2301\330\020\021\330\024\031\230\023\230E\240\023\240E\250\023\250E\260\021\330\024!\240\021\330\024 \240\001\330\024!\240\021\330\024(\250\002\250#\250Q\330\024\037\230q\330\024\035\230Q\330\024\"\240!\360\006\000\016\034\2303\230a\330\014\024\220G\2305\240\013\2509\260A\3301>\270a\3300=\270Q\3300<\270A\3300D\300B\300c\310\021\340\014\022\220*\230A\230Q\340\010\013\210>\230\023\230A\330\014\r\330\020\027\220q\330\020\033\2301\330\020\021\330\024\031\230\023\230E\240\023\240E\250\023\250E\260\021\330\024!\240\021\330\024 \240\001\330\024!\240\021\330\024(\250\002\250#\250Q\330\024\037\230q\330\024\035\230Q\330\024\"\240!\360\006\000\016\034\2303\230a\330\014\024\220G\2305\240\013\2509\260A\3301>\270a\3300=\270Q\3300<\270A\3300D\300B\300c\310\021\340\014\022\220*\230A\230Q\200\001\360\014\000\020\021\330\017\020\330\017\020\330\017\020\330\017\020\330\017\020\330!\"\330\017\020\330\017\020\330\017\020\360@\001\000\005\r\210A\210Q\340\004\036\230a\330\004\036\230a\330\004\036\230a\330\004\036\230a\330\004\036\230a\330\004\"\240!\340\004\036\230d\240!\2401\330\004\016\210m\2302\230Q\330\004$\240A\340\004\033\2301\230F\240!\2401\330\004\n\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004#\2401\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004%\240Q\340\004\020\220\002\220&\230\002\230.\250\010\260\001\330\004$\240A\360\006\000\005\014\2102\210V\2202\220S\230\001\230\026\230r\240\031\250\"\250C\250~\270X\300Q\330\004\010\210\n\220!\330\004!\240\021\360\006\000\005\032\230\023\230B\230f\240B\240i\250r\260\021\340\004\n\210\"\210G\2201\220C\220v\230R""\230y\250\010\260\007\260q\270\001\330\004\017\210r\220\026\220q\230\003\2308\2408\2501\330\004\"\240!\360\n\000\005\031\230\001\340\004\031\230\032\2402\240Q\330\004$\240M\260\021\260!\340\004\010\210\005\210U\220!\2201\340\010\036\230a\230u\240O\2601\260D\270\001\270\023\270D\300\007\300\177\320V[\320[\\\360\006\000\t\014\2101\330\014\024\220F\230\"\230I\240Q\240f\250A\250S\260\004\260L\300\001\300\024\300W\320La\320ah\320hi\320ij\340\014\024\220F\230\"\230D\240\001\240\026\240q\250\003\2504\250|\2701\270D\300\007\320G\\\320\\c\320cd\320de\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270C\270q\340\010\014\210E\220\025\220a\220q\330\014\020\220\005\220U\230!\2301\330\020\036\230a\230u\240F\250!\2503\250c\260\022\260=\300\001\300\021\340\014\031\230\021\330\014\021\220\021\340\014\017\210r\220\023\220A\330\020\023\2202\220S\230\001\330\024\030\230\005\230U\240!\2401\330\030!\240\021\240#\240U\250)\2601\260A\360\006\000\r\023\220$\220n\240A\320%5\260]\300!\3005\310\r\320UY\320Yd\320dg\320gh\330\020\024\220E\230\025\230a\230q\330\024\"\240!\2407\250&\260\001\260\023\260C\260r\270\031\300\"\300L\320PQ\320QT\320TW\320WY\320Yh\320hi\320ij\330\024\"\240!\2405\250\004\250A\250U\260.\300\001\300\021\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030\034\230A\330\030*\250-\260q\270\001\330\020\036\230a\330\020\026\220a\330\020\023\2202\220S\230\001\330\024\027\220r\230\023\230A\330\030\034\230E\240\025\240a\240q\330\034%\240Q\240d\250%\250y\270\001\270\021\340\014\017\210q\330\020\023\220;\230c\240\021\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025 \240\002\240!\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220T\230\023\230E\240\033\250B\250a\250q\260\003\2603\260b\270\001\330\014\030\230\001\230\023\230C\230u\240B\240g\250Q\250a\360\006\000\r\021\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\360\010\000\t\022\220""\021\330\010\021\220\021\340\010\014\210E\220\025\220a\220q\330\014\022\220!\2204\220r\230\023\230A\230V\2401\240D\250\001\330\014\022\220!\2204\220r\230\023\230A\230V\2401\240D\250\001\360\006\000\005\010\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\014\270C\270q\330?\330?\330?\330?\330Q\320QR\320RS\330\020\036\230a\330\020\026\220a\330\020\025\220Q\330\020\023\2202\220S\230\001\330\024\027\220r\230\023\230A\330\030!\240\021\240$\240e\2501\330\020\023\2202\220S\230\001\330\024*\320*<\270A\270[\310\n\320RS\320ST\330\024\030\230\001\340\014\017\210q\330\020\023\220;\230c\240\021\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025 \240\002\240!\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220S\230\003\2305\240\013\2502\250V\2601\260C\260r\270\021\330\014\030\230\001\230\023\230C\230u\240D\250\001\250\021\340\014\020\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\014\270A\270U\300!\330?\330?\330>?\330?\330?\330\230\023\230A\330\014\r\330\020\027\220q\330\020\033\2301\330\020\021\330\024\032\230$\230i\240w\250g\260Q\330\024!\240\021\330\024 \240\001\330\024!\240\021\330\024(\250\002\250#\250Q\330\024\037\230q\330\024\035\230Q""\360\006\000\016\034\2303\230a\330\014\024\220G\2305\240\013\2509\260M\300\035\320N^\320^k\320kv\360\000\000w\001C\002\360\000\000C\002M\002\360\000\000M\002a\002\360\000\000a\002c\002\360\000\000c\002f\002\360\000\000f\002g\002\340\014\022\220*\230A\230Q\340\010\013\210>\230\023\230A\330\014\r\330\020\027\220q\330\020\033\2301\330\020\021\330\024\032\230$\230i\240w\250g\260Q\330\024!\240\021\330\024 \240\001\330\024!\240\021\330\024(\250\002\250#\250Q\330\024\037\230q\330\024\035\230Q\360\006\000\016\034\2303\230a\330\014\024\220G\2305\240\013\2509\260M\300\035\310k\320Yf\320fq\320q}\360\000\000~\001H\002\360\000\000H\002\\\002\360\000\000\\\002^\002\360\000\000^\002a\002\360\000\000a\002b\002\340\014\022\220*\230A\230Q\200\001\360\016\000\t\n\330\010\t\330\010\t\330\010\t\360R\001\000\005\"\240\021\330\004!\240\021\330\004\036\230a\330\004\036\230a\330\004\033\2301\340\004\"\240!\330\004\037\230q\360\016\000\005\013\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004#\2401\340\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004%\240Q\360\010\000\005\t\210\005\210U\220!\2201\340\010\014\210E\220\025\220a\220q\330\014\021\220\022\2207\230(\240!\2403\240f\250A\250T\260\025\260g\270Q\270a\340\014\024\220B\220d\230!\2302\230W\240G\2501\250I\260Q\260d\270'\300\021\300!\330\014\024\220B\220d\230!\2302\230W\240G\2501\250I\260Q\260d\270'\300\021\300!\340\014\026\220a\220v\230Q\230d\240%\240r\250\023\250A\250Q\330\014\026\220a\220v\230Q\230d\240%\240r\250\023\250A\250Q\340\014\017\210r\220\024\220Q\220h\230c\240\022\2404\240q\250\001\330\020\030\230\001\230\023\230C\230u\240B\240d\250!\2508\2602\260V\2701\270A\330\020\034\230A\230S\240\003\2405\250\002\250'\260\021\260!\340\020\030\230\001\230\023\230C\230u\240B\240d\250!\2508\2602\260V\2701\270A\330\020\034\230A\230S\240\003\2405\250\002\250'\260\021\260!\360\006\000\r\020\210x\220q\230\003\2303\230c\240\023\240M\260\021\260!\330\020\030\230\001\230\023\230C\230v\240Q\360\006\000\005\016\210Q\330\004""\010\210\005\210U\220!\2201\330\010\016\210a\210x\220r\230\023\230A\230V\2404\240t\2501\330\010\016\210a\210x\220r\230\023\230A\230V\2404\240t\2501\340\004\014\210G\2205\230\013\2409\250L\270\003\2701\3309>\270a\3309>\270a\3309>\270a\3309E\300Q\3309?\270q\3309>\270a\3309F\300a\3309G\300q\3309M\310T\320QR\320RT\320T[\320[\\\320\\_\320_e\320ef\3309B\300!\200\001\360\014\000\t\n\330\010\t\330\010\t\330\010\t\360R\001\000\005\037\230a\330\004\036\230a\330\004\036\230a\330\004\033\2301\330\004\"\240!\330\004\037\230q\340\004\n\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004#\2401\340\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004%\240Q\360\010\000\005\t\210\005\210U\220!\2201\340\010\014\210E\220\025\220a\220q\330\014\021\220\022\2207\230(\240!\2403\240f\250A\250T\260\021\340\014\021\220\022\2204\220q\230\002\230'\240\027\250\001\250\026\250q\260\004\260G\2701\270A\340\014\023\2201\220F\230!\2304\230u\240B\240c\250\021\250!\340\014\030\230\001\230\023\230C\230u\240B\240g\250Q\250a\330\014\024\220A\220S\230\003\2305\240\002\240$\240a\240u\250B\250f\260A\260Q\360\006\000\r\020\210x\220q\230\003\2303\230c\240\023\240M\260\021\260!\330\020\030\230\001\230\023\230C\230v\240Q\360\006\000\005\016\210Q\330\004\010\210\005\210U\220!\2201\330\010\016\210a\210u\220B\220c\230\021\230&\240\001\240\024\240Q\340\004\014\210G\2205\230\013\2409\250L\270\003\2701\3309>\270a\3309>\270a\3309E\300Q\3309?\270q\3309>\270a\3309F\300a\3309G\300q\3309M\310T\320QR\320RT\320T[\320[\\\320\\_\320_e\320ef\3309B\300!\200\001\360\016\000\t\n\330\010\t\330\010\t\330\010\t\360R\001\000\005\037\230a\330\004\036\230a\330\004\036\230a\330\004\"\240!\330\004\033\2301\340\004\"\240!\330\004\037\230q\340\004\n\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004#\2401\340\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004%\240Q\360\010\000\005\t\210\005\210U\220!\2201\330\010\014\210E\220\025\220a\220q\330\014\021\220\022\2207\230(\240!\2403\240f\250A\250T""\260\021\340\014\021\220\022\2204\220q\230\002\230'\240\027\250\001\250\026\250q\260\004\260G\2701\270A\330\014\023\2201\220F\230!\2304\230u\240B\240c\250\022\2503\250b\260\002\260$\260a\260z\300\021\300#\300Q\340\014\030\230\001\230\023\230C\230u\240B\240g\250Q\250a\330\014\024\220A\220S\230\003\2305\240\002\240$\240a\240u\250B\250f\260A\260Q\360\006\000\r\020\210x\220q\230\003\2303\230c\240\023\240M\260\021\260!\330\020\030\230\001\230\023\230C\230v\240Q\360\n\000\005\016\210Q\330\004\010\210\005\210U\220!\2201\330\010\016\210a\210u\220B\220c\230\021\230&\240\001\240\024\240Q\340\004\014\210G\2205\230\013\2409\250L\270\003\2701\3309>\270a\3309>\270a\3309B\300!\3309E\300Q\3309?\270q\3309>\270a\3309F\300a\3309G\300q\3309M\310T\320QR\320RT\320T[\320[\\\320\\_\320_e\320ef\3309B\300!\200\001\360\020\000\t\n\330\010\t\330\010\t\330\010\t\360\n\000\005\"\240\021\330\004!\240\021\330\004\036\230a\330\004\036\230a\330\004!\240\021\330\004\033\2301\340\004\"\240!\330\004\037\230q\360\020\000\005\013\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004#\2401\340\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004%\240Q\360\010\000\005\t\210\005\210U\220!\2201\340\010\014\210E\220\025\220a\220q\330\014\021\220\022\2207\230(\240!\2403\240f\250A\250T\260\025\260g\270Q\270a\340\014\024\220B\220d\230!\2302\230W\240G\2501\250I\260Q\260d\270'\300\021\300!\330\014\024\220B\220d\230!\2302\230W\240G\2501\250I\260Q\260d\270'\300\021\300!\340\014\026\220a\220v\230Q\230d\240%\240r\250\023\250A\250Q\360\006\000\r\020\210r\220\024\220Q\220h\230b\240\t\250\021\250!\330\020\026\220a\340\020\026\220i\230q\240\003\2404\240q\250\006\250a\250t\2605\270\002\270#\270S\300\001\300\031\310!\3104\310u\320TU\320U]\320]a\320ag\320gi\320ij\340\014\030\230\001\230\023\230C\230u\240B\240g\250Q\250a\330\014\024\220A\220S\230\003\2305\240\002\240$\240a\240u\250B\250f\260A\260Q\360\006\000\r\020\210x\220q\230\003\2303\230c\240\023\240M\260\021\260!\330\020\030\230\001\230\023\230C\230v""\240Q\360\006\000\005\016\210Q\330\004\010\210\005\210U\220!\2201\330\010\016\210a\210x\220r\230\023\230A\230V\2404\240t\2501\330\010\016\210a\210x\220r\230\023\230A\230V\2404\240t\2501\340\004\014\210G\2205\230\013\2409\250L\270\003\2701\3309>\270a\3309>\270a\3309A\300\021\3309>\270a\3309E\300Q\3309?\270q\3309F\300a\3309G\300q\3309M\310T\320QR\320RT\320T[\320[\\\320\\_\320_e\320ef\3309B\300!\200\001\360\020\000\t\n\330\010\t\330\010\t\330\010\t\330\010\t\330\010\t\330\032\033\330\010\t\330\010\t\330\010\t\360f\001\000\005\r\210A\210Q\340\004\036\230a\330\004\036\230a\330\004\036\230a\330\004\036\230a\330\004\036\230a\330\004\036\230a\330\004\036\230a\330\004\"\240!\360\006\000\005\034\2301\230F\240!\2401\330\004\013\2102\210V\2202\220S\230\001\230\026\230r\240\031\250\"\250C\250~\270X\300Q\330\004\010\210\n\220!\330\004!\240\021\340\004\n\210\"\210F\220\"\220K\230z\250\024\250X\260Q\330\004#\2401\340\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\330\004%\240Q\340\004\020\220\002\220&\230\001\230\035\240h\250a\330\004#\2401\340\004\034\230B\230f\240A\240]\260(\270!\330\004/\250q\340\004\036\230d\240!\2401\330\004\016\210b\220\002\220!\330\004$\240A\360\006\000\005\031\230\001\360\010\000\005\032\230\023\230B\230f\240B\240i\250r\260\021\340\004\n\210\"\210G\2201\220C\220v\230R\230y\250\010\260\007\260q\270\001\330\004\017\210r\220\026\220q\230\003\2308\2408\2501\330\004\"\240!\340\004\031\230\032\2402\240Q\330\004$\240M\260\021\260!\340\004\010\210\005\210U\220!\2201\340\010\036\230a\230u\240O\2601\260D\270\001\270\023\270D\300\007\300\177\320V[\320[\\\360\006\000\t\014\2101\330\014\024\220F\230\"\230I\240Q\240f\250A\250S\260\004\260L\300\001\300\024\300W\320La\320ah\320hi\320ij\340\014\024\220F\230\"\230D\240\001\240\026\240q\250\003\2504\250|\2701\270D\300\007\320G\\\320\\c\320cd\320de\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270C\270q\330\010\014\210E\220\025\220a\220q\340\014\020\220\005\220U\230!\2301\330\020\036\230a\230u\240F""\250!\2503\250c\260\022\260=\300\001\300\021\340\014\031\230\021\330\014\021\220\021\340\014\017\210r\220\023\220A\330\020\023\2202\220S\230\001\330\024\030\230\005\230U\240!\2401\330\030!\240\021\240#\240U\250)\2601\260A\340\014\022\220$\220n\240A\320%5\260]\300!\3005\310\r\320UY\320Yd\320dg\320gh\340\020 \240\004\240A\240Q\360\006\000\021\025\220E\230\025\230a\230q\330\024.\250a\250x\260s\270\"\270N\310!\3103\310b\320PQ\330\024\"\240!\2408\2506\260\021\260#\260S\270\003\2706\300\021\300#\300S\310\002\310.\320XY\320Y]\320]^\330\035#\2401\240C\240s\250\"\320,F\300a\300u\310B\310i\320WZ\320Zf\320fg\320gj\320jm\320mo\320o~\320~\177\360\000\000@\002A\002\330\024\"\240!\2405\250\004\250A\250U\260.\300\001\300\021\330\024\031\230\021\340\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\020\036\230a\330\020\026\220a\340\020\023\2202\220S\230\001\330\024\027\220r\230\023\230A\330\030\034\230E\240\025\240a\240q\330\034%\240Q\240d\250%\250y\270\001\270\021\340\014\017\210q\330\020\023\220;\230c\240\021\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025 \240\002\240!\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\030\230\001\230\023\230C\230u\240B\240g\250Q\250a\330\014\024\220A\220S\230\003\2305\240\013\2502\250V\2601\260C\260s\270\"\270A\340\014\020\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\360\006\000\005\016\210Q\330\004\r\210Q\360\006\000\005\t\210\005\210U\220!\2201\330\010\016\210a\210t\2202\220S\230\001\230\026\230q\240\004\240A\330\010\016\210a\210t\2202\220S\230\001\230\026\230q\240\004\240A\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\014\270C\270q\330?\330?\330\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]\270!\2705\300\003\3002\300R\300}\320TU\320UV\330\020\034\230A\230S\240\003\2406\250\021\360\006\000\r\026\220S\230\002\230-\240q\250\003\2503\250h\260a\260s\270\"\270B\270c\300\035\310a\310q\330\014\025\220S\230\002\230-\240q\250\003\2503\250h\260a\260s\270\"\270B\270c\300\035\310a\310q\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\026\220a\330\020\027\220u\230E\240\023\240B\240m\2601\260F\270%\270u\300C\300}\320TU\320U[\320[`\320`e\320eh\320hi\330\024\035\230X\240Q\240c\250\022\2509\260C\260x\270r\300\037\320PQ\320QR\330\024\034\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c\250\023\250D\260\002\260#\260S\270\003\2702\270S\300\001\330\020\026\220a\330\020\027\220u\230E\240\023\240B\240m\2601\260F\270%\270u\300C\300}\320TU\320U[\320[`\320`e\320eh\320hi\330\024\035\230X\240Q\240c\250\022\2509\260C\260x\270r\300\037\320PQ\320QR\330\024\034\230A\330\024\033\2301\330\024\031\230\021\330\024\027\220r\230\023\230A\330\030*\250-\260q\270\001\330\030\034\230A\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240e\2505\260\001\360\006\000\r\021\220\014\230A\230S\240\003\2403\240c""\250\021\330\020\026\220a\330\020\026\220a\330\020\025\220Q\340\020\026\220a\330\020\026\220a\330\020\025\220Q\340\014\017\210q\330\020\023\2204\220s\230!\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025\031\230\021\230%\230u\240B\240a\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\340\014\024\220A\220S\230\003\2305\240\004\240A\240U\250%\250r\260\026\260q\270\003\2702\270Q\330\014\031\230\021\230#\230S\240\005\240T\250\022\2506\260\021\260!\330\014\030\230\001\230\023\230C\230u\240D\250\002\250&\260\001\260\021\360\016\000\r\020\210}\230A\230T\240\023\240A\330\020\023\220>\240\023\240C\240q\330\024 \240\001\240\023\240C\240v\250Q\340\021\037\230s\240%\240t\2502\250]\270!\2705\300\003\3002\300R\300}\320TU\320UV\330\020\034\230A\230S\240\003\2406\250\021\340\014\020\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\020\030\230\001\230\023\230C\230v\240Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\013\2709\300L\320PQ\330\020\034\230A\230V\2401\330\034#\2401\330\034#\2401\330\034!\240\021\330\034\"\240!\330\034#\2401\330\034#\2401\330\034!\240\021\330\034(\250\001\330\034!\240\021\330\036\037\330\034'\240q\330\034%\240Q\330\034)\250\021\330\034(\250\001\330\034)\250\021\330\0341\260\034\270Q\330\0340\260\001\260\023\260C\260s\270!\330\034*\250!\330\034(\250\001\330\t\027\220s\230!\330\010\020\220\007\220u\230K\240y\260\013\2709\300L\320PQ\330\020\035\230]\250!\330\0351\260\021\260#\260S\270\003\2701\330\0352\260,\270a\330\035*\250!\330\035)\250\021\360\006\000\t\017\210j\230\001\230\021\200\001\360\024\000\030\031\330\027\030\330\027\030\330\027\030\330\027\030\330\027\030\330\027\030\330)*\330\027\030\330\027\030\330\027\030\360j\001\000\005\r\210A\210Q\340\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\034\230A\330\004\035\230Q\330\004\035\230Q\330\004\033\2301\330\004\"\240!\330\004\033\2301\330\004\n\210\"\210F\220\"\220K\230z\250\024""\250X\260Q\330\004\016\210b\220\006\220b\230\013\240:\250T\260\030\270\022\2701\340\004#\2401\330\004%\240Q\330\004\036\230a\360\006\000\005\014\2102\210V\2202\220S\230\001\230\026\230r\240\031\250\"\250C\250t\2608\2701\330\004\010\210\n\220!\330\004!\240\021\340\004\036\230d\240!\2401\360\010\000\005\032\230\023\230B\230f\240B\240i\250r\260\021\330\004\n\210\"\210G\2201\220C\220v\230R\230y\250\010\260\007\260q\270\001\330\004\017\210r\220\026\220q\230\003\2308\2408\2501\330\004\"\240!\360\010\000\005\031\230\001\340\004$\240M\260\021\260!\340\004\010\210\005\210U\220!\2201\340\010\036\230a\230u\240O\2601\260D\270\001\270\023\270D\300\007\300\177\320V[\320[\\\360\006\000\t\014\2101\330\014\024\220F\230\"\230I\240Q\240f\250A\250T\260\034\270Q\270d\300'\320I^\320^e\320ef\320fg\340\014\024\220F\230\"\230D\240\001\240\026\240q\250\004\250L\270\001\270\024\270W\320DY\320Y`\320`a\320ab\340\010\032\230!\2307\240-\250q\260\003\2602\260V\2701\270A\330\010\022\220-\230r\240\026\240q\250\001\340\010\014\210E\220\025\220a\220q\330\014\035\230Q\330\014\031\230\021\330\014\021\220\021\360\006\000\r\025\220C\220r\230\035\240a\240s\250#\250W\260A\260S\270\002\270\"\270C\270}\310A\310Q\340\014\017\210r\220\023\220A\330\020\023\2202\220S\230\001\330\024\035\230Q\230c\240\025\240a\340\014\022\220$\220e\2303\230b\240\r\250Q\250d\260$\260d\270#\270]\310!\3104\310t\320S^\320^a\320ab\330\020\030\230\007\230q\240\003\2402\240Y\250c\260\030\270\022\270?\310!\3101\330\020\036\230a\330\020\026\220a\330\020\025\220Q\340\020\023\2202\220S\230\001\330\024&\240m\2601\260A\330\024\030\230\001\340\020\023\2202\220S\230\001\330\024\027\220r\230\023\230A\330\030!\240\021\240$\240e\2501\360\006\000\r\020\210{\230#\230Q\340\020\023\220=\240\001\240\024\240S\250\001\330\024\027\220~\240S\250\003\2501\330\030$\240A\240S\250\003\2506\260\021\330\025#\2403\240e\2504\250r\260\035\270a\270u\300C\300r\310\022\310=\320XY\320YZ\330\030$\240A\240S\250\003\2506\260\021\360\010\000\021\024\220<\230q\240\003\2403""\240c\250\023\250A\330\024\027\220~\240S\250\003\2508\2601\260A\330\030$\240A\240S\250\003\2506\260\021\340\024\027\220~\240S\250\003\2508\2601\260A\330\030$\240A\240S\250\003\2506\260\021\330\020\030\230\001\230\023\230C\230u\240A\330\020!\240\021\360\006\000\021\024\220=\240\001\240\024\240S\250\001\330\024\027\220~\240S\250\003\2501\330\030$\240A\240S\250\003\2506\260\021\340\025#\2403\240e\2504\250r\260\035\270a\270u\300C\300r\310\022\310=\320XY\320YZ\330\024 \240\001\240\023\240C\240v\250Q\340\020\031\230\023\230B\230m\2501\250D\260\003\2608\2701\270C\270r\300\022\3003\300m\320ST\320TU\330\020\031\230\023\230B\230m\2501\250D\260\003\2608\2701\270C\270r\300\022\3003\300m\320ST\320TU\340\020\026\220a\330\020\036\230a\330\020\026\220a\330\020\036\230a\360\006\000\021\024\220<\230q\240\003\2403\240c\250\023\250A\340\024\030\230\005\230S\240\r\250Q\250e\2604\260u\270F\300#\300R\300}\320TU\320UV\330\030\033\230>\250\023\250B\250h\260a\260q\330\034(\250\001\250\023\250C\250v\260Q\330\030)\250\021\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240d\250%\250q\360\006\000\025\031\230\005\230S\240\r\250Q\250e\2604\260u\270F\300#\300R\300}\320TU\320UV\330\030\033\230>\250\023\250B\250h\260a\260q\330\034(\250\001\250\023\250C\250v\260Q\330\030)\250\021\340\024\027\220r\230\023\230A\330\030\033\2302\230S\240\001\330\034%\240Q\240d\250%\250q\360\006\000\021\025\220L\240\001\240\023\240C\240s\250#\250S\260\004\260B\260c\270\023\270C\270r\300\023\300A\330\024\033\2305\240\006\240c\250\022\250=\270\001\270\027\300\005\300U\310#\310]\320Z[\320[a\320af\320fr\320ru\320uv\330\030!\240\030\250\021\250#\250R\250y\270\003\2708\3002\300_\320TU\320UV\330\030'\240q\330\030\037\230q\330\030\035\230Q\330\030\033\2302\230S\240\001\330\034.\250m\2701\270A\330\034 \240\001\340\030\033\2302\230S\240\001\330\034\037\230r\240\023\240A\330 )\250\021\250%\250u\260A\360\006\000\021\025\220L\240\001\240\023\240C\240s\250#\250S\260\004\260B\260c\270\023\270C\270r\300\023""\300A\330\024\033\2305\240\006\240c\250\022\250=\270\001\270\027\300\005\300U\310#\310]\320Z[\320[a\320af\320fr\320ru\320uv\330\030!\240\030\250\021\250#\250R\250y\270\003\2708\3002\300_\320TU\320UV\330\030'\240q\330\030\037\230q\330\030\035\230Q\330\030\033\2302\230S\240\001\330\034.\250m\2701\270A\330\034 \240\001\340\030\033\2302\230S\240\001\330\034\037\230r\240\023\240A\330 )\250\021\250%\250u\260A\360\006\000\021\025\220L\240\001\240\023\240C\240s\250#\250Q\330\024!\240\021\330\024\031\230\021\330\024\032\230!\340\024!\240\021\330\024\031\230\021\330\024\032\230!\340\014\017\210q\330\020\023\220;\230c\240\021\330\024\037\230~\250S\260\002\260$\260b\270\001\330\025 \240\002\240!\330\024 \240\004\240B\240n\260D\270\002\270!\340\024\037\230q\340\020\033\2301\360\006\000\r\025\220A\220S\230\003\2305\240\013\2502\250V\2601\260C\260r\270\021\360\006\000\r\021\220\010\230\001\230\023\230C\230s\240#\240]\260!\2604\260s\270-\300q\310\003\3103\310a\330\024\034\230A\230S\240\003\2406\250\021\360\016\000\r\020\210t\2201\330\020\023\220=\240\001\240\024\240S\250\001\330\024\027\220~\240S\250\003\2501\330\030$\240A\240S\250\003\2506\260\021\340\025#\2403\240e\2504\250r\260\035\270a\270u\300C\300r\310\022\310=\320XY\320YZ\330\024 \240\001\240\023\240C\240v\250Q\340\004\007\200~\220S\230\001\330\010\020\220\007\220u\230K\240y\260\014\270A\270V\3001\330?\330__pyx_string_tab; + Py_ssize_t pos = 0; + for (int i = 0; i < 360; i++) { + Py_ssize_t bytes_length = index[i].length; + PyObject *string = PyUnicode_DecodeUTF8(bytes + pos, bytes_length, NULL); + if (likely(string) && i >= 51) PyUnicode_InternInPlace(&string); + if (unlikely(!string)) { + Py_XDECREF(data); + __PYX_ERR(0, 1, __pyx_L1_error) + } + stringtab[i] = string; + pos += bytes_length; + } + for (int i = 360; i < 385; i++) { + Py_ssize_t bytes_length = index[i].length; + PyObject *string = PyBytes_FromStringAndSize(bytes + pos, bytes_length); + stringtab[i] = string; + pos += bytes_length; + if (unlikely(!string)) { + Py_XDECREF(data); + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + Py_XDECREF(data); + for (Py_ssize_t i = 0; i < 385; i++) { + if (unlikely(PyObject_Hash(stringtab[i]) == -1)) { + __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = stringtab + 360; + for (Py_ssize_t i=0; i<25; ++i) { + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL); + #else + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + } + { + PyObject **numbertab = __pyx_mstate->__pyx_number_tab; + double const c_constants[] = {0.0}; + for (int i = 0; i < 1; i++) { + numbertab[i] = PyFloat_FromDouble(c_constants[i]); + if (unlikely(!numbertab[i])) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + { + PyObject **numbertab = __pyx_mstate->__pyx_number_tab + 1; + int8_t const cint_constants_1[] = {0,-1,1,2,3,20}; + int16_t const cint_constants_2[] = {-999}; + int32_t const cint_constants_4[] = {136983863L}; + for (int i = 0; i < 8; i++) { + numbertab[i] = PyLong_FromLong((i < 6 ? cint_constants_1[i - 0] : (i < 7 ? cint_constants_2[i - 6] : cint_constants_4[i - 7]))); + if (unlikely(!numbertab[i])) __PYX_ERR(0, 1, __pyx_L1_error) + } + } + #if CYTHON_IMMORTAL_CONSTANTS + { + PyObject **table = __pyx_mstate->__pyx_number_tab; + for (Py_ssize_t i=0; i<9; ++i) { + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + Py_SET_REFCNT(table[i], _Py_IMMORTAL_REFCNT_LOCAL); + #else + Py_SET_REFCNT(table[i], _Py_IMMORTAL_INITIAL_REFCNT); + #endif + } + } + #endif + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: init_codeobjects ### */ +typedef struct { + unsigned int argcount : 5; + unsigned int num_posonly_args : 1; + unsigned int num_kwonly_args : 1; + unsigned int nlocals : 7; + unsigned int flags : 10; + unsigned int first_line : 13; +} __Pyx_PyCode_New_function_description; +/* NewCodeObj.proto */ +static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + PyObject *line_table, + PyObject *tuple_dedup_map +); + + +static int __Pyx_CreateCodeObjects(__pyx_mstatetype *__pyx_mstate) { + PyObject* tuple_dedup_map = PyDict_New(); + if (unlikely(!tuple_dedup_map)) return -1; + { + const __Pyx_PyCode_New_function_description descr = {16, 0, 0, 47, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 187}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_sz, __pyx_mstate->__pyx_n_u_sv, __pyx_mstate->__pyx_n_u_st, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_sz_view, __pyx_mstate->__pyx_n_u_sv_view, __pyx_mstate->__pyx_n_u_st_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_t_tmp, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_drift_increment, __pyx_mstate->__pyx_n_u_gaussian_values}; + __pyx_mstate_global->__pyx_codeobj_tab[0] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_full_ddm_hddm_base, __pyx_mstate->__pyx_kp_b_iso88591_AQ_A_1_1_1_A_A_A_1_2V2S_r_Ct81, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[0])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {13, 0, 0, 38, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 368}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_gaussian_values}; + __pyx_mstate_global->__pyx_codeobj_tab[1] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm, __pyx_mstate->__pyx_kp_b_iso88591_AQ_1_1_1_1_1_2V2S_r_Ct81_F_Kz_X, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[1])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {16, 0, 0, 46, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 515}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[2] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_flexbound, __pyx_mstate->__pyx_kp_b_iso88591_AQ_A_1_1_1_1_2V2S_r_Ct81_F_Kz_X, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[2])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {18, 0, 0, 52, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 682}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_drift_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_drift_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_drift, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_drift_view, __pyx_mstate->__pyx_n_u_drift_params_tmp, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[3] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_flex, __pyx_mstate->__pyx_kp_b_iso88591_D_AQ_1_1_1_1_1_2V2S_r_Ct81_F_Kz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[3])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {17, 0, 0, 48, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 864}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_alpha, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_alpha_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_alpha, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_alpha_stable_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[4] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_levy_flexbound, __pyx_mstate->__pyx_kp_b_iso88591_B_AQ_A_1_1_q_1_1_2V2S_r_Ct81_F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[4])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {19, 0, 0, 57, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 1027}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_z_dist, __pyx_mstate->__pyx_n_u_v_dist, __pyx_mstate->__pyx_n_u_t_dist, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_sz_samplewise, __pyx_mstate->__pyx_n_u_sv_samplewise, __pyx_mstate->__pyx_n_u_st_samplewise, __pyx_mstate->__pyx_n_u_sz_samplewise_view, __pyx_mstate->__pyx_n_u_sv_samplewise_view, __pyx_mstate->__pyx_n_u_st_samplewise_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_t_tmp, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_drift_increment, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[5] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_full_ddm_rv, __pyx_mstate->__pyx_kp_b_iso88591_F_AQ_1_1_1_1_1_BfBj_HA_BfBj_HA, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[5])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {19, 0, 0, 54, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 1233}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_sz, __pyx_mstate->__pyx_n_u_sv, __pyx_mstate->__pyx_n_u_st, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_sz_view, __pyx_mstate->__pyx_n_u_sv_view, __pyx_mstate->__pyx_n_u_st_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_t_tmp, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_drift_increment, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[6] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_full_ddm, __pyx_mstate->__pyx_kp_b_iso88591_F_AQ_A_1_1_1_A_A_A_1_2V2S_r_Ct8, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[6])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {17, 0, 0, 49, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 1430}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_sv, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_sv_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_drift_increment, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[7] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_sdv, __pyx_mstate->__pyx_kp_b_iso88591_B_AQ_2V2S_r_Ct81_A_1_1_1_A_1_F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[7])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {17, 0, 0, 48, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 1611}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_g, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_g_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[8] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ornstein_uhlenbeck, __pyx_mstate->__pyx_kp_b_iso88591_B_AQ_2V2S_r_Ct81_A_1_1_1_1_1_F, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[8])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {16, 0, 0, 54, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 1819}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_sqrt_st_view, __pyx_mstate->__pyx_n_u_n_particles, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_particles, __pyx_mstate->__pyx_n_u_particles_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_num_steps, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_j, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_v_dict, __pyx_mstate->__pyx_n_u_z_dict, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[9] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_race_model, __pyx_mstate->__pyx_kp_b_iso88591_AQ_a_a_a_a_a_d_1_m2Q_A_1F_1_F_K, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[9])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {18, 0, 0, 61, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 2008}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_g, __pyx_mstate->__pyx_n_u_b, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_g_view, __pyx_mstate->__pyx_n_u_b_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_n_particles, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_particles, __pyx_mstate->__pyx_n_u_particles_view, __pyx_mstate->__pyx_n_u_particles_reduced_sum, __pyx_mstate->__pyx_n_u_particles_reduced_sum_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_sqrt_st_view, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_t_par, __pyx_mstate->__pyx_n_u_particles_sum, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_num_steps, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_v_dict, __pyx_mstate->__pyx_n_u_z_dict, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[10] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_lca, __pyx_mstate->__pyx_kp_b_iso88591_f_AQ_a_a_a_a_a_a_a_1F_1_2V2S_r, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[10])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {21, 0, 0, 63, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 2229}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_vh, __pyx_mstate->__pyx_n_u_vl1, __pyx_mstate->__pyx_n_u_vl2, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_zh, __pyx_mstate->__pyx_n_u_zl1, __pyx_mstate->__pyx_n_u_zl2, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_print_info, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_vh_view, __pyx_mstate->__pyx_n_u_vl1_view, __pyx_mstate->__pyx_n_u_vl2_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_zh_view, __pyx_mstate->__pyx_n_u_zl1_view, __pyx_mstate->__pyx_n_u_zl2_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_decision_taken, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_y_h, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_t_particle1, __pyx_mstate->__pyx_n_u_t_particle2, __pyx_mstate->__pyx_n_u_y_l, __pyx_mstate->__pyx_n_u_y_l1, __pyx_mstate->__pyx_n_u_y_l2, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_ix1, __pyx_mstate->__pyx_n_u_ix2, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[11] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_flexbound_seq2, __pyx_mstate->__pyx_kp_b_iso88591_j_AQ_A_Q_Q_1_A_Q_Q_1_1_F_Kz_XQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[11])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {21, 0, 0, 70, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 2543}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_vh, __pyx_mstate->__pyx_n_u_vl1, __pyx_mstate->__pyx_n_u_vl2, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_zh, __pyx_mstate->__pyx_n_u_zl1, __pyx_mstate->__pyx_n_u_zl2, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_print_info, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_vh_view, __pyx_mstate->__pyx_n_u_vl1_view, __pyx_mstate->__pyx_n_u_vl2_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_zh_view, __pyx_mstate->__pyx_n_u_zl1_view, __pyx_mstate->__pyx_n_u_zl2_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_rts_high, __pyx_mstate->__pyx_n_u_rts_low, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_rts_high_view, __pyx_mstate->__pyx_n_u_rts_low_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_y_h, __pyx_mstate->__pyx_n_u_y_l, __pyx_mstate->__pyx_n_u_y_l1, __pyx_mstate->__pyx_n_u_y_l2, __pyx_mstate->__pyx_n_u_v_l, __pyx_mstate->__pyx_n_u_v_l1, __pyx_mstate->__pyx_n_u_v_l2, __pyx_mstate->__pyx_n_u_t_h, __pyx_mstate->__pyx_n_u_t_l, __pyx_mstate->__pyx_n_u_t_l1, __pyx_mstate->__pyx_n_u_t_l2, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_ix1, __pyx_mstate->__pyx_n_u_ix2, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[12] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_flexbound_par2, __pyx_mstate->__pyx_kp_b_iso88591_j_AQ_A_Q_Q_1_A_Q_Q_1_1_2V2S_r_C, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[12])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {24, 0, 0, 84, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 2825}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_vh, __pyx_mstate->__pyx_n_u_vl1, __pyx_mstate->__pyx_n_u_vl2, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_zh, __pyx_mstate->__pyx_n_u_zl1, __pyx_mstate->__pyx_n_u_zl2, __pyx_mstate->__pyx_n_u_d, __pyx_mstate->__pyx_n_u_g, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s_pre_high_level_choice, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_print_info, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_vh_view, __pyx_mstate->__pyx_n_u_vl1_view, __pyx_mstate->__pyx_n_u_vl2_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_zh_view, __pyx_mstate->__pyx_n_u_zl1_view, __pyx_mstate->__pyx_n_u_zl2_view, __pyx_mstate->__pyx_n_u_d_view, __pyx_mstate->__pyx_n_u_g_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_s_pre_high_level_choice_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_low, __pyx_mstate->__pyx_n_u_rts_high, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_rts_high_view, __pyx_mstate->__pyx_n_u_rts_low_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_bias_trace_l1, __pyx_mstate->__pyx_n_u_bias_trace_l2, __pyx_mstate->__pyx_n_u_bias_trace_l1_view, __pyx_mstate->__pyx_n_u_bias_trace_l2_view, __pyx_mstate->__pyx_n_u_y_h, __pyx_mstate->__pyx_n_u_y_l, __pyx_mstate->__pyx_n_u_y_l1, __pyx_mstate->__pyx_n_u_y_l2, __pyx_mstate->__pyx_n_u_v_l, __pyx_mstate->__pyx_n_u_v_l1, __pyx_mstate->__pyx_n_u_v_l2, __pyx_mstate->__pyx_n_u_t_h, __pyx_mstate->__pyx_n_u_t_l, __pyx_mstate->__pyx_n_u_t_l1, __pyx_mstate->__pyx_n_u_t_l2, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_ix1, __pyx_mstate->__pyx_n_u_ix2, __pyx_mstate->__pyx_n_u_ix_l, __pyx_mstate->__pyx_n_u_ix_tmp, __pyx_mstate->__pyx_n_u_ix1_tmp, __pyx_mstate->__pyx_n_u_ix2_tmp, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[13] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_flexbound_mic2_ornstein, __pyx_mstate->__pyx_kp_b_iso88591_23_l_AQ_A_Q_Q_1_A_Q_Q_1_1_1_1_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[13])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {22, 0, 0, 80, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 3166}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_vh, __pyx_mstate->__pyx_n_u_vl1, __pyx_mstate->__pyx_n_u_vl2, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_zh, __pyx_mstate->__pyx_n_u_zl1, __pyx_mstate->__pyx_n_u_zl2, __pyx_mstate->__pyx_n_u_d, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_print_info, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_vh_view, __pyx_mstate->__pyx_n_u_vl1_view, __pyx_mstate->__pyx_n_u_vl2_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_zh_view, __pyx_mstate->__pyx_n_u_zl1_view, __pyx_mstate->__pyx_n_u_zl2_view, __pyx_mstate->__pyx_n_u_d_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_low, __pyx_mstate->__pyx_n_u_rts_high, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_rts_high_view, __pyx_mstate->__pyx_n_u_rts_low_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_bias_trace_l1, __pyx_mstate->__pyx_n_u_bias_trace_l2, __pyx_mstate->__pyx_n_u_bias_trace_l1_view, __pyx_mstate->__pyx_n_u_bias_trace_l2_view, __pyx_mstate->__pyx_n_u_y_h, __pyx_mstate->__pyx_n_u_y_l, __pyx_mstate->__pyx_n_u_y_l1, __pyx_mstate->__pyx_n_u_y_l2, __pyx_mstate->__pyx_n_u_v_l, __pyx_mstate->__pyx_n_u_v_l1, __pyx_mstate->__pyx_n_u_v_l2, __pyx_mstate->__pyx_n_u_t_h, __pyx_mstate->__pyx_n_u_t_l, __pyx_mstate->__pyx_n_u_t_l1, __pyx_mstate->__pyx_n_u_t_l2, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_ix1, __pyx_mstate->__pyx_n_u_ix2, __pyx_mstate->__pyx_n_u_ix_l, __pyx_mstate->__pyx_n_u_ix_tmp, __pyx_mstate->__pyx_n_u_ix1_tmp, __pyx_mstate->__pyx_n_u_ix2_tmp, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[14] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_flexbound_mic2_multinoise, __pyx_mstate->__pyx_kp_b_iso88591_45_AQ_A_Q_Q_1_A_Q_Q_1_1_1_F_Kz, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[14])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {23, 0, 0, 82, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 3514}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_vh, __pyx_mstate->__pyx_n_u_vl1, __pyx_mstate->__pyx_n_u_vl2, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_zh, __pyx_mstate->__pyx_n_u_zl1, __pyx_mstate->__pyx_n_u_zl2, __pyx_mstate->__pyx_n_u_d, __pyx_mstate->__pyx_n_u_g, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_print_info, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_vh_view, __pyx_mstate->__pyx_n_u_vl1_view, __pyx_mstate->__pyx_n_u_vl2_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_zh_view, __pyx_mstate->__pyx_n_u_zl1_view, __pyx_mstate->__pyx_n_u_zl2_view, __pyx_mstate->__pyx_n_u_d_view, __pyx_mstate->__pyx_n_u_g_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_low, __pyx_mstate->__pyx_n_u_rts_high, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_rts_high_view, __pyx_mstate->__pyx_n_u_rts_low_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_bias_trace_l1, __pyx_mstate->__pyx_n_u_bias_trace_l2, __pyx_mstate->__pyx_n_u_bias_trace_l1_view, __pyx_mstate->__pyx_n_u_bias_trace_l2_view, __pyx_mstate->__pyx_n_u_y_h, __pyx_mstate->__pyx_n_u_y_l, __pyx_mstate->__pyx_n_u_y_l1, __pyx_mstate->__pyx_n_u_y_l2, __pyx_mstate->__pyx_n_u_v_l, __pyx_mstate->__pyx_n_u_v_l1, __pyx_mstate->__pyx_n_u_v_l2, __pyx_mstate->__pyx_n_u_t_h, __pyx_mstate->__pyx_n_u_t_l, __pyx_mstate->__pyx_n_u_t_l1, __pyx_mstate->__pyx_n_u_t_l2, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_ix1, __pyx_mstate->__pyx_n_u_ix2, __pyx_mstate->__pyx_n_u_ix_l, __pyx_mstate->__pyx_n_u_ix_tmp, __pyx_mstate->__pyx_n_u_ix1_tmp, __pyx_mstate->__pyx_n_u_ix2_tmp, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[15] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_flexbound_mic2_ornstein_mult, __pyx_mstate->__pyx_kp_b_iso88591_AQ_A_Q_Q_1_A_Q_Q_1_1_1_1_F_Kz_X, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[15])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {10, 0, 0, 28, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 3857}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_sd, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_nact, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_sd_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_zs, __pyx_mstate->__pyx_n_u_vs, __pyx_mstate->__pyx_n_u_x_t, __pyx_mstate->__pyx_n_u_v_dict}; + __pyx_mstate_global->__pyx_codeobj_tab[16] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_lba_vanilla, __pyx_mstate->__pyx_kp_b_iso88591_R_a_a_a_1_q_F_Kz_XQ_1_b_b_T_1_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[16])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {11, 0, 0, 30, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 3958}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_theta, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_sd, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_nact, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_theta_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_sd_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_zs, __pyx_mstate->__pyx_n_u_vs, __pyx_mstate->__pyx_n_u_x_t, __pyx_mstate->__pyx_n_u_v_dict}; + __pyx_mstate_global->__pyx_codeobj_tab[17] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_lba_angle, __pyx_mstate->__pyx_kp_b_iso88591_R_a_a_a_1_q_F_Kz_XQ_1_b_b_T_1_Q_2, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[17])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {12, 0, 0, 35, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 4062}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v_RL, __pyx_mstate->__pyx_n_u_v_WM, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_t_WM, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_sd, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_nact, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_RL_view, __pyx_mstate->__pyx_n_u_v_WM_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_WM_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_sd_view, __pyx_mstate->__pyx_n_u_zs, __pyx_mstate->__pyx_n_u_x_t_RL, __pyx_mstate->__pyx_n_u_x_t_WM, __pyx_mstate->__pyx_n_u_vs_RL, __pyx_mstate->__pyx_n_u_vs_WM, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_x_t, __pyx_mstate->__pyx_n_u_v_dict}; + __pyx_mstate_global->__pyx_codeobj_tab[18] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_rlwm_lba_pw_v1, __pyx_mstate->__pyx_kp_b_iso88591_a_a_1_q_F_Kz_XQ_1_b_b_T_1_Q_U_1, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[18])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {11, 0, 0, 32, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 4145}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v_RL, __pyx_mstate->__pyx_n_u_v_WM, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_z, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_sd, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_nact, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_RL_view, __pyx_mstate->__pyx_n_u_v_WM_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_z_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_sd_view, __pyx_mstate->__pyx_n_u_zs, __pyx_mstate->__pyx_n_u_x_t_RL, __pyx_mstate->__pyx_n_u_x_t_WM, __pyx_mstate->__pyx_n_u_vs_RL, __pyx_mstate->__pyx_n_u_vs_WM, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_i, __pyx_mstate->__pyx_n_u_v_dict}; + __pyx_mstate_global->__pyx_codeobj_tab[19] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_rlwm_lba_race, __pyx_mstate->__pyx_kp_b_iso88591_R_a_a_1_q_F_Kz_XQ_1_b_b_T_1_Q_U, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[19])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {23, 0, 0, 82, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 4263}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_vh, __pyx_mstate->__pyx_n_u_vl1, __pyx_mstate->__pyx_n_u_vl2, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_zh, __pyx_mstate->__pyx_n_u_zl1, __pyx_mstate->__pyx_n_u_zl2, __pyx_mstate->__pyx_n_u_d, __pyx_mstate->__pyx_n_u_g, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_print_info, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_vh_view, __pyx_mstate->__pyx_n_u_vl1_view, __pyx_mstate->__pyx_n_u_vl2_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_zh_view, __pyx_mstate->__pyx_n_u_zl1_view, __pyx_mstate->__pyx_n_u_zl2_view, __pyx_mstate->__pyx_n_u_d_view, __pyx_mstate->__pyx_n_u_g_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_low, __pyx_mstate->__pyx_n_u_rts_high, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_rts_high_view, __pyx_mstate->__pyx_n_u_rts_low_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_bias_trace_l1, __pyx_mstate->__pyx_n_u_bias_trace_l2, __pyx_mstate->__pyx_n_u_bias_trace_l1_view, __pyx_mstate->__pyx_n_u_bias_trace_l2_view, __pyx_mstate->__pyx_n_u_y_h, __pyx_mstate->__pyx_n_u_y_l, __pyx_mstate->__pyx_n_u_y_l1, __pyx_mstate->__pyx_n_u_y_l2, __pyx_mstate->__pyx_n_u_v_l, __pyx_mstate->__pyx_n_u_v_l1, __pyx_mstate->__pyx_n_u_v_l2, __pyx_mstate->__pyx_n_u_t_h, __pyx_mstate->__pyx_n_u_t_l, __pyx_mstate->__pyx_n_u_t_l1, __pyx_mstate->__pyx_n_u_t_l2, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_ix1, __pyx_mstate->__pyx_n_u_ix2, __pyx_mstate->__pyx_n_u_ix_l, __pyx_mstate->__pyx_n_u_ix_tmp, __pyx_mstate->__pyx_n_u_ix1_tmp, __pyx_mstate->__pyx_n_u_ix2_tmp, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[20] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_flexbound_mic2_unnormalized, __pyx_mstate->__pyx_kp_b_iso88591_9_898989898989JK898989_AQ_A_Q_Q, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[20])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {22, 0, 0, 62, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 4606}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_vh, __pyx_mstate->__pyx_n_u_vl1, __pyx_mstate->__pyx_n_u_vl2, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_zh, __pyx_mstate->__pyx_n_u_zl1, __pyx_mstate->__pyx_n_u_zl2, __pyx_mstate->__pyx_n_u_d, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_deadline, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_print_info, __pyx_mstate->__pyx_n_u_boundary_fun, __pyx_mstate->__pyx_n_u_boundary_multiplicative, __pyx_mstate->__pyx_n_u_boundary_params, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_vh_view, __pyx_mstate->__pyx_n_u_vl1_view, __pyx_mstate->__pyx_n_u_vl2_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_zh_view, __pyx_mstate->__pyx_n_u_zl1_view, __pyx_mstate->__pyx_n_u_zl2_view, __pyx_mstate->__pyx_n_u_d_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_deadline_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_t_s, __pyx_mstate->__pyx_n_u_boundary, __pyx_mstate->__pyx_n_u_boundary_view, __pyx_mstate->__pyx_n_u_bias_trace, __pyx_mstate->__pyx_n_u_bias_trace_view, __pyx_mstate->__pyx_n_u_y_h, __pyx_mstate->__pyx_n_u_y_l, __pyx_mstate->__pyx_n_u_v_l, __pyx_mstate->__pyx_n_u_t_h, __pyx_mstate->__pyx_n_u_t_l, __pyx_mstate->__pyx_n_u_tmp_pos_dep, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_deadline_tmp, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_ix_tmp, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_boundary_params_tmp, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_key}; + __pyx_mstate_global->__pyx_codeobj_tab[21] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_ddm_flexbound_tradeoff, __pyx_mstate->__pyx_kp_b_iso88591_AQ_A_Q_Q_1_A_Q_Q_1_1_1_F_Kz_XQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[21])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {11, 0, 0, 28, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 4880}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_mu, __pyx_mstate->__pyx_n_u_sigma, __pyx_mstate->__pyx_n_u_tau, __pyx_mstate->__pyx_n_u_p, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_race, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_rng, __pyx_mstate->__pyx_n_u_n_choices, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_rt_candidates, __pyx_mstate->__pyx_n_u_c, __pyx_mstate->__pyx_n_u_mu_val, __pyx_mstate->__pyx_n_u_sigma_val, __pyx_mstate->__pyx_n_u_tau_val, __pyx_mstate->__pyx_n_u_norm_sample, __pyx_mstate->__pyx_n_u_exp_sample, __pyx_mstate->__pyx_n_u_rt_val, __pyx_mstate->__pyx_n_u_choice_idx, __pyx_mstate->__pyx_n_u_random_val}; + __pyx_mstate_global->__pyx_codeobj_tab[22] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_exgauss, __pyx_mstate->__pyx_kp_b_iso88591_G_q_81D_a_BhawfA_HAU_3fA_r_s_Rw, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[22])) goto bad; + } + { + const __Pyx_PyCode_New_function_description descr = {13, 0, 0, 42, (unsigned int)(CO_OPTIMIZED|CO_NEWLOCALS|CO_VARKEYWORDS), 5022}; + PyObject* const varnames[] = {__pyx_mstate->__pyx_n_u_v, __pyx_mstate->__pyx_n_u_a, __pyx_mstate->__pyx_n_u_t, __pyx_mstate->__pyx_n_u_p, __pyx_mstate->__pyx_n_u_s, __pyx_mstate->__pyx_n_u_delta_t, __pyx_mstate->__pyx_n_u_max_t, __pyx_mstate->__pyx_n_u_n_samples, __pyx_mstate->__pyx_n_u_n_trials, __pyx_mstate->__pyx_n_u_random_state, __pyx_mstate->__pyx_n_u_return_option, __pyx_mstate->__pyx_n_u_smooth_unif, __pyx_mstate->__pyx_n_u_race, __pyx_mstate->__pyx_n_u_kwargs, __pyx_mstate->__pyx_n_u_v_view, __pyx_mstate->__pyx_n_u_a_view, __pyx_mstate->__pyx_n_u_t_view, __pyx_mstate->__pyx_n_u_p_view, __pyx_mstate->__pyx_n_u_s_view, __pyx_mstate->__pyx_n_u_traj, __pyx_mstate->__pyx_n_u_traj_view, __pyx_mstate->__pyx_n_u_rts, __pyx_mstate->__pyx_n_u_choices, __pyx_mstate->__pyx_n_u_rts_view, __pyx_mstate->__pyx_n_u_choices_view, __pyx_mstate->__pyx_n_u_delta_t_sqrt, __pyx_mstate->__pyx_n_u_y, __pyx_mstate->__pyx_n_u_t_particle, __pyx_mstate->__pyx_n_u_smooth_u, __pyx_mstate->__pyx_n_u_sqrt_st, __pyx_mstate->__pyx_n_u_n, __pyx_mstate->__pyx_n_u_ix, __pyx_mstate->__pyx_n_u_k, __pyx_mstate->__pyx_n_u_m, __pyx_mstate->__pyx_n_u_num_draws, __pyx_mstate->__pyx_n_u_gaussian_values, __pyx_mstate->__pyx_n_u_n_choices, __pyx_mstate->__pyx_n_u_rt_candidates, __pyx_mstate->__pyx_n_u_c, __pyx_mstate->__pyx_n_u_choices_idx, __pyx_mstate->__pyx_n_u_random_val, __pyx_mstate->__pyx_n_u_choice_idx}; + __pyx_mstate_global->__pyx_codeobj_tab[23] = __Pyx_PyCode_New(descr, varnames, __pyx_mstate->__pyx_kp_u_src_cssm_pyx, __pyx_mstate->__pyx_n_u_shifted_wald, __pyx_mstate->__pyx_kp_b_iso88591_AQ_a_a_a_1_1_2V2S_r_Ct6_F_Kz_XQ, tuple_dedup_map); if (unlikely(!__pyx_mstate_global->__pyx_codeobj_tab[23])) goto bad; + } + Py_DECREF(tuple_dedup_map); + return 0; + bad: + Py_DECREF(tuple_dedup_map); + return -1; +} +/* #### Code section: init_globals ### */ + +static int __Pyx_InitGlobals(void) { + /* PythonCompatibility.init */ + if (likely(__Pyx_init_co_variables() == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* AssertionsEnabled.init */ + if (likely(__Pyx_init_assertions_enabled() == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* NumpyImportArray.init */ + /* + * Cython has automatically inserted a call to _import_array since + * you didn't include one when you cimported numpy. To disable this + * add the line + * numpy._import_array + */ + #ifdef NPY_FEATURE_VERSION + #ifndef NO_IMPORT_ARRAY + if (unlikely(_import_array() == -1)) { + PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import " + "(auto-generated because you didn't call 'numpy.import_array()' after cimporting numpy; " + "use 'numpy._import_array' to disable if you are certain you don't need it)."); + } + #endif + #endif + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CommonTypesMetaclass.init */ + if (likely(__pyx_CommonTypesMetaclass_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CachedMethodType.init */ + #if CYTHON_COMPILING_IN_LIMITED_API + { + PyObject *typesModule=NULL; + typesModule = PyImport_ImportModule("types"); + if (typesModule) { + __pyx_mstate_global->__Pyx_CachedMethodType = PyObject_GetAttrString(typesModule, "MethodType"); + Py_DECREF(typesModule); + } + } // error handling follows + #endif + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + /* CythonFunctionShared.init */ + if (likely(__pyx_CyFunction_init(__pyx_m) == 0)); else + + if (unlikely(PyErr_Occurred())) __PYX_ERR(0, 1, __pyx_L1_error) + + return 0; + __pyx_L1_error:; + return -1; +} +/* #### Code section: cleanup_globals ### */ +/* #### Code section: cleanup_module ### */ +/* #### Code section: main_method ### */ +/* #### Code section: utility_code_pragmas ### */ +#ifdef _MSC_VER +#pragma warning( push ) +/* Warning 4127: conditional expression is constant + * Cython uses constant conditional expressions to allow in inline functions to be optimized at + * compile-time, so this warning is not useful + */ +#pragma warning( disable : 4127 ) +#endif + + + +/* #### Code section: utility_code_def ### */ + +/* --- Runtime support code --- */ +/* Refnanny */ +#if CYTHON_REFNANNY +static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) { + PyObject *m = NULL, *p = NULL; + void *r = NULL; + m = PyImport_ImportModule(modname); + if (!m) goto end; + p = PyObject_GetAttrString(m, "RefNannyAPI"); + if (!p) goto end; + r = PyLong_AsVoidPtr(p); +end: + Py_XDECREF(p); + Py_XDECREF(m); + return (__Pyx_RefNannyAPIStruct *)r; +} +#endif + +/* TupleAndListFromArray */ +#if !CYTHON_COMPILING_IN_CPYTHON && CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + Py_ssize_t i; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + for (i = 0; i < n; i++) { + if (unlikely(__Pyx_PyTuple_SET_ITEM(res, i, src[i]) < (0))) { + Py_DECREF(res); + return NULL; + } + Py_INCREF(src[i]); + } + return res; +} +#elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE void __Pyx_copy_object_array(PyObject *const *CYTHON_RESTRICT src, PyObject** CYTHON_RESTRICT dest, Py_ssize_t length) { + PyObject *v; + Py_ssize_t i; + for (i = 0; i < length; i++) { + v = dest[i] = src[i]; + Py_INCREF(v); + } +} +static CYTHON_INLINE PyObject * +__Pyx_PyTuple_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return __Pyx_NewRef(__pyx_mstate_global->__pyx_empty_tuple); + } + res = PyTuple_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyTupleObject*)res)->ob_item, n); + return res; +} +static CYTHON_INLINE PyObject * +__Pyx_PyList_FromArray(PyObject *const *src, Py_ssize_t n) +{ + PyObject *res; + if (n <= 0) { + return PyList_New(0); + } + res = PyList_New(n); + if (unlikely(res == NULL)) return NULL; + __Pyx_copy_object_array(src, ((PyListObject*)res)->ob_item, n); + return res; +} +#endif + +/* BytesEquals */ +static CYTHON_INLINE int __Pyx_PyBytes_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL ||\ + !(CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) + return PyObject_RichCompareBool(s1, s2, equals); +#else + if (s1 == s2) { + return (equals == Py_EQ); + } else if (PyBytes_CheckExact(s1) & PyBytes_CheckExact(s2)) { + const char *ps1, *ps2; + Py_ssize_t length = PyBytes_GET_SIZE(s1); + if (length != PyBytes_GET_SIZE(s2)) + return (equals == Py_NE); + ps1 = PyBytes_AS_STRING(s1); + ps2 = PyBytes_AS_STRING(s2); + if (ps1[0] != ps2[0]) { + return (equals == Py_NE); + } else if (length == 1) { + return (equals == Py_EQ); + } else { + int result; +#if CYTHON_USE_UNICODE_INTERNALS && (PY_VERSION_HEX < 0x030B0000) + Py_hash_t hash1, hash2; + hash1 = ((PyBytesObject*)s1)->ob_shash; + hash2 = ((PyBytesObject*)s2)->ob_shash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + return (equals == Py_NE); + } +#endif + result = memcmp(ps1, ps2, (size_t)length); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & PyBytes_CheckExact(s2)) { + return (equals == Py_NE); + } else if ((s2 == Py_None) & PyBytes_CheckExact(s1)) { + return (equals == Py_NE); + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +#endif +} + +/* UnicodeEquals */ +static CYTHON_INLINE int __Pyx_PyUnicode_Equals(PyObject* s1, PyObject* s2, int equals) { +#if CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_GRAAL + return PyObject_RichCompareBool(s1, s2, equals); +#else + int s1_is_unicode, s2_is_unicode; + if (s1 == s2) { + goto return_eq; + } + s1_is_unicode = PyUnicode_CheckExact(s1); + s2_is_unicode = PyUnicode_CheckExact(s2); + if (s1_is_unicode & s2_is_unicode) { + Py_ssize_t length, length2; + int kind; + void *data1, *data2; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(__Pyx_PyUnicode_READY(s1) < 0) || unlikely(__Pyx_PyUnicode_READY(s2) < 0)) + return -1; + #endif + length = __Pyx_PyUnicode_GET_LENGTH(s1); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length < 0)) return -1; + #endif + length2 = __Pyx_PyUnicode_GET_LENGTH(s2); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(length2 < 0)) return -1; + #endif + if (length != length2) { + goto return_ne; + } +#if CYTHON_USE_UNICODE_INTERNALS + { + Py_hash_t hash1, hash2; + hash1 = ((PyASCIIObject*)s1)->hash; + hash2 = ((PyASCIIObject*)s2)->hash; + if (hash1 != hash2 && hash1 != -1 && hash2 != -1) { + goto return_ne; + } + } +#endif + kind = __Pyx_PyUnicode_KIND(s1); + if (kind != __Pyx_PyUnicode_KIND(s2)) { + goto return_ne; + } + data1 = __Pyx_PyUnicode_DATA(s1); + data2 = __Pyx_PyUnicode_DATA(s2); + if (__Pyx_PyUnicode_READ(kind, data1, 0) != __Pyx_PyUnicode_READ(kind, data2, 0)) { + goto return_ne; + } else if (length == 1) { + goto return_eq; + } else { + int result = memcmp(data1, data2, (size_t)(length * kind)); + return (equals == Py_EQ) ? (result == 0) : (result != 0); + } + } else if ((s1 == Py_None) & s2_is_unicode) { + goto return_ne; + } else if ((s2 == Py_None) & s1_is_unicode) { + goto return_ne; + } else { + int result; + PyObject* py_result = PyObject_RichCompare(s1, s2, equals); + if (!py_result) + return -1; + result = __Pyx_PyObject_IsTrue(py_result); + Py_DECREF(py_result); + return result; + } +return_eq: + return (equals == Py_EQ); +return_ne: + return (equals == Py_NE); +#endif +} + +/* fastcall */ +#if CYTHON_METH_FASTCALL +static CYTHON_INLINE PyObject * __Pyx_GetKwValue_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues, PyObject *s) +{ + Py_ssize_t i, n = __Pyx_PyTuple_GET_SIZE(kwnames); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(n == -1)) return NULL; + #endif + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + if (s == namei) return kwvalues[i]; + } + for (i = 0; i < n; i++) + { + PyObject *namei = __Pyx_PyTuple_GET_ITEM(kwnames, i); + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!namei)) return NULL; + #endif + int eq = __Pyx_PyUnicode_Equals(s, namei, Py_EQ); + if (unlikely(eq != 0)) { + if (unlikely(eq < 0)) return NULL; + return kwvalues[i]; + } + } + return NULL; +} +#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000 || CYTHON_COMPILING_IN_LIMITED_API +CYTHON_UNUSED static PyObject *__Pyx_KwargsAsDict_FASTCALL(PyObject *kwnames, PyObject *const *kwvalues) { + Py_ssize_t i, nkwargs; + PyObject *dict; +#if !CYTHON_ASSUME_SAFE_SIZE + nkwargs = PyTuple_Size(kwnames); + if (unlikely(nkwargs < 0)) return NULL; +#else + nkwargs = PyTuple_GET_SIZE(kwnames); +#endif + dict = PyDict_New(); + if (unlikely(!dict)) + return NULL; + for (i=0; itp_call; + if (unlikely(!call)) + return PyObject_Call(func, arg, kw); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = (*call)(func, arg, kw); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectCallMethO */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) { + PyObject *self, *result; + PyCFunction cfunc; + cfunc = __Pyx_CyOrPyCFunction_GET_FUNCTION(func); + self = __Pyx_CyOrPyCFunction_GET_SELF(func); + if (unlikely(Py_EnterRecursiveCall(" while calling a Python object"))) + return NULL; + result = cfunc(self, arg); + Py_LeaveRecursiveCall(); + if (unlikely(!result) && unlikely(!PyErr_Occurred())) { + PyErr_SetString( + PyExc_SystemError, + "NULL result without error in PyObject_Call"); + } + return result; +} +#endif + +/* PyObjectFastCall */ +#if PY_VERSION_HEX < 0x03090000 || CYTHON_COMPILING_IN_LIMITED_API +static PyObject* __Pyx_PyObject_FastCall_fallback(PyObject *func, PyObject * const*args, size_t nargs, PyObject *kwargs) { + PyObject *argstuple; + PyObject *result = 0; + size_t i; + argstuple = PyTuple_New((Py_ssize_t)nargs); + if (unlikely(!argstuple)) return NULL; + for (i = 0; i < nargs; i++) { + Py_INCREF(args[i]); + if (__Pyx_PyTuple_SET_ITEM(argstuple, (Py_ssize_t)i, args[i]) != (0)) goto bad; + } + result = __Pyx_PyObject_Call(func, argstuple, kwargs); + bad: + Py_DECREF(argstuple); + return result; +} +#endif +#if CYTHON_VECTORCALL && !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x03090000 + #define __Pyx_PyVectorcall_Function(callable) _PyVectorcall_Function(callable) + #elif CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE vectorcallfunc __Pyx_PyVectorcall_Function(PyObject *callable) { + PyTypeObject *tp = Py_TYPE(callable); + #if defined(__Pyx_CyFunction_USED) + if (__Pyx_CyFunction_CheckExact(callable)) { + return __Pyx_CyFunction_func_vectorcall(callable); + } + #endif + if (!PyType_HasFeature(tp, Py_TPFLAGS_HAVE_VECTORCALL)) { + return NULL; + } + assert(PyCallable_Check(callable)); + Py_ssize_t offset = tp->tp_vectorcall_offset; + assert(offset > 0); + vectorcallfunc ptr; + memcpy(&ptr, (char *) callable + offset, sizeof(ptr)); + return ptr; +} + #else + #define __Pyx_PyVectorcall_Function(callable) PyVectorcall_Function(callable) + #endif +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_FastCallDict(PyObject *func, PyObject *const *args, size_t _nargs, PyObject *kwargs) { + Py_ssize_t nargs = __Pyx_PyVectorcall_NARGS(_nargs); +#if CYTHON_COMPILING_IN_CPYTHON + if (nargs == 0 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_NOARGS)) + return __Pyx_PyObject_CallMethO(func, NULL); + } + else if (nargs == 1 && kwargs == NULL) { + if (__Pyx_CyOrPyCFunction_Check(func) && likely( __Pyx_CyOrPyCFunction_GET_FLAGS(func) & METH_O)) + return __Pyx_PyObject_CallMethO(func, args[0]); + } +#endif + if (kwargs == NULL) { + #if CYTHON_VECTORCALL + #if CYTHON_COMPILING_IN_LIMITED_API + return PyObject_Vectorcall(func, args, _nargs, NULL); + #else + vectorcallfunc f = __Pyx_PyVectorcall_Function(func); + if (f) { + return f(func, args, _nargs, NULL); + } + #endif + #endif + } + if (nargs == 0) { + return __Pyx_PyObject_Call(func, __pyx_mstate_global->__pyx_empty_tuple, kwargs); + } + #if PY_VERSION_HEX >= 0x03090000 && !CYTHON_COMPILING_IN_LIMITED_API + return PyObject_VectorcallDict(func, args, (size_t)nargs, kwargs); + #else + return __Pyx_PyObject_FastCall_fallback(func, args, (size_t)nargs, kwargs); + #endif +} + +/* PyObjectCallOneArg */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) { + PyObject *args[2] = {NULL, arg}; + return __Pyx_PyObject_FastCall(func, args+1, 1 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); +} + +/* PyObjectGetAttrStr */ +#if CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) { + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro)) + return tp->tp_getattro(obj, attr_name); + return PyObject_GetAttr(obj, attr_name); +} +#endif + +/* UnpackUnboundCMethod */ +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *args, PyObject *kwargs) { + PyObject *result; + PyObject *selfless_args = PyTuple_GetSlice(args, 1, PyTuple_Size(args)); + if (unlikely(!selfless_args)) return NULL; + result = PyObject_Call(method, selfless_args, kwargs); + Py_DECREF(selfless_args); + return result; +} +#elif CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject **args, Py_ssize_t nargs, PyObject *kwnames) { + return _PyObject_Vectorcall + (method, args ? args+1 : NULL, nargs ? nargs-1 : 0, kwnames); +} +#else +static PyObject *__Pyx_SelflessCall(PyObject *method, PyObject *const *args, Py_ssize_t nargs, PyObject *kwnames) { + return +#if PY_VERSION_HEX < 0x03090000 + _PyObject_Vectorcall +#else + PyObject_Vectorcall +#endif + (method, args ? args+1 : NULL, nargs ? (size_t) nargs-1 : 0, kwnames); +} +#endif +static PyMethodDef __Pyx_UnboundCMethod_Def = { + "CythonUnboundCMethod", + __PYX_REINTERPRET_FUNCION(PyCFunction, __Pyx_SelflessCall), +#if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030C0000 + METH_VARARGS | METH_KEYWORDS, +#else + METH_FASTCALL | METH_KEYWORDS, +#endif + NULL +}; +static int __Pyx_TryUnpackUnboundCMethod(__Pyx_CachedCFunction* target) { + PyObject *method, *result=NULL; + method = __Pyx_PyObject_GetAttrStr(target->type, *target->method_name); + if (unlikely(!method)) + return -1; + result = method; +#if CYTHON_COMPILING_IN_CPYTHON + if (likely(__Pyx_TypeCheck(method, &PyMethodDescr_Type))) + { + PyMethodDescrObject *descr = (PyMethodDescrObject*) method; + target->func = descr->d_method->ml_meth; + target->flag = descr->d_method->ml_flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_STACKLESS); + } else +#endif +#if CYTHON_COMPILING_IN_PYPY +#else + if (PyCFunction_Check(method)) +#endif + { + PyObject *self; + int self_found; +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + self = PyObject_GetAttrString(method, "__self__"); + if (!self) { + PyErr_Clear(); + } +#else + self = PyCFunction_GET_SELF(method); +#endif + self_found = (self && self != Py_None); +#if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_COMPILING_IN_PYPY + Py_XDECREF(self); +#endif + if (self_found) { + PyObject *unbound_method = PyCFunction_New(&__Pyx_UnboundCMethod_Def, method); + if (unlikely(!unbound_method)) return -1; + Py_DECREF(method); + result = unbound_method; + } + } +#if !CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + if (unlikely(target->method)) { + Py_DECREF(result); + } else +#endif + target->method = result; + return 0; +} + +/* CallUnboundCMethod0 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject* __Pyx_CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + if (likely(cfunc->flag == METH_NOARGS)) + return __Pyx_CallCFunction(cfunc, self, NULL); + if (likely(cfunc->flag == METH_FASTCALL)) + return __Pyx_CallCFunctionFast(cfunc, self, NULL, 0); + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, NULL, 0, NULL); + if (likely(cfunc->flag == (METH_VARARGS | METH_KEYWORDS))) + return __Pyx_CallCFunctionWithKeywords(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple, NULL); + if (cfunc->flag == METH_VARARGS) + return __Pyx_CallCFunction(cfunc, self, __pyx_mstate_global->__pyx_empty_tuple); + return __Pyx__CallUnboundCMethod0(cfunc, self); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod0(&tmp_cfunc, self); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod0(cfunc, self); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod0(__Pyx_CachedCFunction* cfunc, PyObject* self) { + PyObject *result; + if (unlikely(!cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; + result = __Pyx_PyObject_CallOneArg(cfunc->method, self); + return result; +} + +/* py_dict_items */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Items(PyObject* d) { + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_items, d); +} + +/* py_dict_values */ +static CYTHON_INLINE PyObject* __Pyx_PyDict_Values(PyObject* d) { + return __Pyx_CallUnboundCMethod0(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_values, d); +} + +/* OwnedDictNext */ +#if CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, PyObject **ppos, PyObject **pkey, PyObject **pvalue) { + PyObject *next = NULL; + if (!*ppos) { + if (pvalue) { + PyObject *dictview = pkey ? __Pyx_PyDict_Items(p) : __Pyx_PyDict_Values(p); + if (unlikely(!dictview)) goto bad; + *ppos = PyObject_GetIter(dictview); + Py_DECREF(dictview); + } else { + *ppos = PyObject_GetIter(p); + } + if (unlikely(!*ppos)) goto bad; + } + next = PyIter_Next(*ppos); + if (!next) { + if (PyErr_Occurred()) goto bad; + return 0; + } + if (pkey && pvalue) { + *pkey = __Pyx_PySequence_ITEM(next, 0); + if (unlikely(*pkey)) goto bad; + *pvalue = __Pyx_PySequence_ITEM(next, 1); + if (unlikely(*pvalue)) goto bad; + Py_DECREF(next); + } else if (pkey) { + *pkey = next; + } else { + assert(pvalue); + *pvalue = next; + } + return 1; + bad: + Py_XDECREF(next); +#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 + PyErr_FormatUnraisable("Exception ignored in __Pyx_PyDict_NextRef"); +#else + PyErr_WriteUnraisable(__pyx_mstate_global->__pyx_n_u_Pyx_PyDict_NextRef); +#endif + if (pkey) *pkey = NULL; + if (pvalue) *pvalue = NULL; + return 0; +} +#else // !CYTHON_AVOID_BORROWED_REFS +static int __Pyx_PyDict_NextRef(PyObject *p, Py_ssize_t *ppos, PyObject **pkey, PyObject **pvalue) { + int result = PyDict_Next(p, ppos, pkey, pvalue); + if (likely(result == 1)) { + if (pkey) Py_INCREF(*pkey); + if (pvalue) Py_INCREF(*pvalue); + } + return result; +} +#endif + +/* RaiseDoubleKeywords */ +static void __Pyx_RaiseDoubleKeywordsError( + const char* func_name, + PyObject* kw_name) +{ + PyErr_Format(PyExc_TypeError, + "%s() got multiple values for keyword argument '%U'", func_name, kw_name); +} + +/* CallUnboundCMethod2 */ +#if CYTHON_COMPILING_IN_CPYTHON +static CYTHON_INLINE PyObject *__Pyx_CallUnboundCMethod2(__Pyx_CachedCFunction *cfunc, PyObject *self, PyObject *arg1, PyObject *arg2) { + int was_initialized = __Pyx_CachedCFunction_GetAndSetInitializing(cfunc); + if (likely(was_initialized == 2 && cfunc->func)) { + PyObject *args[2] = {arg1, arg2}; + if (cfunc->flag == METH_FASTCALL) { + return __Pyx_CallCFunctionFast(cfunc, self, args, 2); + } + if (cfunc->flag == (METH_FASTCALL | METH_KEYWORDS)) + return __Pyx_CallCFunctionFastWithKeywords(cfunc, self, args, 2, NULL); + } +#if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + else if (unlikely(was_initialized == 1)) { + __Pyx_CachedCFunction tmp_cfunc = { +#ifndef __cplusplus + 0 +#endif + }; + tmp_cfunc.type = cfunc->type; + tmp_cfunc.method_name = cfunc->method_name; + return __Pyx__CallUnboundCMethod2(&tmp_cfunc, self, arg1, arg2); + } +#endif + PyObject *result = __Pyx__CallUnboundCMethod2(cfunc, self, arg1, arg2); + __Pyx_CachedCFunction_SetFinishedInitializing(cfunc); + return result; +} +#endif +static PyObject* __Pyx__CallUnboundCMethod2(__Pyx_CachedCFunction* cfunc, PyObject* self, PyObject* arg1, PyObject* arg2){ + if (unlikely(!cfunc->func && !cfunc->method) && unlikely(__Pyx_TryUnpackUnboundCMethod(cfunc) < 0)) return NULL; +#if CYTHON_COMPILING_IN_CPYTHON + if (cfunc->func && (cfunc->flag & METH_VARARGS)) { + PyObject *result = NULL; + PyObject *args = PyTuple_New(2); + if (unlikely(!args)) return NULL; + Py_INCREF(arg1); + PyTuple_SET_ITEM(args, 0, arg1); + Py_INCREF(arg2); + PyTuple_SET_ITEM(args, 1, arg2); + if (cfunc->flag & METH_KEYWORDS) + result = __Pyx_CallCFunctionWithKeywords(cfunc, self, args, NULL); + else + result = __Pyx_CallCFunction(cfunc, self, args); + Py_DECREF(args); + return result; + } +#endif + { + PyObject *args[4] = {NULL, self, arg1, arg2}; + return __Pyx_PyObject_FastCall(cfunc->method, args+1, 3 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } +} + +/* ParseKeywordsImpl */ +static int __Pyx_ValidateDuplicatePosArgs( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char* function_name) +{ + PyObject ** const *name = argnames; + while (name != first_kw_arg) { + PyObject *key = **name; + int found = PyDict_Contains(kwds, key); + if (unlikely(found)) { + if (found == 1) __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; + } + name++; + } + return 0; +bad: + return -1; +} +#if CYTHON_USE_UNICODE_INTERNALS +static CYTHON_INLINE int __Pyx_UnicodeKeywordsEqual(PyObject *s1, PyObject *s2) { + int kind; + Py_ssize_t len = PyUnicode_GET_LENGTH(s1); + if (len != PyUnicode_GET_LENGTH(s2)) return 0; + kind = PyUnicode_KIND(s1); + if (kind != PyUnicode_KIND(s2)) return 0; + const void *data1 = PyUnicode_DATA(s1); + const void *data2 = PyUnicode_DATA(s2); + return (memcmp(data1, data2, (size_t) len * (size_t) kind) == 0); +} +#endif +static int __Pyx_MatchKeywordArg_str( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + #if CYTHON_USE_UNICODE_INTERNALS + Py_hash_t key_hash = ((PyASCIIObject*)key)->hash; + if (unlikely(key_hash == -1)) { + key_hash = PyObject_Hash(key); + if (unlikely(key_hash == -1)) + goto bad; + } + #endif + name = first_kw_arg; + while (*name) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (key_hash == ((PyASCIIObject*)name_str)->hash && __Pyx_UnicodeKeywordsEqual(name_str, key)) { + *index_found = (size_t) (name - argnames); + return 1; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) { + *index_found = (size_t) (name - argnames); + return 1; + } + } + #endif + name++; + } + name = argnames; + while (name != first_kw_arg) { + PyObject *name_str = **name; + #if CYTHON_USE_UNICODE_INTERNALS + if (unlikely(key_hash == ((PyASCIIObject*)name_str)->hash)) { + if (__Pyx_UnicodeKeywordsEqual(name_str, key)) + goto arg_passed_twice; + } + #else + #if CYTHON_ASSUME_SAFE_SIZE + if (PyUnicode_GET_LENGTH(name_str) == PyUnicode_GET_LENGTH(key)) + #endif + { + if (unlikely(name_str == key)) goto arg_passed_twice; + int cmp = PyUnicode_Compare(name_str, key); + if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad; + if (cmp == 0) goto arg_passed_twice; + } + #endif + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +bad: + return -1; +} +static int __Pyx_MatchKeywordArg_nostr( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + PyObject ** const *name; + if (unlikely(!PyUnicode_Check(key))) goto invalid_keyword_type; + name = first_kw_arg; + while (*name) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (cmp == 1) { + *index_found = (size_t) (name - argnames); + return 1; + } + if (unlikely(cmp == -1)) goto bad; + name++; + } + name = argnames; + while (name != first_kw_arg) { + int cmp = PyObject_RichCompareBool(**name, key, Py_EQ); + if (unlikely(cmp != 0)) { + if (cmp == 1) goto arg_passed_twice; + else goto bad; + } + name++; + } + return 0; +arg_passed_twice: + __Pyx_RaiseDoubleKeywordsError(function_name, key); + goto bad; +invalid_keyword_type: + PyErr_Format(PyExc_TypeError, + "%.200s() keywords must be strings", function_name); + goto bad; +bad: + return -1; +} +static CYTHON_INLINE int __Pyx_MatchKeywordArg( + PyObject *key, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + size_t *index_found, + const char *function_name) +{ + return likely(PyUnicode_CheckExact(key)) ? + __Pyx_MatchKeywordArg_str(key, argnames, first_kw_arg, index_found, function_name) : + __Pyx_MatchKeywordArg_nostr(key, argnames, first_kw_arg, index_found, function_name); +} +static void __Pyx_RejectUnknownKeyword( + PyObject *kwds, + PyObject ** const argnames[], + PyObject ** const *first_kw_arg, + const char *function_name) +{ + #if CYTHON_AVOID_BORROWED_REFS + PyObject *pos = NULL; + #else + Py_ssize_t pos = 0; + #endif + PyObject *key = NULL; + __Pyx_BEGIN_CRITICAL_SECTION(kwds); + while ( + #if CYTHON_AVOID_BORROWED_REFS + __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL) + #else + PyDict_Next(kwds, &pos, &key, NULL) + #endif + ) { + PyObject** const *name = first_kw_arg; + while (*name && (**name != key)) name++; + if (!*name) { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp != 1) { + if (cmp == 0) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + break; + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + #endif + } + __Pyx_END_CRITICAL_SECTION(); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(pos); + #endif + assert(PyErr_Occurred()); +} +static int __Pyx_ParseKeywordDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t extracted = 0; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + name = first_kw_arg; + while (*name && num_kwargs > extracted) { + PyObject * key = **name; + PyObject *value; + int found = 0; + #if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + found = PyDict_GetItemRef(kwds, key, &value); + #else + value = PyDict_GetItemWithError(kwds, key); + if (value) { + Py_INCREF(value); + found = 1; + } else { + if (unlikely(PyErr_Occurred())) goto bad; + } + #endif + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + extracted++; + } + name++; + } + if (num_kwargs > extracted) { + if (ignore_unknown_kwargs) { + if (unlikely(__Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name) == -1)) + goto bad; + } else { + __Pyx_RejectUnknownKeyword(kwds, argnames, first_kw_arg, function_name); + goto bad; + } + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordDictToDict( + PyObject *kwds, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + const char* function_name) +{ + PyObject** const *name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + Py_ssize_t len; +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return -1; +#endif + if (PyDict_Update(kwds2, kwds) < 0) goto bad; + name = first_kw_arg; + while (*name) { + PyObject *key = **name; + PyObject *value; +#if !CYTHON_COMPILING_IN_LIMITED_API && (PY_VERSION_HEX >= 0x030d00A2 || defined(PyDict_Pop)) + int found = PyDict_Pop(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + } +#elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int found = PyDict_GetItemRef(kwds2, key, &value); + if (found) { + if (unlikely(found < 0)) goto bad; + values[name-argnames] = value; + if (unlikely(PyDict_DelItem(kwds2, key) < 0)) goto bad; + } +#else + #if CYTHON_COMPILING_IN_CPYTHON + value = _PyDict_Pop(kwds2, key, kwds2); + #else + value = __Pyx_CallUnboundCMethod2(&__pyx_mstate_global->__pyx_umethod_PyDict_Type_pop, kwds2, key, kwds2); + #endif + if (value == kwds2) { + Py_DECREF(value); + } else { + if (unlikely(!value)) goto bad; + values[name-argnames] = value; + } +#endif + name++; + } + len = PyDict_Size(kwds2); + if (len > 0) { + return __Pyx_ValidateDuplicatePosArgs(kwds, argnames, first_kw_arg, function_name); + } else if (unlikely(len == -1)) { + goto bad; + } + return 0; +bad: + return -1; +} +static int __Pyx_ParseKeywordsTuple( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + PyObject *key = NULL; + PyObject** const * name; + PyObject** const *first_kw_arg = argnames + num_pos_args; + for (Py_ssize_t pos = 0; pos < num_kwargs; pos++) { +#if CYTHON_AVOID_BORROWED_REFS + key = __Pyx_PySequence_ITEM(kwds, pos); +#else + key = __Pyx_PyTuple_GET_ITEM(kwds, pos); +#endif +#if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(!key)) goto bad; +#endif + name = first_kw_arg; + while (*name && (**name != key)) name++; + if (*name) { + PyObject *value = kwvalues[pos]; + values[name-argnames] = __Pyx_NewRef(value); + } else { + size_t index_found = 0; + int cmp = __Pyx_MatchKeywordArg(key, argnames, first_kw_arg, &index_found, function_name); + if (cmp == 1) { + PyObject *value = kwvalues[pos]; + values[index_found] = __Pyx_NewRef(value); + } else { + if (unlikely(cmp == -1)) goto bad; + if (kwds2) { + PyObject *value = kwvalues[pos]; + if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad; + } else if (!ignore_unknown_kwargs) { + goto invalid_keyword; + } + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(key); + key = NULL; + #endif + } + return 0; +invalid_keyword: + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + goto bad; +bad: + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(key); + #endif + return -1; +} + +/* ParseKeywords */ +static int __Pyx_ParseKeywords( + PyObject *kwds, + PyObject * const *kwvalues, + PyObject ** const argnames[], + PyObject *kwds2, + PyObject *values[], + Py_ssize_t num_pos_args, + Py_ssize_t num_kwargs, + const char* function_name, + int ignore_unknown_kwargs) +{ + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) + return __Pyx_ParseKeywordsTuple(kwds, kwvalues, argnames, kwds2, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); + else if (kwds2) + return __Pyx_ParseKeywordDictToDict(kwds, argnames, kwds2, values, num_pos_args, function_name); + else + return __Pyx_ParseKeywordDict(kwds, argnames, values, num_pos_args, num_kwargs, function_name, ignore_unknown_kwargs); +} + +/* RaiseArgTupleInvalid */ +static void __Pyx_RaiseArgtupleInvalid( + const char* func_name, + int exact, + Py_ssize_t num_min, + Py_ssize_t num_max, + Py_ssize_t num_found) +{ + Py_ssize_t num_expected; + const char *more_or_less; + if (num_found < num_min) { + num_expected = num_min; + more_or_less = "at least"; + } else { + num_expected = num_max; + more_or_less = "at most"; + } + if (exact) { + more_or_less = "exactly"; + } + PyErr_Format(PyExc_TypeError, + "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)", + func_name, more_or_less, num_expected, + (num_expected == 1) ? "" : "s", num_found); +} + +/* ArgTypeTestFunc */ +static int __Pyx__ArgTypeTest(PyObject *obj, PyTypeObject *type, const char *name, int exact) +{ + __Pyx_TypeName type_name; + __Pyx_TypeName obj_type_name; + PyObject *extra_info = __pyx_mstate_global->__pyx_empty_unicode; + int from_annotation_subclass = 0; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + else if (!exact) { + if (likely(__Pyx_TypeCheck(obj, type))) return 1; + } else if (exact == 2) { + if (__Pyx_TypeCheck(obj, type)) { + from_annotation_subclass = 1; + extra_info = __pyx_mstate_global->__pyx_kp_u_Note_that_Cython_is_deliberately; + } + } + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "Argument '%.200s' has incorrect type (expected " __Pyx_FMT_TYPENAME + ", got " __Pyx_FMT_TYPENAME ")" +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + "%s%U" +#endif + , name, type_name, obj_type_name +#if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + , (from_annotation_subclass ? ". " : ""), extra_info +#endif + ); +#if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + if (exact == 2 && from_annotation_subclass) { + PyObject *res; + PyObject *vargs[2]; + vargs[0] = PyErr_GetRaisedException(); + vargs[1] = extra_info; + res = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_kp_u_add_note, vargs, 2, NULL); + Py_XDECREF(res); + PyErr_SetRaisedException(vargs[0]); + } +#endif + __Pyx_DECREF_TypeName(type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* PyErrExceptionMatches */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(tuple); + for (i=0; i= 0x030C00A6 + PyObject *current_exception = tstate->current_exception; + if (unlikely(!current_exception)) return 0; + exc_type = (PyObject*) Py_TYPE(current_exception); + if (exc_type == err) return 1; +#else + exc_type = tstate->curexc_type; + if (exc_type == err) return 1; + if (unlikely(!exc_type)) return 0; +#endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(exc_type); + #endif + if (unlikely(PyTuple_Check(err))) { + result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err); + } else { + result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err); + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(exc_type); + #endif + return result; +} +#endif + +/* PyErrFetchRestore */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject *tmp_value; + assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value))); + if (value) { + #if CYTHON_COMPILING_IN_CPYTHON + if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb)) + #endif + PyException_SetTraceback(value, tb); + } + tmp_value = tstate->current_exception; + tstate->current_exception = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + tmp_type = tstate->curexc_type; + tmp_value = tstate->curexc_value; + tmp_tb = tstate->curexc_traceback; + tstate->curexc_type = type; + tstate->curexc_value = value; + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#endif +} +static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyObject* exc_value; + exc_value = tstate->current_exception; + tstate->current_exception = 0; + *value = exc_value; + *type = NULL; + *tb = NULL; + if (exc_value) { + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + #if CYTHON_COMPILING_IN_CPYTHON + *tb = ((PyBaseExceptionObject*) exc_value)->traceback; + Py_XINCREF(*tb); + #else + *tb = PyException_GetTraceback(exc_value); + #endif + } +#else + *type = tstate->curexc_type; + *value = tstate->curexc_value; + *tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; +#endif +} +#endif + +/* PyObjectGetAttrStrNoError */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static void __Pyx_PyObject_GetAttrStr_ClearAttributeError(void) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (likely(__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + __Pyx_PyErr_Clear(); +} +#endif +static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStrNoError(PyObject* obj, PyObject* attr_name) { + PyObject *result; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + (void) PyObject_GetOptionalAttr(obj, attr_name, &result); + return result; +#else +#if CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_TYPE_SLOTS + PyTypeObject* tp = Py_TYPE(obj); + if (likely(tp->tp_getattro == PyObject_GenericGetAttr)) { + return _PyObject_GenericGetAttrWithDict(obj, attr_name, NULL, 1); + } +#endif + result = __Pyx_PyObject_GetAttrStr(obj, attr_name); + if (unlikely(!result)) { + __Pyx_PyObject_GetAttrStr_ClearAttributeError(); + } + return result; +#endif +} + +/* GetBuiltinName */ +static PyObject *__Pyx_GetBuiltinName(PyObject *name) { + PyObject* result = __Pyx_PyObject_GetAttrStrNoError(__pyx_mstate_global->__pyx_b, name); + if (unlikely(!result) && !PyErr_Occurred()) { + PyErr_Format(PyExc_NameError, + "name '%U' is not defined", name); + } + return result; +} + +/* RaiseException */ +static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) { + PyObject* owned_instance = NULL; + if (tb == Py_None) { + tb = 0; + } else if (tb && !PyTraceBack_Check(tb)) { + PyErr_SetString(PyExc_TypeError, + "raise: arg 3 must be a traceback or None"); + goto bad; + } + if (value == Py_None) + value = 0; + if (PyExceptionInstance_Check(type)) { + if (value) { + PyErr_SetString(PyExc_TypeError, + "instance exception may not have a separate value"); + goto bad; + } + value = type; + type = (PyObject*) Py_TYPE(value); + } else if (PyExceptionClass_Check(type)) { + PyObject *instance_class = NULL; + if (value && PyExceptionInstance_Check(value)) { + instance_class = (PyObject*) Py_TYPE(value); + if (instance_class != type) { + int is_subclass = PyObject_IsSubclass(instance_class, type); + if (!is_subclass) { + instance_class = NULL; + } else if (unlikely(is_subclass == -1)) { + goto bad; + } else { + type = instance_class; + } + } + } + if (!instance_class) { + PyObject *args; + if (!value) + args = PyTuple_New(0); + else if (PyTuple_Check(value)) { + Py_INCREF(value); + args = value; + } else + args = PyTuple_Pack(1, value); + if (!args) + goto bad; + owned_instance = PyObject_Call(type, args, NULL); + Py_DECREF(args); + if (!owned_instance) + goto bad; + value = owned_instance; + if (!PyExceptionInstance_Check(value)) { + PyErr_Format(PyExc_TypeError, + "calling %R should have returned an instance of " + "BaseException, not %R", + type, Py_TYPE(value)); + goto bad; + } + } + } else { + PyErr_SetString(PyExc_TypeError, + "raise: exception class must be a subclass of BaseException"); + goto bad; + } + if (cause) { + PyObject *fixed_cause; + if (cause == Py_None) { + fixed_cause = NULL; + } else if (PyExceptionClass_Check(cause)) { + fixed_cause = PyObject_CallObject(cause, NULL); + if (fixed_cause == NULL) + goto bad; + } else if (PyExceptionInstance_Check(cause)) { + fixed_cause = cause; + Py_INCREF(fixed_cause); + } else { + PyErr_SetString(PyExc_TypeError, + "exception causes must derive from " + "BaseException"); + goto bad; + } + PyException_SetCause(value, fixed_cause); + } + PyErr_SetObject(type, value); + if (tb) { +#if PY_VERSION_HEX >= 0x030C00A6 + PyException_SetTraceback(value, tb); +#elif CYTHON_FAST_THREAD_STATE + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject* tmp_tb = tstate->curexc_traceback; + if (tb != tmp_tb) { + Py_INCREF(tb); + tstate->curexc_traceback = tb; + Py_XDECREF(tmp_tb); + } +#else + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb); + Py_INCREF(tb); + PyErr_Restore(tmp_type, tmp_value, tb); + Py_XDECREF(tmp_tb); +#endif + } +bad: + Py_XDECREF(owned_instance); + return; +} + +/* PyObjectFastCallMethod */ +#if !CYTHON_VECTORCALL || PY_VERSION_HEX < 0x03090000 +static PyObject *__Pyx_PyObject_FastCallMethod(PyObject *name, PyObject *const *args, size_t nargsf) { + PyObject *result; + PyObject *attr = PyObject_GetAttr(args[0], name); + if (unlikely(!attr)) + return NULL; + result = __Pyx_PyObject_FastCall(attr, args+1, nargsf - 1); + Py_DECREF(attr); + return result; +} +#endif + +/* RaiseUnexpectedTypeError */ +static int +__Pyx_RaiseUnexpectedTypeError(const char *expected, PyObject *obj) +{ + __Pyx_TypeName obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, "Expected %s, got " __Pyx_FMT_TYPENAME, + expected, obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return 0; +} + +/* CIntToDigits */ +static const char DIGIT_PAIRS_10[2*10*10+1] = { + "00010203040506070809" + "10111213141516171819" + "20212223242526272829" + "30313233343536373839" + "40414243444546474849" + "50515253545556575859" + "60616263646566676869" + "70717273747576777879" + "80818283848586878889" + "90919293949596979899" +}; +static const char DIGIT_PAIRS_8[2*8*8+1] = { + "0001020304050607" + "1011121314151617" + "2021222324252627" + "3031323334353637" + "4041424344454647" + "5051525354555657" + "6061626364656667" + "7071727374757677" +}; +static const char DIGITS_HEX[2*16+1] = { + "0123456789abcdef" + "0123456789ABCDEF" +}; + +/* BuildPyUnicode */ +static PyObject* __Pyx_PyUnicode_BuildFromAscii(Py_ssize_t ulength, const char* chars, int clength, + int prepend_sign, char padding_char) { + PyObject *uval; + Py_ssize_t uoffset = ulength - clength; +#if CYTHON_USE_UNICODE_INTERNALS + Py_ssize_t i; + void *udata; + uval = PyUnicode_New(ulength, 127); + if (unlikely(!uval)) return NULL; + udata = PyUnicode_DATA(uval); + if (uoffset > 0) { + i = 0; + if (prepend_sign) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, 0, '-'); + i++; + } + for (; i < uoffset; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, i, padding_char); + } + } + for (i=0; i < clength; i++) { + __Pyx_PyUnicode_WRITE(PyUnicode_1BYTE_KIND, udata, uoffset+i, chars[i]); + } +#else + { + PyObject *sign = NULL, *padding = NULL; + uval = NULL; + if (uoffset > 0) { + prepend_sign = !!prepend_sign; + if (uoffset > prepend_sign) { + padding = PyUnicode_FromOrdinal(padding_char); + if (likely(padding) && uoffset > prepend_sign + 1) { + PyObject *tmp = PySequence_Repeat(padding, uoffset - prepend_sign); + Py_DECREF(padding); + padding = tmp; + } + if (unlikely(!padding)) goto done_or_error; + } + if (prepend_sign) { + sign = PyUnicode_FromOrdinal('-'); + if (unlikely(!sign)) goto done_or_error; + } + } + uval = PyUnicode_DecodeASCII(chars, clength, NULL); + if (likely(uval) && padding) { + PyObject *tmp = PyUnicode_Concat(padding, uval); + Py_DECREF(uval); + uval = tmp; + } + if (likely(uval) && sign) { + PyObject *tmp = PyUnicode_Concat(sign, uval); + Py_DECREF(uval); + uval = tmp; + } +done_or_error: + Py_XDECREF(padding); + Py_XDECREF(sign); + } +#endif + return uval; +} + +/* COrdinalToPyUnicode */ +static CYTHON_INLINE int __Pyx_CheckUnicodeValue(int value) { + return value <= 1114111; +} +static PyObject* __Pyx_PyUnicode_FromOrdinal_Padded(int value, Py_ssize_t ulength, char padding_char) { + if (likely(ulength <= 250)) { + char chars[256]; + if (value <= 255) { + memset(chars, padding_char, (size_t) (ulength - 1)); + chars[ulength-1] = (char) value; + return PyUnicode_DecodeLatin1(chars, ulength, NULL); + } + char *cpos = chars + sizeof(chars); + if (value < 0x800) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xc0 | (value & 0x1f)); + } else if (value < 0x10000) { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xe0 | (value & 0x0f)); + } else { + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0x80 | (value & 0x3f)); + value >>= 6; + *--cpos = (char) (0xf0 | (value & 0x07)); + } + cpos -= ulength; + memset(cpos, padding_char, (size_t) (ulength - 1)); + return PyUnicode_DecodeUTF8(cpos, chars + sizeof(chars) - cpos, NULL); + } + if (value <= 127 && CYTHON_USE_UNICODE_INTERNALS) { + const char chars[1] = {(char) value}; + return __Pyx_PyUnicode_BuildFromAscii(ulength, chars, 1, 0, padding_char); + } + { + PyObject *uchar, *padding_uchar, *padding, *result; + padding_uchar = PyUnicode_FromOrdinal(padding_char); + if (unlikely(!padding_uchar)) return NULL; + padding = PySequence_Repeat(padding_uchar, ulength - 1); + Py_DECREF(padding_uchar); + if (unlikely(!padding)) return NULL; + uchar = PyUnicode_FromOrdinal(value); + if (unlikely(!uchar)) { + Py_DECREF(padding); + return NULL; + } + result = PyUnicode_Concat(padding, uchar); + Py_DECREF(padding); + Py_DECREF(uchar); + return result; + } +} + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_int(int value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(int)*3+2]; + char *dpos, *end = digits + sizeof(int)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + int remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const int neg_one = (int) -1, const_zero = (int) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'c') { + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (int) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); + } + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (int) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (int) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (int) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* CIntToPyUnicode */ +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_From_Py_ssize_t(Py_ssize_t value, Py_ssize_t width, char padding_char, char format_char) { + char digits[sizeof(Py_ssize_t)*3+2]; + char *dpos, *end = digits + sizeof(Py_ssize_t)*3+2; + const char *hex_digits = DIGITS_HEX; + Py_ssize_t length, ulength; + int prepend_sign, last_one_off; + Py_ssize_t remaining; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wconversion" +#endif + const Py_ssize_t neg_one = (Py_ssize_t) -1, const_zero = (Py_ssize_t) 0; +#ifdef __Pyx_HAS_GCC_DIAGNOSTIC +#pragma GCC diagnostic pop +#endif + const int is_unsigned = neg_one > const_zero; + if (format_char == 'c') { + if (unlikely(!(is_unsigned || value == 0 || value > 0) || + !(sizeof(value) <= 2 || value & ~ (Py_ssize_t) 0x01fffff || __Pyx_CheckUnicodeValue((int) value)))) { + PyErr_SetString(PyExc_OverflowError, "%c arg not in range(0x110000)"); + return NULL; + } + if (width <= 1) { + return PyUnicode_FromOrdinal((int) value); + } + return __Pyx_PyUnicode_FromOrdinal_Padded((int) value, width, padding_char); + } + if (format_char == 'X') { + hex_digits += 16; + format_char = 'x'; + } + remaining = value; + last_one_off = 0; + dpos = end; + do { + int digit_pos; + switch (format_char) { + case 'o': + digit_pos = abs((int)(remaining % (8*8))); + remaining = (Py_ssize_t) (remaining / (8*8)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); + last_one_off = (digit_pos < 8); + break; + case 'd': + digit_pos = abs((int)(remaining % (10*10))); + remaining = (Py_ssize_t) (remaining / (10*10)); + dpos -= 2; + memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); + last_one_off = (digit_pos < 10); + break; + case 'x': + *(--dpos) = hex_digits[abs((int)(remaining % 16))]; + remaining = (Py_ssize_t) (remaining / 16); + break; + default: + assert(0); + break; + } + } while (unlikely(remaining != 0)); + assert(!last_one_off || *dpos == '0'); + dpos += last_one_off; + length = end - dpos; + ulength = length; + prepend_sign = 0; + if (!is_unsigned && value <= neg_one) { + if (padding_char == ' ' || width <= length + 1) { + *(--dpos) = '-'; + ++length; + } else { + prepend_sign = 1; + } + ++ulength; + } + if (width > ulength) { + ulength = width; + } + if (ulength == 1) { + return PyUnicode_FromOrdinal(*dpos); + } + return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char); +} + +/* JoinPyUnicode */ +static PyObject* __Pyx_PyUnicode_Join(PyObject** values, Py_ssize_t value_count, Py_ssize_t result_ulength, + Py_UCS4 max_char) { +#if CYTHON_USE_UNICODE_INTERNALS && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + PyObject *result_uval; + int result_ukind, kind_shift; + Py_ssize_t i, char_pos; + void *result_udata; + if (max_char > 1114111) max_char = 1114111; + result_uval = PyUnicode_New(result_ulength, max_char); + if (unlikely(!result_uval)) return NULL; + result_ukind = (max_char <= 255) ? PyUnicode_1BYTE_KIND : (max_char <= 65535) ? PyUnicode_2BYTE_KIND : PyUnicode_4BYTE_KIND; + kind_shift = (result_ukind == PyUnicode_4BYTE_KIND) ? 2 : result_ukind - 1; + result_udata = PyUnicode_DATA(result_uval); + assert(kind_shift == 2 || kind_shift == 1 || kind_shift == 0); + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - result_ulength < 0)) + goto overflow; + char_pos = 0; + for (i=0; i < value_count; i++) { + int ukind; + Py_ssize_t ulength; + void *udata; + PyObject *uval = values[i]; + #if !CYTHON_COMPILING_IN_LIMITED_API + if (__Pyx_PyUnicode_READY(uval) == (-1)) + goto bad; + #endif + ulength = __Pyx_PyUnicode_GET_LENGTH(uval); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(ulength < 0)) goto bad; + #endif + if (unlikely(!ulength)) + continue; + if (unlikely((PY_SSIZE_T_MAX >> kind_shift) - ulength < char_pos)) + goto overflow; + ukind = __Pyx_PyUnicode_KIND(uval); + udata = __Pyx_PyUnicode_DATA(uval); + if (ukind == result_ukind) { + memcpy((char *)result_udata + (char_pos << kind_shift), udata, (size_t) (ulength << kind_shift)); + } else { + #if PY_VERSION_HEX >= 0x030d0000 + if (unlikely(PyUnicode_CopyCharacters(result_uval, char_pos, uval, 0, ulength) < 0)) goto bad; + #elif CYTHON_COMPILING_IN_CPYTHON || defined(_PyUnicode_FastCopyCharacters) + _PyUnicode_FastCopyCharacters(result_uval, char_pos, uval, 0, ulength); + #else + Py_ssize_t j; + for (j=0; j < ulength; j++) { + Py_UCS4 uchar = __Pyx_PyUnicode_READ(ukind, udata, j); + __Pyx_PyUnicode_WRITE(result_ukind, result_udata, char_pos+j, uchar); + } + #endif + } + char_pos += ulength; + } + return result_uval; +overflow: + PyErr_SetString(PyExc_OverflowError, "join() result is too long for a Python string"); +bad: + Py_DECREF(result_uval); + return NULL; +#else + Py_ssize_t i; + PyObject *result = NULL; + PyObject *value_tuple = PyTuple_New(value_count); + if (unlikely(!value_tuple)) return NULL; + CYTHON_UNUSED_VAR(max_char); + CYTHON_UNUSED_VAR(result_ulength); + for (i=0; i__pyx_empty_unicode, value_tuple); +bad: + Py_DECREF(value_tuple); + return result; +#endif +} + +/* GetAttr */ +static CYTHON_INLINE PyObject *__Pyx_GetAttr(PyObject *o, PyObject *n) { +#if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) + return __Pyx_PyObject_GetAttrStr(o, n); +#endif + return PyObject_GetAttr(o, n); +} + +/* GetItemInt */ +static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) { + PyObject *r; + if (unlikely(!j)) return NULL; + r = PyObject_GetItem(o, j); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyList_GET_SIZE(o); + } + if ((CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS)) { + return __Pyx_PyList_GetItemRefFast(o, wrapped_i, unsafe_shared); + } else + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyList_GET_SIZE(o)))) { + return __Pyx_NewRef(PyList_GET_ITEM(o, wrapped_i)); + } + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +#else + (void)wraparound; + (void)boundscheck; + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + Py_ssize_t wrapped_i = i; + if (wraparound & unlikely(i < 0)) { + wrapped_i += PyTuple_GET_SIZE(o); + } + if ((!boundscheck) || likely(__Pyx_is_valid_index(wrapped_i, PyTuple_GET_SIZE(o)))) { + return __Pyx_NewRef(PyTuple_GET_ITEM(o, wrapped_i)); + } + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +#else + (void)wraparound; + (void)boundscheck; + return PySequence_GetItem(o, i); +#endif +} +static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o); + if ((CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS)) { + return __Pyx_PyList_GetItemRefFast(o, n, unsafe_shared); + } else if ((!boundscheck) || (likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o))))) { + return __Pyx_NewRef(PyList_GET_ITEM(o, n)); + } + } else + #if !CYTHON_AVOID_BORROWED_REFS + if (PyTuple_CheckExact(o)) { + Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o); + if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyTuple_GET_SIZE(o)))) { + return __Pyx_NewRef(PyTuple_GET_ITEM(o, n)); + } + } else + #endif +#endif +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (!is_list && mm && mm->mp_subscript) { + PyObject *r, *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return NULL; + r = mm->mp_subscript(o, key); + Py_DECREF(key); + return r; + } + if (is_list || likely(sm && sm->sq_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return NULL; + PyErr_Clear(); + } + } + return sm->sq_item(o, i); + } + } +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_GetItem(o, i); + } +#endif + (void)wraparound; + (void)boundscheck; + return __Pyx_GetItemInt_Generic(o, PyLong_FromSsize_t(i)); +} + +/* ObjectGetItem */ +#if CYTHON_USE_TYPE_SLOTS +static PyObject *__Pyx_PyObject_GetIndex(PyObject *obj, PyObject *index) { + PyObject *runerr = NULL; + Py_ssize_t key_value; + key_value = __Pyx_PyIndex_AsSsize_t(index); + if (likely(key_value != -1 || !(runerr = PyErr_Occurred()))) { + return __Pyx_GetItemInt_Fast(obj, key_value, 0, 1, 1, 1); + } + if (PyErr_GivenExceptionMatches(runerr, PyExc_OverflowError)) { + __Pyx_TypeName index_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(index)); + PyErr_Clear(); + PyErr_Format(PyExc_IndexError, + "cannot fit '" __Pyx_FMT_TYPENAME "' into an index-sized integer", index_type_name); + __Pyx_DECREF_TypeName(index_type_name); + } + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem_Slow(PyObject *obj, PyObject *key) { + __Pyx_TypeName obj_type_name; + if (likely(PyType_Check(obj))) { + PyObject *meth = __Pyx_PyObject_GetAttrStrNoError(obj, __pyx_mstate_global->__pyx_n_u_class_getitem); + if (!meth) { + PyErr_Clear(); + } else { + PyObject *result = __Pyx_PyObject_CallOneArg(meth, key); + Py_DECREF(meth); + return result; + } + } + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is not subscriptable", obj_type_name); + __Pyx_DECREF_TypeName(obj_type_name); + return NULL; +} +static PyObject *__Pyx_PyObject_GetItem(PyObject *obj, PyObject *key) { + PyTypeObject *tp = Py_TYPE(obj); + PyMappingMethods *mm = tp->tp_as_mapping; + PySequenceMethods *sm = tp->tp_as_sequence; + if (likely(mm && mm->mp_subscript)) { + return mm->mp_subscript(obj, key); + } + if (likely(sm && sm->sq_item)) { + return __Pyx_PyObject_GetIndex(obj, key); + } + return __Pyx_PyObject_GetItem_Slow(obj, key); +} +#endif + +/* RejectKeywords */ +static void __Pyx_RejectKeywords(const char* function_name, PyObject *kwds) { + PyObject *key = NULL; + if (CYTHON_METH_FASTCALL && likely(PyTuple_Check(kwds))) { + key = __Pyx_PySequence_ITEM(kwds, 0); + } else { +#if CYTHON_AVOID_BORROWED_REFS + PyObject *pos = NULL; +#else + Py_ssize_t pos = 0; +#endif +#if !CYTHON_COMPILING_IN_PYPY || defined(PyArg_ValidateKeywordArguments) + if (unlikely(!PyArg_ValidateKeywordArguments(kwds))) return; +#endif + __Pyx_PyDict_NextRef(kwds, &pos, &key, NULL); +#if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(pos); +#endif + } + if (likely(key)) { + PyErr_Format(PyExc_TypeError, + "%s() got an unexpected keyword argument '%U'", + function_name, key); + Py_DECREF(key); + } +} + +/* DivInt[Py_ssize_t] */ +static CYTHON_INLINE Py_ssize_t __Pyx_div_Py_ssize_t(Py_ssize_t a, Py_ssize_t b, int b_is_constant) { + Py_ssize_t q = a / b; + Py_ssize_t r = a - q*b; + Py_ssize_t adapt_python = (b_is_constant ? + ((r != 0) & ((r < 0) ^ (b < 0))) : + ((r != 0) & ((r ^ b) < 0)) + ); + return q - adapt_python; +} + +/* GetAttr3 */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static PyObject *__Pyx_GetAttr3Default(PyObject *d) { + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + if (unlikely(!__Pyx_PyErr_ExceptionMatches(PyExc_AttributeError))) + return NULL; + __Pyx_PyErr_Clear(); + Py_INCREF(d); + return d; +} +#endif +static CYTHON_INLINE PyObject *__Pyx_GetAttr3(PyObject *o, PyObject *n, PyObject *d) { + PyObject *r; +#if __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + int res = PyObject_GetOptionalAttr(o, n, &r); + return (res != 0) ? r : __Pyx_NewRef(d); +#else + #if CYTHON_USE_TYPE_SLOTS + if (likely(PyUnicode_Check(n))) { + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (unlikely(!r) && likely(!PyErr_Occurred())) { + r = __Pyx_NewRef(d); + } + return r; + } + #endif + r = PyObject_GetAttr(o, n); + return (likely(r)) ? r : __Pyx_GetAttr3Default(d); +#endif +} + +/* PyDictVersioning */ +#if CYTHON_USE_DICT_VERSIONS && CYTHON_USE_TYPE_SLOTS +static CYTHON_INLINE PY_UINT64_T __Pyx_get_tp_dict_version(PyObject *obj) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + return likely(dict) ? __PYX_GET_DICT_VERSION(dict) : 0; +} +static CYTHON_INLINE PY_UINT64_T __Pyx_get_object_dict_version(PyObject *obj) { + PyObject **dictptr = NULL; + Py_ssize_t offset = Py_TYPE(obj)->tp_dictoffset; + if (offset) { +#if CYTHON_COMPILING_IN_CPYTHON + dictptr = (likely(offset > 0)) ? (PyObject **) ((char *)obj + offset) : _PyObject_GetDictPtr(obj); +#else + dictptr = _PyObject_GetDictPtr(obj); +#endif + } + return (dictptr && *dictptr) ? __PYX_GET_DICT_VERSION(*dictptr) : 0; +} +static CYTHON_INLINE int __Pyx_object_dict_version_matches(PyObject* obj, PY_UINT64_T tp_dict_version, PY_UINT64_T obj_dict_version) { + PyObject *dict = Py_TYPE(obj)->tp_dict; + if (unlikely(!dict) || unlikely(tp_dict_version != __PYX_GET_DICT_VERSION(dict))) + return 0; + return obj_dict_version == __Pyx_get_object_dict_version(obj); +} +#endif + +/* GetModuleGlobalName */ +#if CYTHON_USE_DICT_VERSIONS +static PyObject *__Pyx__GetModuleGlobalName(PyObject *name, PY_UINT64_T *dict_version, PyObject **dict_cached_value) +#else +static CYTHON_INLINE PyObject *__Pyx__GetModuleGlobalName(PyObject *name) +#endif +{ + PyObject *result; +#if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(!__pyx_m)) { + if (!PyErr_Occurred()) + PyErr_SetNone(PyExc_NameError); + return NULL; + } + result = PyObject_GetAttr(__pyx_m, name); + if (likely(result)) { + return result; + } + PyErr_Clear(); +#elif CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + if (unlikely(__Pyx_PyDict_GetItemRef(__pyx_mstate_global->__pyx_d, name, &result) == -1)) PyErr_Clear(); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return result; + } +#else + result = _PyDict_GetItem_KnownHash(__pyx_mstate_global->__pyx_d, name, ((PyASCIIObject *) name)->hash); + __PYX_UPDATE_DICT_CACHE(__pyx_mstate_global->__pyx_d, result, *dict_cached_value, *dict_version) + if (likely(result)) { + return __Pyx_NewRef(result); + } + PyErr_Clear(); +#endif + return __Pyx_GetBuiltinName(name); +} + +/* RaiseTooManyValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) { + PyErr_Format(PyExc_ValueError, + "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected); +} + +/* RaiseNeedMoreValuesToUnpack */ +static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) { + PyErr_Format(PyExc_ValueError, + "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack", + index, (index == 1) ? "" : "s"); +} + +/* RaiseNoneIterError */ +static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) { + PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable"); +} + +/* ExtTypeTest */ +static CYTHON_INLINE int __Pyx_TypeTest(PyObject *obj, PyTypeObject *type) { + __Pyx_TypeName obj_type_name; + __Pyx_TypeName type_name; + if (unlikely(!type)) { + PyErr_SetString(PyExc_SystemError, "Missing type object"); + return 0; + } + if (likely(__Pyx_TypeCheck(obj, type))) + return 1; + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + type_name = __Pyx_PyType_GetFullyQualifiedName(type); + PyErr_Format(PyExc_TypeError, + "Cannot convert " __Pyx_FMT_TYPENAME " to " __Pyx_FMT_TYPENAME, + obj_type_name, type_name); + __Pyx_DECREF_TypeName(obj_type_name); + __Pyx_DECREF_TypeName(type_name); + return 0; +} + +/* GetTopmostException */ +#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE +static _PyErr_StackItem * +__Pyx_PyErr_GetTopmostException(PyThreadState *tstate) +{ + _PyErr_StackItem *exc_info = tstate->exc_info; + while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) && + exc_info->previous_item != NULL) + { + exc_info = exc_info->previous_item; + } + return exc_info; +} +#endif + +/* SaveResetException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + PyObject *exc_value = exc_info->exc_value; + if (exc_value == NULL || exc_value == Py_None) { + *value = NULL; + *type = NULL; + *tb = NULL; + } else { + *value = exc_value; + Py_INCREF(*value); + *type = (PyObject*) Py_TYPE(exc_value); + Py_INCREF(*type); + *tb = PyException_GetTraceback(exc_value); + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate); + *type = exc_info->exc_type; + *value = exc_info->exc_value; + *tb = exc_info->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #else + *type = tstate->exc_type; + *value = tstate->exc_value; + *tb = tstate->exc_traceback; + Py_XINCREF(*type); + Py_XINCREF(*value); + Py_XINCREF(*tb); + #endif +} +static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) { + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + PyObject *tmp_value = exc_info->exc_value; + exc_info->exc_value = value; + Py_XDECREF(tmp_value); + Py_XDECREF(type); + Py_XDECREF(tb); + #else + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = type; + exc_info->exc_value = value; + exc_info->exc_traceback = tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = type; + tstate->exc_value = value; + tstate->exc_traceback = tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); + #endif +} +#endif + +/* GetException */ +#if CYTHON_FAST_THREAD_STATE +static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) +#else +static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb) +#endif +{ + PyObject *local_type = NULL, *local_value, *local_tb = NULL; +#if CYTHON_FAST_THREAD_STATE + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if PY_VERSION_HEX >= 0x030C0000 + local_value = tstate->current_exception; + tstate->current_exception = 0; + #else + local_type = tstate->curexc_type; + local_value = tstate->curexc_value; + local_tb = tstate->curexc_traceback; + tstate->curexc_type = 0; + tstate->curexc_value = 0; + tstate->curexc_traceback = 0; + #endif +#elif __PYX_LIMITED_VERSION_HEX > 0x030C0000 + local_value = PyErr_GetRaisedException(); +#else + PyErr_Fetch(&local_type, &local_value, &local_tb); +#endif +#if __PYX_LIMITED_VERSION_HEX > 0x030C0000 + if (likely(local_value)) { + local_type = (PyObject*) Py_TYPE(local_value); + Py_INCREF(local_type); + local_tb = PyException_GetTraceback(local_value); + } +#else + PyErr_NormalizeException(&local_type, &local_value, &local_tb); +#if CYTHON_FAST_THREAD_STATE + if (unlikely(tstate->curexc_type)) +#else + if (unlikely(PyErr_Occurred())) +#endif + goto bad; + if (local_tb) { + if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0)) + goto bad; + } +#endif // __PYX_LIMITED_VERSION_HEX > 0x030C0000 + Py_XINCREF(local_tb); + Py_XINCREF(local_type); + Py_XINCREF(local_value); + *type = local_type; + *value = local_value; + *tb = local_tb; +#if CYTHON_FAST_THREAD_STATE + #if CYTHON_USE_EXC_INFO_STACK + { + _PyErr_StackItem *exc_info = tstate->exc_info; + #if PY_VERSION_HEX >= 0x030B00a4 + tmp_value = exc_info->exc_value; + exc_info->exc_value = local_value; + tmp_type = NULL; + tmp_tb = NULL; + Py_XDECREF(local_type); + Py_XDECREF(local_tb); + #else + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = local_type; + exc_info->exc_value = local_value; + exc_info->exc_traceback = local_tb; + #endif + } + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = local_type; + tstate->exc_value = local_value; + tstate->exc_traceback = local_tb; + #endif + Py_XDECREF(tmp_type); + Py_XDECREF(tmp_value); + Py_XDECREF(tmp_tb); +#elif __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + PyErr_SetHandledException(local_value); + Py_XDECREF(local_value); + Py_XDECREF(local_type); + Py_XDECREF(local_tb); +#else + PyErr_SetExcInfo(local_type, local_value, local_tb); +#endif + return 0; +#if __PYX_LIMITED_VERSION_HEX <= 0x030C0000 +bad: + *type = 0; + *value = 0; + *tb = 0; + Py_XDECREF(local_type); + Py_XDECREF(local_value); + Py_XDECREF(local_tb); + return -1; +#endif +} + +/* SwapException */ +#if CYTHON_FAST_THREAD_STATE +static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4 + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_value = exc_info->exc_value; + exc_info->exc_value = *value; + if (tmp_value == NULL || tmp_value == Py_None) { + Py_XDECREF(tmp_value); + tmp_value = NULL; + tmp_type = NULL; + tmp_tb = NULL; + } else { + tmp_type = (PyObject*) Py_TYPE(tmp_value); + Py_INCREF(tmp_type); + #if CYTHON_COMPILING_IN_CPYTHON + tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback; + Py_XINCREF(tmp_tb); + #else + tmp_tb = PyException_GetTraceback(tmp_value); + #endif + } + #elif CYTHON_USE_EXC_INFO_STACK + _PyErr_StackItem *exc_info = tstate->exc_info; + tmp_type = exc_info->exc_type; + tmp_value = exc_info->exc_value; + tmp_tb = exc_info->exc_traceback; + exc_info->exc_type = *type; + exc_info->exc_value = *value; + exc_info->exc_traceback = *tb; + #else + tmp_type = tstate->exc_type; + tmp_value = tstate->exc_value; + tmp_tb = tstate->exc_traceback; + tstate->exc_type = *type; + tstate->exc_value = *value; + tstate->exc_traceback = *tb; + #endif + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#else +static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) { + PyObject *tmp_type, *tmp_value, *tmp_tb; + PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb); + PyErr_SetExcInfo(*type, *value, *tb); + *type = tmp_type; + *value = tmp_value; + *tb = tmp_tb; +} +#endif + +/* HasAttr */ +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 +static CYTHON_INLINE int __Pyx_HasAttr(PyObject *o, PyObject *n) { + PyObject *r; + if (unlikely(!PyUnicode_Check(n))) { + PyErr_SetString(PyExc_TypeError, + "hasattr(): attribute name must be string"); + return -1; + } + r = __Pyx_PyObject_GetAttrStrNoError(o, n); + if (!r) { + return (unlikely(PyErr_Occurred())) ? -1 : 0; + } else { + Py_DECREF(r); + return 1; + } +} +#endif + +/* Import */ +static int __Pyx__Import_GetModule(PyObject *qualname, PyObject **module) { + PyObject *imported_module = PyImport_GetModule(qualname); + if (unlikely(!imported_module)) { + *module = NULL; + if (PyErr_Occurred()) { + return -1; + } + return 0; + } + *module = imported_module; + return 1; +} +static int __Pyx__Import_Lookup(PyObject *qualname, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject **module) { + PyObject *imported_module; + PyObject *top_level_package_name; + Py_ssize_t i; + int status, module_found; + Py_ssize_t dot_index; + module_found = __Pyx__Import_GetModule(qualname, &imported_module); + if (unlikely(!module_found || module_found == -1)) { + *module = NULL; + return module_found; + } + if (imported_names) { + for (i = 0; i < len_imported_names; i++) { + PyObject *imported_name = imported_names[i]; +#if __PYX_LIMITED_VERSION_HEX < 0x030d0000 + int has_imported_attribute = PyObject_HasAttr(imported_module, imported_name); +#else + int has_imported_attribute = PyObject_HasAttrWithError(imported_module, imported_name); + if (unlikely(has_imported_attribute == -1)) goto error; +#endif + if (!has_imported_attribute) { + goto not_found; + } + } + *module = imported_module; + return 1; + } + dot_index = PyUnicode_FindChar(qualname, '.', 0, PY_SSIZE_T_MAX, 1); + if (dot_index == -1) { + *module = imported_module; + return 1; + } + if (unlikely(dot_index == -2)) goto error; + top_level_package_name = PyUnicode_Substring(qualname, 0, dot_index); + if (unlikely(!top_level_package_name)) goto error; + Py_DECREF(imported_module); + status = __Pyx__Import_GetModule(top_level_package_name, module); + Py_DECREF(top_level_package_name); + return status; +error: + Py_DECREF(imported_module); + *module = NULL; + return -1; +not_found: + Py_DECREF(imported_module); + *module = NULL; + return 0; +} +static PyObject *__Pyx_Import(PyObject *name, PyObject *const *imported_names, Py_ssize_t len_imported_names, PyObject *qualname, int level) { + PyObject *module = 0; + PyObject *empty_dict = 0; + PyObject *from_list = 0; + int module_found; + if (!qualname) { + qualname = name; + } + module_found = __Pyx__Import_Lookup(qualname, imported_names, len_imported_names, &module); + if (likely(module_found == 1)) { + return module; + } else if (unlikely(module_found == -1)) { + return NULL; + } + empty_dict = PyDict_New(); + if (unlikely(!empty_dict)) + goto bad; + if (imported_names) { +#if CYTHON_COMPILING_IN_CPYTHON + from_list = __Pyx_PyList_FromArray(imported_names, len_imported_names); + if (unlikely(!from_list)) + goto bad; +#else + from_list = PyList_New(len_imported_names); + if (unlikely(!from_list)) goto bad; + for (Py_ssize_t i=0; i__pyx_d, empty_dict, from_list, 1); + if (unlikely(!module)) { + if (unlikely(!PyErr_ExceptionMatches(PyExc_ImportError))) + goto bad; + PyErr_Clear(); + } + } + level = 0; + } + if (!module) { + module = PyImport_ImportModuleLevelObject( + name, __pyx_mstate_global->__pyx_d, empty_dict, from_list, level); + } +bad: + Py_XDECREF(from_list); + Py_XDECREF(empty_dict); + return module; +} + +/* FastTypeChecks */ +#if CYTHON_COMPILING_IN_CPYTHON +static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) { + while (a) { + a = __Pyx_PyType_GetSlot(a, tp_base, PyTypeObject*); + if (a == b) + return 1; + } + return b == &PyBaseObject_Type; +} +static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (a == b) return 1; + mro = a->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + if (PyTuple_GET_ITEM(mro, i) == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(a, b); +} +static CYTHON_INLINE int __Pyx_IsAnySubtype2(PyTypeObject *cls, PyTypeObject *a, PyTypeObject *b) { + PyObject *mro; + if (cls == a || cls == b) return 1; + mro = cls->tp_mro; + if (likely(mro)) { + Py_ssize_t i, n; + n = PyTuple_GET_SIZE(mro); + for (i = 0; i < n; i++) { + PyObject *base = PyTuple_GET_ITEM(mro, i); + if (base == (PyObject *)a || base == (PyObject *)b) + return 1; + } + return 0; + } + return __Pyx_InBases(cls, a) || __Pyx_InBases(cls, b); +} +static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObject* exc_type1, PyObject *exc_type2) { + if (exc_type1) { + return __Pyx_IsAnySubtype2((PyTypeObject*)err, (PyTypeObject*)exc_type1, (PyTypeObject*)exc_type2); + } else { + return __Pyx_IsSubtype((PyTypeObject*)err, (PyTypeObject*)exc_type2); + } +} +static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) { + Py_ssize_t i, n; + assert(PyExceptionClass_Check(exc_type)); + n = PyTuple_GET_SIZE(tuple); + for (i=0; itp_as_sequence && type->tp_as_sequence->sq_repeat)) { + return type->tp_as_sequence->sq_repeat(seq, mul); + } else +#endif + { + return __Pyx_PySequence_Multiply_Generic(seq, mul); + } +} + +/* PyObjectFormatAndDecref */ +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatSimpleAndDecref(PyObject* s, PyObject* f) { + if (unlikely(!s)) return NULL; + if (likely(PyUnicode_CheckExact(s))) return s; + return __Pyx_PyObject_FormatAndDecref(s, f); +} +static CYTHON_INLINE PyObject* __Pyx_PyObject_FormatAndDecref(PyObject* s, PyObject* f) { + PyObject *result; + if (unlikely(!s)) return NULL; + result = PyObject_Format(s, f); + Py_DECREF(s); + return result; +} + +/* PyObjectFormat */ +#if CYTHON_USE_UNICODE_WRITER +static PyObject* __Pyx_PyObject_Format(PyObject* obj, PyObject* format_spec) { + int ret; + _PyUnicodeWriter writer; + if (likely(PyFloat_CheckExact(obj))) { + _PyUnicodeWriter_Init(&writer); + ret = _PyFloat_FormatAdvancedWriter( + &writer, + obj, + format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); + } else if (likely(PyLong_CheckExact(obj))) { + _PyUnicodeWriter_Init(&writer); + ret = _PyLong_FormatAdvancedWriter( + &writer, + obj, + format_spec, 0, PyUnicode_GET_LENGTH(format_spec)); + } else { + return PyObject_Format(obj, format_spec); + } + if (unlikely(ret == -1)) { + _PyUnicodeWriter_Dealloc(&writer); + return NULL; + } + return _PyUnicodeWriter_Finish(&writer); +} +#endif + +/* SetItemInt */ +static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) { + int r; + if (unlikely(!j)) return -1; + r = PyObject_SetItem(o, j, v); + Py_DECREF(j); + return r; +} +static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list, + int wraparound, int boundscheck, int unsafe_shared) { + CYTHON_MAYBE_UNUSED_VAR(unsafe_shared); +#if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE && !CYTHON_AVOID_BORROWED_REFS + if (is_list || PyList_CheckExact(o)) { + Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o)); + if ((CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS && !__Pyx_IS_UNIQUELY_REFERENCED(o, unsafe_shared))) { + Py_INCREF(v); + return PyList_SetItem(o, n, v); + } else if ((!boundscheck) || likely(__Pyx_is_valid_index(n, PyList_GET_SIZE(o)))) { + PyObject* old; + Py_INCREF(v); + old = PyList_GET_ITEM(o, n); + PyList_SET_ITEM(o, n, v); + Py_DECREF(old); + return 0; + } + } else +#endif +#if CYTHON_USE_TYPE_SLOTS && !CYTHON_COMPILING_IN_PYPY + { + PyMappingMethods *mm = Py_TYPE(o)->tp_as_mapping; + PySequenceMethods *sm = Py_TYPE(o)->tp_as_sequence; + if (!is_list && mm && mm->mp_ass_subscript) { + int r; + PyObject *key = PyLong_FromSsize_t(i); + if (unlikely(!key)) return -1; + r = mm->mp_ass_subscript(o, key, v); + Py_DECREF(key); + return r; + } + if (is_list || likely(sm && sm->sq_ass_item)) { + if (wraparound && unlikely(i < 0) && likely(sm->sq_length)) { + Py_ssize_t l = sm->sq_length(o); + if (likely(l >= 0)) { + i += l; + } else { + if (!PyErr_ExceptionMatches(PyExc_OverflowError)) + return -1; + PyErr_Clear(); + } + } + return sm->sq_ass_item(o, i, v); + } + } +#else + if (is_list || !PyMapping_Check(o)) { + return PySequence_SetItem(o, i, v); + } +#endif + (void)wraparound; + (void)boundscheck; + return __Pyx_SetItemInt_Generic(o, PyLong_FromSsize_t(i), v); +} + +/* RaiseUnboundLocalError */ +static void __Pyx_RaiseUnboundLocalError(const char *varname) { + PyErr_Format(PyExc_UnboundLocalError, "local variable '%s' referenced before assignment", varname); +} + +/* DivInt[long] */ +static CYTHON_INLINE long __Pyx_div_long(long a, long b, int b_is_constant) { + long q = a / b; + long r = a - q*b; + long adapt_python = (b_is_constant ? + ((r != 0) & ((r < 0) ^ (b < 0))) : + ((r != 0) & ((r ^ b) < 0)) + ); + return q - adapt_python; +} + +/* PyObjectVectorCallKwBuilder */ +#if CYTHON_VECTORCALL +static int __Pyx_VectorcallBuilder_AddArg(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_PyObject_FastCallDict; + if (__Pyx_PyTuple_SET_ITEM(builder, n, key) != (0)) return -1; + Py_INCREF(key); + args[n] = value; + return 0; +} +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + (void)__Pyx_VectorcallBuilder_AddArgStr; + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return __Pyx_VectorcallBuilder_AddArg(key, value, builder, args, n); +} +static int __Pyx_VectorcallBuilder_AddArgStr(const char *key, PyObject *value, PyObject *builder, PyObject **args, int n) { + PyObject *pyKey = PyUnicode_FromString(key); + if (!pyKey) return -1; + return __Pyx_VectorcallBuilder_AddArg(pyKey, value, builder, args, n); +} +#else // CYTHON_VECTORCALL +CYTHON_UNUSED static int __Pyx_VectorcallBuilder_AddArg_Check(PyObject *key, PyObject *value, PyObject *builder, CYTHON_UNUSED PyObject **args, CYTHON_UNUSED int n) { + if (unlikely(!PyUnicode_Check(key))) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + return -1; + } + return PyDict_SetItem(builder, key, value); +} +#endif + +/* IsLittleEndian */ +static CYTHON_INLINE int __Pyx_Is_Little_Endian(void) +{ + union { + uint32_t u32; + uint8_t u8[4]; + } S; + S.u32 = 0x01020304; + return S.u8[0] == 4; +} + +/* BufferFormatCheck */ +static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx, + __Pyx_BufFmt_StackElem* stack, + const __Pyx_TypeInfo* type) { + stack[0].field = &ctx->root; + stack[0].parent_offset = 0; + ctx->root.type = type; + ctx->root.name = "buffer dtype"; + ctx->root.offset = 0; + ctx->head = stack; + ctx->head->field = &ctx->root; + ctx->fmt_offset = 0; + ctx->head->parent_offset = 0; + ctx->new_packmode = '@'; + ctx->enc_packmode = '@'; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->is_complex = 0; + ctx->is_valid_array = 0; + ctx->struct_alignment = 0; + while (type->typegroup == 'S') { + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = 0; + type = type->fields->type; + } +} +static int __Pyx_BufFmt_ParseNumber(const char** ts) { + int count; + const char* t = *ts; + if (*t < '0' || *t > '9') { + return -1; + } else { + count = *t++ - '0'; + while (*t >= '0' && *t <= '9') { + count *= 10; + count += *t++ - '0'; + } + } + *ts = t; + return count; +} +static int __Pyx_BufFmt_ExpectNumber(const char **ts) { + int number = __Pyx_BufFmt_ParseNumber(ts); + if (number == -1) + PyErr_Format(PyExc_ValueError,\ + "Does not understand character buffer dtype format string ('%c')", **ts); + return number; +} +static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) { + PyErr_Format(PyExc_ValueError, + "Unexpected format string character: '%c'", ch); +} +static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) { + switch (ch) { + case '?': return "'bool'"; + case 'c': return "'char'"; + case 'b': return "'signed char'"; + case 'B': return "'unsigned char'"; + case 'h': return "'short'"; + case 'H': return "'unsigned short'"; + case 'i': return "'int'"; + case 'I': return "'unsigned int'"; + case 'l': return "'long'"; + case 'L': return "'unsigned long'"; + case 'q': return "'long long'"; + case 'Q': return "'unsigned long long'"; + case 'f': return (is_complex ? "'complex float'" : "'float'"); + case 'd': return (is_complex ? "'complex double'" : "'double'"); + case 'g': return (is_complex ? "'complex long double'" : "'long double'"); + case 'T': return "a struct"; + case 'O': return "Python object"; + case 'P': return "a pointer"; + case 's': case 'p': return "a string"; + case 0: return "end"; + default: return "unparsable format string"; + } +} +static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return 2; + case 'i': case 'I': case 'l': case 'L': return 4; + case 'q': case 'Q': return 8; + case 'f': return (is_complex ? 8 : 4); + case 'd': return (is_complex ? 16 : 8); + case 'g': { + PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g').."); + return 0; + } + case 'O': case 'P': return sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) { + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(short); + case 'i': case 'I': return sizeof(int); + case 'l': case 'L': return sizeof(long); + case 'q': case 'Q': return sizeof(PY_LONG_LONG); + case 'f': return sizeof(float) * (is_complex ? 2 : 1); + case 'd': return sizeof(double) * (is_complex ? 2 : 1); + case 'g': return sizeof(long double) * (is_complex ? 2 : 1); + case 'O': case 'P': return sizeof(void*); + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +typedef struct { char c; short x; } __Pyx_st_short; +typedef struct { char c; int x; } __Pyx_st_int; +typedef struct { char c; long x; } __Pyx_st_long; +typedef struct { char c; float x; } __Pyx_st_float; +typedef struct { char c; double x; } __Pyx_st_double; +typedef struct { char c; long double x; } __Pyx_st_longdouble; +typedef struct { char c; void *x; } __Pyx_st_void_p; +typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong; +static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, int is_complex) { + CYTHON_UNUSED_VAR(is_complex); + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long); + case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG); + case 'f': return sizeof(__Pyx_st_float) - sizeof(float); + case 'd': return sizeof(__Pyx_st_double) - sizeof(double); + case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +/* These are for computing the padding at the end of the struct to align + on the first member of the struct. This will probably the same as above, + but we don't have any guarantees. + */ +typedef struct { short x; char c; } __Pyx_pad_short; +typedef struct { int x; char c; } __Pyx_pad_int; +typedef struct { long x; char c; } __Pyx_pad_long; +typedef struct { float x; char c; } __Pyx_pad_float; +typedef struct { double x; char c; } __Pyx_pad_double; +typedef struct { long double x; char c; } __Pyx_pad_longdouble; +typedef struct { void *x; char c; } __Pyx_pad_void_p; +typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong; +static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, int is_complex) { + CYTHON_UNUSED_VAR(is_complex); + switch (ch) { + case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1; + case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short); + case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int); + case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long); + case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG); + case 'f': return sizeof(__Pyx_pad_float) - sizeof(float); + case 'd': return sizeof(__Pyx_pad_double) - sizeof(double); + case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double); + case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*); + default: + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } +} +static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) { + switch (ch) { + case 'c': + return 'H'; + case 'b': case 'h': case 'i': + case 'l': case 'q': case 's': case 'p': + return 'I'; + case '?': case 'B': case 'H': case 'I': case 'L': case 'Q': + return 'U'; + case 'f': case 'd': case 'g': + return (is_complex ? 'C' : 'R'); + case 'O': + return 'O'; + case 'P': + return 'P'; + default: { + __Pyx_BufFmt_RaiseUnexpectedChar(ch); + return 0; + } + } +} +static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) { + if (ctx->head == NULL || ctx->head->field == &ctx->root) { + const char* expected; + const char* quote; + if (ctx->head == NULL) { + expected = "end"; + quote = ""; + } else { + expected = ctx->head->field->type->name; + quote = "'"; + } + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected %s%s%s but got %s", + quote, expected, quote, + __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex)); + } else { + const __Pyx_StructField* field = ctx->head->field; + const __Pyx_StructField* parent = (ctx->head - 1)->field; + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'", + field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex), + parent->type->name, field->name); + } +} +static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) { + char group; + size_t size, offset, arraysize = 1; + if (ctx->enc_type == 0) return 0; + if (ctx->head->field->type->arraysize[0]) { + int i, ndim = 0; + if (ctx->enc_type == 's' || ctx->enc_type == 'p') { + ctx->is_valid_array = ctx->head->field->type->ndim == 1; + ndim = 1; + if (ctx->enc_count != ctx->head->field->type->arraysize[0]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %zu", + ctx->head->field->type->arraysize[0], ctx->enc_count); + return -1; + } + } + if (!ctx->is_valid_array) { + PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d", + ctx->head->field->type->ndim, ndim); + return -1; + } + for (i = 0; i < ctx->head->field->type->ndim; i++) { + arraysize *= ctx->head->field->type->arraysize[i]; + } + ctx->is_valid_array = 0; + ctx->enc_count = 1; + } + group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex); + do { + const __Pyx_StructField* field = ctx->head->field; + const __Pyx_TypeInfo* type = field->type; + if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') { + size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex); + } else { + size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex); + } + if (ctx->enc_packmode == '@') { + size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex); + size_t align_mod_offset; + if (align_at == 0) return -1; + align_mod_offset = ctx->fmt_offset % align_at; + if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset; + if (ctx->struct_alignment == 0) + ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type, + ctx->is_complex); + } + if (type->size != size || type->typegroup != group) { + if (type->typegroup == 'C' && type->fields != NULL) { + size_t parent_offset = ctx->head->parent_offset + field->offset; + ++ctx->head; + ctx->head->field = type->fields; + ctx->head->parent_offset = parent_offset; + continue; + } + if ((type->typegroup == 'H' || group == 'H') && type->size == size) { + } else { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + } + offset = ctx->head->parent_offset + field->offset; + if (ctx->fmt_offset != offset) { + PyErr_Format(PyExc_ValueError, + "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected", + (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset); + return -1; + } + ctx->fmt_offset += size; + if (arraysize) + ctx->fmt_offset += (arraysize - 1) * size; + --ctx->enc_count; + while (1) { + if (field == &ctx->root) { + ctx->head = NULL; + if (ctx->enc_count != 0) { + __Pyx_BufFmt_RaiseExpected(ctx); + return -1; + } + break; + } + ctx->head->field = ++field; + if (field->type == NULL) { + --ctx->head; + field = ctx->head->field; + continue; + } else if (field->type->typegroup == 'S') { + size_t parent_offset = ctx->head->parent_offset + field->offset; + if (field->type->fields->type == NULL) continue; + field = field->type->fields; + ++ctx->head; + ctx->head->field = field; + ctx->head->parent_offset = parent_offset; + break; + } else { + break; + } + } + } while (ctx->enc_count); + ctx->enc_type = 0; + ctx->is_complex = 0; + return 0; +} +static int +__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp) +{ + const char *ts = *tsp; + int i = 0, number, ndim; + ++ts; + if (ctx->new_count != 1) { + PyErr_SetString(PyExc_ValueError, + "Cannot handle repeated arrays in format string"); + return -1; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return -1; + ndim = ctx->head->field->type->ndim; + while (*ts && *ts != ')') { + switch (*ts) { + case ' ': case '\f': case '\r': case '\n': case '\t': case '\v': continue; + default: break; + } + number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return -1; + if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) { + PyErr_Format(PyExc_ValueError, + "Expected a dimension of size %zu, got %d", + ctx->head->field->type->arraysize[i], number); + return -1; + } + if (*ts != ',' && *ts != ')') { + PyErr_Format(PyExc_ValueError, + "Expected a comma in format string, got '%c'", *ts); + return -1; + } + if (*ts == ',') ts++; + i++; + } + if (i != ndim) { + PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d", + ctx->head->field->type->ndim, i); + return -1; + } + if (!*ts) { + PyErr_SetString(PyExc_ValueError, + "Unexpected end of format string, expected ')'"); + return -1; + } + ctx->is_valid_array = 1; + ctx->new_count = 1; + *tsp = ++ts; + return 0; +} +static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) { + int got_Z = 0; + while (1) { + switch(*ts) { + case 0: + if (ctx->enc_type != 0 && ctx->head == NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + if (ctx->head != NULL) { + __Pyx_BufFmt_RaiseExpected(ctx); + return NULL; + } + return ts; + case ' ': + case '\r': + case '\n': + ++ts; + break; + case '<': + if (!__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '>': + case '!': + if (__Pyx_Is_Little_Endian()) { + PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler"); + return NULL; + } + ctx->new_packmode = '='; + ++ts; + break; + case '=': + case '@': + case '^': + ctx->new_packmode = *ts++; + break; + case 'T': + { + const char* ts_after_sub; + size_t i, struct_count = ctx->new_count; + size_t struct_alignment = ctx->struct_alignment; + ctx->new_count = 1; + ++ts; + if (*ts != '{') { + PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'"); + return NULL; + } + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + ctx->enc_count = 0; + ctx->struct_alignment = 0; + ++ts; + ts_after_sub = ts; + for (i = 0; i != struct_count; ++i) { + ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts); + if (!ts_after_sub) return NULL; + } + ts = ts_after_sub; + if (struct_alignment) ctx->struct_alignment = struct_alignment; + } + break; + case '}': + { + size_t alignment = ctx->struct_alignment; + ++ts; + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_type = 0; + if (alignment && ctx->fmt_offset % alignment) { + ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment); + } + } + return ts; + case 'x': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->fmt_offset += ctx->new_count; + ctx->new_count = 1; + ctx->enc_count = 0; + ctx->enc_type = 0; + ctx->enc_packmode = ctx->new_packmode; + ++ts; + break; + case 'Z': + got_Z = 1; + ++ts; + if (*ts != 'f' && *ts != 'd' && *ts != 'g') { + __Pyx_BufFmt_RaiseUnexpectedChar('Z'); + return NULL; + } + CYTHON_FALLTHROUGH; + case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I': + case 'l': case 'L': case 'q': case 'Q': + case 'f': case 'd': case 'g': + case 'O': case 'p': + if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) && + (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) { + ctx->enc_count += ctx->new_count; + ctx->new_count = 1; + got_Z = 0; + ++ts; + break; + } + CYTHON_FALLTHROUGH; + case 's': + if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL; + ctx->enc_count = ctx->new_count; + ctx->enc_packmode = ctx->new_packmode; + ctx->enc_type = *ts; + ctx->is_complex = got_Z; + ++ts; + ctx->new_count = 1; + got_Z = 0; + break; + case ':': + ++ts; + while(*ts != ':') ++ts; + ++ts; + break; + case '(': + if (__pyx_buffmt_parse_array(ctx, &ts) < 0) return NULL; + break; + default: + { + int number = __Pyx_BufFmt_ExpectNumber(&ts); + if (number == -1) return NULL; + ctx->new_count = (size_t)number; + } + } + } +} + +/* BufferGetAndValidate */ + static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) { + if (unlikely(info->buf == NULL)) return; + if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL; + PyBuffer_Release(info); + } + static void __Pyx_ZeroBuffer(Py_buffer* buf) { + buf->buf = NULL; + buf->obj = NULL; + buf->strides = __Pyx_zeros; + buf->shape = __Pyx_zeros; + buf->suboffsets = __Pyx_minusones; + } + static int __Pyx__GetBufferAndValidate( + Py_buffer* buf, PyObject* obj, const __Pyx_TypeInfo* dtype, int flags, + int nd, int cast, __Pyx_BufFmt_StackElem* stack) + { + buf->buf = NULL; + if (unlikely(PyObject_GetBuffer(obj, buf, flags) == -1)) { + __Pyx_ZeroBuffer(buf); + return -1; + } + if (unlikely(buf->ndim != nd)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + nd, buf->ndim); + goto fail; + } + if (!cast) { + __Pyx_BufFmt_Context ctx; + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail; + } + if (unlikely((size_t)buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)", + buf->itemsize, (buf->itemsize > 1) ? "s" : "", + dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones; + return 0; + fail:; + __Pyx_SafeReleaseBuffer(buf); + return -1; + } + +/* PyLongBinop */ + #if !CYTHON_COMPILING_IN_PYPY + static PyObject* __Pyx_Fallback___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, int inplace) { + return (inplace ? PyNumber_InPlaceAdd : PyNumber_Add)(op1, op2); + } + #if CYTHON_USE_PYLONG_INTERNALS + static PyObject* __Pyx_Unpacked___Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(inplace); + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + long a; + const PY_LONG_LONG llb = intval; + PY_LONG_LONG lla; + if (unlikely(__Pyx_PyLong_IsZero(op1))) { + return __Pyx_NewRef(op2); + } + const int is_positive = __Pyx_PyLong_IsPos(op1); + const digit* digits = __Pyx_PyLong_Digits(op1); + const Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); + if (likely(size == 1)) { + a = (long) digits[0]; + if (!is_positive) a *= -1; + } else { + switch (size) { + case 2: + if (8 * sizeof(long) - 1 > 2 * PyLong_SHIFT) { + a = (long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if (!is_positive) a *= -1; + goto calculate_long; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 2 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } + break; + case 3: + if (8 * sizeof(long) - 1 > 3 * PyLong_SHIFT) { + a = (long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if (!is_positive) a *= -1; + goto calculate_long; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 3 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } + break; + case 4: + if (8 * sizeof(long) - 1 > 4 * PyLong_SHIFT) { + a = (long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0])); + if (!is_positive) a *= -1; + goto calculate_long; + } else if (8 * sizeof(PY_LONG_LONG) - 1 > 4 * PyLong_SHIFT) { + lla = (PY_LONG_LONG) (((((((((unsigned PY_LONG_LONG)digits[3]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[2]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[1]) << PyLong_SHIFT) | (unsigned PY_LONG_LONG)digits[0])); + if (!is_positive) lla *= -1; + goto calculate_long_long; + } + break; + } + return PyLong_Type.tp_as_number->nb_add(op1, op2); + } + calculate_long: + { + long x; + x = a + b; + return PyLong_FromLong(x); + } + calculate_long_long: + { + PY_LONG_LONG llx; + llx = lla + llb; + return PyLong_FromLongLong(llx); + } + + } + #endif + static PyObject* __Pyx_Float___Pyx_PyLong_AddObjC(PyObject *float_val, long intval, int zerodivision_check) { + CYTHON_UNUSED_VAR(zerodivision_check); + const long b = intval; + double a = __Pyx_PyFloat_AS_DOUBLE(float_val); + double result; + + result = ((double)a) + (double)b; + return PyFloat_FromDouble(result); + } + static CYTHON_INLINE PyObject* __Pyx_PyLong_AddObjC(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(zerodivision_check); + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + return __Pyx_Unpacked___Pyx_PyLong_AddObjC(op1, op2, intval, inplace, zerodivision_check); + } + #endif + if (PyFloat_CheckExact(op1)) { + return __Pyx_Float___Pyx_PyLong_AddObjC(op1, intval, zerodivision_check); + } + return __Pyx_Fallback___Pyx_PyLong_AddObjC(op1, op2, inplace); + } + #endif + +/* IterFinish */ + static CYTHON_INLINE int __Pyx_IterFinish(void) { + PyObject* exc_type; + __Pyx_PyThreadState_declare + __Pyx_PyThreadState_assign + exc_type = __Pyx_PyErr_CurrentExceptionType(); + if (unlikely(exc_type)) { + if (unlikely(!__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) + return -1; + __Pyx_PyErr_Clear(); + return 0; + } + return 0; + } + +/* PyObjectCallNoArg */ + static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) { + PyObject *arg[2] = {NULL, NULL}; + return __Pyx_PyObject_FastCall(func, arg + 1, 0 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } + +/* PyObjectGetMethod */ + #if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) + static int __Pyx_PyObject_GetMethod(PyObject *obj, PyObject *name, PyObject **method) { + PyObject *attr; + #if CYTHON_UNPACK_METHODS && CYTHON_COMPILING_IN_CPYTHON && CYTHON_USE_PYTYPE_LOOKUP + __Pyx_TypeName type_name; + PyTypeObject *tp = Py_TYPE(obj); + PyObject *descr; + descrgetfunc f = NULL; + PyObject **dictptr, *dict; + int meth_found = 0; + assert (*method == NULL); + if (unlikely(tp->tp_getattro != PyObject_GenericGetAttr)) { + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + } + if (unlikely(tp->tp_dict == NULL) && unlikely(PyType_Ready(tp) < 0)) { + return 0; + } + descr = _PyType_Lookup(tp, name); + if (likely(descr != NULL)) { + Py_INCREF(descr); + #if defined(Py_TPFLAGS_METHOD_DESCRIPTOR) && Py_TPFLAGS_METHOD_DESCRIPTOR + if (__Pyx_PyType_HasFeature(Py_TYPE(descr), Py_TPFLAGS_METHOD_DESCRIPTOR)) + #else + #ifdef __Pyx_CyFunction_USED + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type) || __Pyx_CyFunction_Check(descr))) + #else + if (likely(PyFunction_Check(descr) || __Pyx_IS_TYPE(descr, &PyMethodDescr_Type))) + #endif + #endif + { + meth_found = 1; + } else { + f = Py_TYPE(descr)->tp_descr_get; + if (f != NULL && PyDescr_IsData(descr)) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + } + } + dictptr = _PyObject_GetDictPtr(obj); + if (dictptr != NULL && (dict = *dictptr) != NULL) { + Py_INCREF(dict); + attr = __Pyx_PyDict_GetItemStr(dict, name); + if (attr != NULL) { + Py_INCREF(attr); + Py_DECREF(dict); + Py_XDECREF(descr); + goto try_unpack; + } + Py_DECREF(dict); + } + if (meth_found) { + *method = descr; + return 1; + } + if (f != NULL) { + attr = f(descr, obj, (PyObject *)Py_TYPE(obj)); + Py_DECREF(descr); + goto try_unpack; + } + if (likely(descr != NULL)) { + *method = descr; + return 0; + } + type_name = __Pyx_PyType_GetFullyQualifiedName(tp); + PyErr_Format(PyExc_AttributeError, + "'" __Pyx_FMT_TYPENAME "' object has no attribute '%U'", + type_name, name); + __Pyx_DECREF_TypeName(type_name); + return 0; + #else + attr = __Pyx_PyObject_GetAttrStr(obj, name); + goto try_unpack; + #endif + try_unpack: + #if CYTHON_UNPACK_METHODS + if (likely(attr) && PyMethod_Check(attr) && likely(PyMethod_GET_SELF(attr) == obj)) { + PyObject *function = PyMethod_GET_FUNCTION(attr); + Py_INCREF(function); + Py_DECREF(attr); + *method = function; + return 1; + } + #endif + *method = attr; + return 0; + } + #endif + +/* PyObjectCallMethod0 */ + static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) { + #if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[1] = {obj}; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_CallNoArg; + return PyObject_VectorcallMethod(method_name, args, 1 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + #else + PyObject *method = NULL, *result = NULL; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_CallOneArg(method, obj); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) goto bad; + result = __Pyx_PyObject_CallNoArg(method); + Py_DECREF(method); + bad: + return result; + #endif + } + +/* UnpackItemEndCheck */ + static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) { + if (unlikely(retval)) { + Py_DECREF(retval); + __Pyx_RaiseTooManyValuesError(expected); + return -1; + } + return __Pyx_IterFinish(); + } + +/* UnpackTupleError */ + static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) { + if (t == Py_None) { + __Pyx_RaiseNoneNotIterableError(); + } else { + Py_ssize_t size = __Pyx_PyTuple_GET_SIZE(t); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(size < 0)) return; + #endif + if (size < index) { + __Pyx_RaiseNeedMoreValuesError(size); + } else { + __Pyx_RaiseTooManyValuesError(index); + } + } + } + +/* UnpackTuple2 */ + static CYTHON_INLINE int __Pyx_unpack_tuple2( + PyObject* tuple, PyObject** value1, PyObject** value2, int is_tuple, int has_known_size, int decref_tuple) { + if (likely(is_tuple || PyTuple_Check(tuple))) { + Py_ssize_t size; + if (has_known_size) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + size = __Pyx_PyTuple_GET_SIZE(tuple); + if (likely(size == 2)) { + return __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple); + } + if (size >= 0) { + __Pyx_UnpackTupleError(tuple, 2); + } + return -1; + } else { + return __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple); + } + } + static CYTHON_INLINE int __Pyx_unpack_tuple2_exact( + PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) { + PyObject *value1 = NULL, *value2 = NULL; + #if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + value1 = __Pyx_PySequence_ITEM(tuple, 0); if (unlikely(!value1)) goto bad; + value2 = __Pyx_PySequence_ITEM(tuple, 1); if (unlikely(!value2)) goto bad; + #else + value1 = PyTuple_GET_ITEM(tuple, 0); Py_INCREF(value1); + value2 = PyTuple_GET_ITEM(tuple, 1); Py_INCREF(value2); + #endif + if (decref_tuple) { + Py_DECREF(tuple); + } + *pvalue1 = value1; + *pvalue2 = value2; + return 0; + #if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + bad: + Py_XDECREF(value1); + Py_XDECREF(value2); + if (decref_tuple) { Py_XDECREF(tuple); } + return -1; + #endif + } + static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, + int has_known_size, int decref_tuple) { + Py_ssize_t index; + PyObject *value1 = NULL, *value2 = NULL, *iter = NULL; + iternextfunc iternext; + iter = PyObject_GetIter(tuple); + if (unlikely(!iter)) goto bad; + if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; } + iternext = __Pyx_PyObject_GetIterNextFunc(iter); + value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; } + value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; } + if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad; + Py_DECREF(iter); + *pvalue1 = value1; + *pvalue2 = value2; + return 0; + unpacking_failed: + if (!has_known_size && __Pyx_IterFinish() == 0) + __Pyx_RaiseNeedMoreValuesError(index); + bad: + Py_XDECREF(iter); + Py_XDECREF(value1); + Py_XDECREF(value2); + if (decref_tuple) { Py_XDECREF(tuple); } + return -1; + } + +/* dict_iter */ + #if CYTHON_COMPILING_IN_PYPY + #include + #endif + static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name, + Py_ssize_t* p_orig_length, int* p_source_is_dict) { + is_dict = is_dict || likely(PyDict_CheckExact(iterable)); + *p_source_is_dict = is_dict; + if (is_dict) { + #if !CYTHON_COMPILING_IN_PYPY + *p_orig_length = PyDict_Size(iterable); + Py_INCREF(iterable); + return iterable; + #else + static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL; + PyObject **pp = NULL; + if (method_name) { + const char *name = PyUnicode_AsUTF8(method_name); + if (strcmp(name, "iteritems") == 0) pp = &py_items; + else if (strcmp(name, "iterkeys") == 0) pp = &py_keys; + else if (strcmp(name, "itervalues") == 0) pp = &py_values; + if (pp) { + if (!*pp) { + *pp = PyUnicode_FromString(name + 4); + if (!*pp) + return NULL; + } + method_name = *pp; + } + } + #endif + } + *p_orig_length = 0; + if (method_name) { + PyObject* iter; + iterable = __Pyx_PyObject_CallMethod0(iterable, method_name); + if (!iterable) + return NULL; + #if !CYTHON_COMPILING_IN_PYPY + if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable)) + return iterable; + #endif + iter = PyObject_GetIter(iterable); + Py_DECREF(iterable); + return iter; + } + return PyObject_GetIter(iterable); + } + #if !CYTHON_AVOID_BORROWED_REFS + static CYTHON_INLINE int __Pyx_dict_iter_next_source_is_dict( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem) { + PyObject *key, *value; + if (unlikely(orig_length != PyDict_Size(iter_obj))) { + PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration"); + return -1; + } + if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) { + return 0; + } + if (pitem) { + PyObject* tuple = PyTuple_New(2); + if (unlikely(!tuple)) { + return -1; + } + Py_INCREF(key); + Py_INCREF(value); + #if CYTHON_ASSUME_SAFE_MACROS + PyTuple_SET_ITEM(tuple, 0, key); + PyTuple_SET_ITEM(tuple, 1, value); + #else + if (unlikely(PyTuple_SetItem(tuple, 0, key) < 0)) { + Py_DECREF(value); + Py_DECREF(tuple); + return -1; + } + if (unlikely(PyTuple_SetItem(tuple, 1, value) < 0)) { + Py_DECREF(tuple); + return -1; + } + #endif + *pitem = tuple; + } else { + if (pkey) { + Py_INCREF(key); + *pkey = key; + } + if (pvalue) { + Py_INCREF(value); + *pvalue = value; + } + } + return 1; + } + #endif + static CYTHON_INLINE int __Pyx_dict_iter_next( + PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos, + PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) { + PyObject* next_item; + #if !CYTHON_AVOID_BORROWED_REFS + if (source_is_dict) { + int result; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_BEGIN_CRITICAL_SECTION(iter_obj); + #endif + result = __Pyx_dict_iter_next_source_is_dict(iter_obj, orig_length, ppos, pkey, pvalue, pitem); + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_END_CRITICAL_SECTION(); + #endif + return result; + } else if (PyTuple_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t tuple_size = __Pyx_PyTuple_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(tuple_size < 0)) return -1; + #endif + if (unlikely(pos >= tuple_size)) return 0; + *ppos = pos + 1; + #if CYTHON_ASSUME_SAFE_MACROS + next_item = PyTuple_GET_ITEM(iter_obj, pos); + #else + next_item = PyTuple_GetItem(iter_obj, pos); + if (unlikely(!next_item)) return -1; + #endif + Py_INCREF(next_item); + } else if (PyList_CheckExact(iter_obj)) { + Py_ssize_t pos = *ppos; + Py_ssize_t list_size = __Pyx_PyList_GET_SIZE(iter_obj); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(list_size < 0)) return -1; + #endif + if (unlikely(pos >= list_size)) return 0; + *ppos = pos + 1; + next_item = __Pyx_PyList_GetItemRef(iter_obj, pos); + if (unlikely(!next_item)) return -1; + } else + #endif + { + next_item = PyIter_Next(iter_obj); + if (unlikely(!next_item)) { + return __Pyx_IterFinish(); + } + } + if (pitem) { + *pitem = next_item; + } else if (pkey && pvalue) { + if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1)) + return -1; + } else if (pkey) { + *pkey = next_item; + } else { + *pvalue = next_item; + } + return 1; + } + +/* MergeKeywords */ + static int __Pyx_MergeKeywords_dict(PyObject *kwdict, PyObject *source_dict) { + Py_ssize_t len1, len2; + len2 = PyDict_Size(source_dict); + if (unlikely(len2 == -1)) return -1; + if (len2 == 0) { + return 0; + } + len1 = PyDict_Size(kwdict); + if (unlikely(len1 == -1)) return -1; + if (len1 > 0) { + PyObject *key, *smaller_dict, *larger_dict; + #if CYTHON_AVOID_BORROWED_REFS + PyObject *ppos = NULL; + #else + Py_ssize_t ppos = 0; + #endif + int duplicates_found = 0; + if (len1 <= len2) { + smaller_dict = kwdict; + larger_dict = source_dict; + } else { + smaller_dict = source_dict; + larger_dict = kwdict; + } + __Pyx_BEGIN_CRITICAL_SECTION(smaller_dict); + while ( + #if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + __Pyx_PyDict_NextRef(smaller_dict, &ppos, &key, NULL) + #else + PyDict_Next(smaller_dict, &ppos, &key, NULL) + #endif + ) { + if (unlikely(PyDict_Contains(larger_dict, key))) { + __Pyx_RaiseDoubleKeywordsError("function", key); + #if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_DECREF(key); + #endif + duplicates_found = 1; + break; + }; + #if CYTHON_AVOID_BORROWED_REFS || CYTHON_AVOID_THREAD_UNSAFE_BORROWED_REFS + Py_DECREF(key); + #endif + } + __Pyx_END_CRITICAL_SECTION(); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(ppos); + #endif + if (unlikely(duplicates_found)) + return -1; + } + return PyDict_Update(kwdict, source_dict); + } + static int __Pyx_MergeKeywords_any(PyObject *kwdict, PyObject *source_mapping) { + PyObject *iter, *key = NULL, *value = NULL; + int source_is_dict, result; + Py_ssize_t orig_length, ppos = 0; + iter = __Pyx_dict_iterator(source_mapping, 0, __pyx_mstate_global->__pyx_n_u_items, &orig_length, &source_is_dict); + if (unlikely(!iter)) { + PyObject *args; + if (unlikely(!PyErr_ExceptionMatches(PyExc_AttributeError))) goto bad; + PyErr_Clear(); + args = PyTuple_Pack(1, source_mapping); + if (likely(args)) { + PyObject *fallback = PyObject_Call((PyObject*)&PyDict_Type, args, NULL); + Py_DECREF(args); + if (likely(fallback)) { + result = __Pyx_MergeKeywords_dict(kwdict, fallback); + Py_DECREF(fallback); + return result; + } + } + if (unlikely(!iter)) goto bad; + } + while (1) { + result = __Pyx_dict_iter_next(iter, orig_length, &ppos, &key, &value, NULL, source_is_dict); + if (unlikely(result < 0)) goto bad; + if (!result) break; + #if PY_VERSION_HEX >= 0x030d0000 && !CYTHON_COMPILING_IN_LIMITED_API + { + int inserted = PyDict_SetDefaultRef(kwdict, key, value, NULL); + if (unlikely(inserted != 0)) { + if (inserted == 1) __Pyx_RaiseDoubleKeywordsError("function", key); + result = -1; + } + } + #else + if (unlikely(PyDict_Contains(kwdict, key))) { + __Pyx_RaiseDoubleKeywordsError("function", key); + result = -1; + } else { + result = PyDict_SetItem(kwdict, key, value); + } + #endif + Py_DECREF(key); + Py_DECREF(value); + if (unlikely(result < 0)) goto bad; + } + Py_XDECREF(iter); + return 0; + bad: + Py_XDECREF(iter); + return -1; + } + static CYTHON_INLINE int __Pyx_MergeKeywords(PyObject *kwdict, PyObject *source_mapping) { + assert(PyDict_Check(kwdict)); + if (likely(PyDict_Check(source_mapping))) { + return __Pyx_MergeKeywords_dict(kwdict, source_mapping); + } else { + return __Pyx_MergeKeywords_any(kwdict, source_mapping); + } + } + +/* SliceObject */ + static CYTHON_INLINE int __Pyx_PyObject_SetSlice(PyObject* obj, PyObject* value, + Py_ssize_t cstart, Py_ssize_t cstop, + PyObject** _py_start, PyObject** _py_stop, PyObject** _py_slice, + int has_cstart, int has_cstop, CYTHON_UNUSED int wraparound) { + __Pyx_TypeName obj_type_name; + #if CYTHON_USE_TYPE_SLOTS + PyMappingMethods* mp = Py_TYPE(obj)->tp_as_mapping; + if (likely(mp && mp->mp_ass_subscript)) + #endif + { + int result; + PyObject *py_slice, *py_start, *py_stop; + if (_py_slice) { + py_slice = *_py_slice; + } else { + PyObject* owned_start = NULL; + PyObject* owned_stop = NULL; + if (_py_start) { + py_start = *_py_start; + } else { + if (has_cstart) { + owned_start = py_start = PyLong_FromSsize_t(cstart); + if (unlikely(!py_start)) goto bad; + } else + py_start = Py_None; + } + if (_py_stop) { + py_stop = *_py_stop; + } else { + if (has_cstop) { + owned_stop = py_stop = PyLong_FromSsize_t(cstop); + if (unlikely(!py_stop)) { + Py_XDECREF(owned_start); + goto bad; + } + } else + py_stop = Py_None; + } + py_slice = PySlice_New(py_start, py_stop, Py_None); + Py_XDECREF(owned_start); + Py_XDECREF(owned_stop); + if (unlikely(!py_slice)) goto bad; + } + #if CYTHON_USE_TYPE_SLOTS + result = mp->mp_ass_subscript(obj, py_slice, value); + #else + result = value ? PyObject_SetItem(obj, py_slice, value) : PyObject_DelItem(obj, py_slice); + #endif + if (!_py_slice) { + Py_DECREF(py_slice); + } + return result; + } + obj_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(obj)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object does not support slice %.10s", + obj_type_name, value ? "assignment" : "deletion"); + __Pyx_DECREF_TypeName(obj_type_name); + bad: + return -1; + } + +/* RaiseMappingExpected */ + static void __Pyx_RaiseMappingExpectedError(PyObject* arg) { + __Pyx_TypeName arg_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(arg)); + PyErr_Format(PyExc_TypeError, + "'" __Pyx_FMT_TYPENAME "' object is not a mapping", arg_type_name); + __Pyx_DECREF_TypeName(arg_type_name); + } + +/* BufferFallbackError */ + static void __Pyx_RaiseBufferFallbackError(void) { + PyErr_SetString(PyExc_ValueError, + "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!"); + } + +/* PyLongCompare */ + static CYTHON_INLINE int __Pyx_PyLong_BoolEqObjC(PyObject *op1, PyObject *op2, long intval, long inplace) { + CYTHON_MAYBE_UNUSED_VAR(intval); + CYTHON_UNUSED_VAR(inplace); + if (op1 == op2) { + return 1; + } + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(PyLong_CheckExact(op1))) { + int unequal; + unsigned long uintval; + Py_ssize_t size = __Pyx_PyLong_DigitCount(op1); + const digit* digits = __Pyx_PyLong_Digits(op1); + if (intval == 0) { + return (__Pyx_PyLong_IsZero(op1) == 1); + } else if (intval < 0) { + if (__Pyx_PyLong_IsNonNeg(op1)) + return 0; + intval = -intval; + } else { + if (__Pyx_PyLong_IsNeg(op1)) + return 0; + } + uintval = (unsigned long) intval; + #if PyLong_SHIFT * 4 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 4)) { + unequal = (size != 5) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[4] != ((uintval >> (4 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else + #endif + #if PyLong_SHIFT * 3 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 3)) { + unequal = (size != 4) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[3] != ((uintval >> (3 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else + #endif + #if PyLong_SHIFT * 2 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 2)) { + unequal = (size != 3) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)) | (digits[2] != ((uintval >> (2 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else + #endif + #if PyLong_SHIFT * 1 < SIZEOF_LONG*8 + if (uintval >> (PyLong_SHIFT * 1)) { + unequal = (size != 2) || (digits[0] != (uintval & (unsigned long) PyLong_MASK)) + | (digits[1] != ((uintval >> (1 * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)); + } else + #endif + unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK)); + return (unequal == 0); + } + #endif + if (PyFloat_CheckExact(op1)) { + const long b = intval; + double a = __Pyx_PyFloat_AS_DOUBLE(op1); + return ((double)a == (double)b); + } + return __Pyx_PyObject_IsTrueAndDecref( + PyObject_RichCompare(op1, op2, Py_EQ)); + } + +/* AllocateExtensionType */ + static PyObject *__Pyx_AllocateExtensionType(PyTypeObject *t, int is_final) { + if (is_final || likely(!__Pyx_PyType_HasFeature(t, Py_TPFLAGS_IS_ABSTRACT))) { + allocfunc alloc_func = __Pyx_PyType_GetSlot(t, tp_alloc, allocfunc); + return alloc_func(t, 0); + } else { + newfunc tp_new = __Pyx_PyType_TryGetSlot(&PyBaseObject_Type, tp_new, newfunc); + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (!tp_new) { + PyObject *new_str = PyUnicode_FromString("__new__"); + if (likely(new_str)) { + PyObject *o = PyObject_CallMethodObjArgs((PyObject *)&PyBaseObject_Type, new_str, t, NULL); + Py_DECREF(new_str); + return o; + } else + return NULL; + } else + #endif + return tp_new(t, __pyx_mstate_global->__pyx_empty_tuple, 0); + } + } + +/* CallTypeTraverse */ + #if !CYTHON_USE_TYPE_SPECS || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x03090000) + #else + static int __Pyx_call_type_traverse(PyObject *o, int always_call, visitproc visit, void *arg) { + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x03090000 + if (__Pyx_get_runtime_version() < 0x03090000) return 0; + #endif + if (!always_call) { + PyTypeObject *base = __Pyx_PyObject_GetSlot(o, tp_base, PyTypeObject*); + unsigned long flags = PyType_GetFlags(base); + if (flags & Py_TPFLAGS_HEAPTYPE) { + return 0; + } + } + Py_VISIT((PyObject*)Py_TYPE(o)); + return 0; + } + #endif + +/* LimitedApiGetTypeDict */ + #if CYTHON_COMPILING_IN_LIMITED_API + static Py_ssize_t __Pyx_GetTypeDictOffset(void) { + PyObject *tp_dictoffset_o; + Py_ssize_t tp_dictoffset; + tp_dictoffset_o = PyObject_GetAttrString((PyObject*)(&PyType_Type), "__dictoffset__"); + if (unlikely(!tp_dictoffset_o)) return -1; + tp_dictoffset = PyLong_AsSsize_t(tp_dictoffset_o); + Py_DECREF(tp_dictoffset_o); + if (unlikely(tp_dictoffset == 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' doesn't have a dictoffset"); + return -1; + } else if (unlikely(tp_dictoffset < 0)) { + PyErr_SetString( + PyExc_TypeError, + "'type' has an unexpected negative dictoffset. " + "Please report this as Cython bug"); + return -1; + } + return tp_dictoffset; + } + static PyObject *__Pyx_GetTypeDict(PyTypeObject *tp) { + static Py_ssize_t tp_dictoffset = 0; + if (unlikely(tp_dictoffset == 0)) { + tp_dictoffset = __Pyx_GetTypeDictOffset(); + if (unlikely(tp_dictoffset == -1 && PyErr_Occurred())) { + tp_dictoffset = 0; // try again next time? + return NULL; + } + } + return *(PyObject**)((char*)tp + tp_dictoffset); + } + #endif + +/* SetItemOnTypeDict */ + static int __Pyx__SetItemOnTypeDict(PyTypeObject *tp, PyObject *k, PyObject *v) { + int result; + PyObject *tp_dict; + #if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; + #else + tp_dict = tp->tp_dict; + #endif + result = PyDict_SetItem(tp_dict, k, v); + if (likely(!result)) { + PyType_Modified(tp); + if (unlikely(PyObject_HasAttr(v, __pyx_mstate_global->__pyx_n_u_set_name))) { + PyObject *setNameResult = PyObject_CallMethodObjArgs(v, __pyx_mstate_global->__pyx_n_u_set_name, (PyObject *) tp, k, NULL); + if (!setNameResult) return -1; + Py_DECREF(setNameResult); + } + } + return result; + } + +/* FixUpExtensionType */ + static int __Pyx_fix_up_extension_type_from_spec(PyType_Spec *spec, PyTypeObject *type) { + #if __PYX_LIMITED_VERSION_HEX > 0x030900B1 + CYTHON_UNUSED_VAR(spec); + CYTHON_UNUSED_VAR(type); + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + #else + const PyType_Slot *slot = spec->slots; + int changed = 0; + #if !CYTHON_COMPILING_IN_LIMITED_API + while (slot && slot->slot && slot->slot != Py_tp_members) + slot++; + if (slot && slot->slot == Py_tp_members) { + #if !CYTHON_COMPILING_IN_CPYTHON + const + #endif // !CYTHON_COMPILING_IN_CPYTHON) + PyMemberDef *memb = (PyMemberDef*) slot->pfunc; + while (memb && memb->name) { + if (memb->name[0] == '_' && memb->name[1] == '_') { + if (strcmp(memb->name, "__weaklistoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_weaklistoffset = memb->offset; + changed = 1; + } + else if (strcmp(memb->name, "__dictoffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_dictoffset = memb->offset; + changed = 1; + } + #if CYTHON_METH_FASTCALL + else if (strcmp(memb->name, "__vectorcalloffset__") == 0) { + assert(memb->type == T_PYSSIZET); + assert(memb->flags == READONLY); + type->tp_vectorcall_offset = memb->offset; + changed = 1; + } + #endif // CYTHON_METH_FASTCALL + #if !CYTHON_COMPILING_IN_PYPY + else if (strcmp(memb->name, "__module__") == 0) { + PyObject *descr; + assert(memb->type == T_OBJECT); + assert(memb->flags == 0 || memb->flags == READONLY); + descr = PyDescr_NewMember(type, memb); + if (unlikely(!descr)) + return -1; + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + #endif // !CYTHON_COMPILING_IN_PYPY + } + memb++; + } + } + #endif // !CYTHON_COMPILING_IN_LIMITED_API + #if !CYTHON_COMPILING_IN_PYPY + slot = spec->slots; + while (slot && slot->slot && slot->slot != Py_tp_getset) + slot++; + if (slot && slot->slot == Py_tp_getset) { + PyGetSetDef *getset = (PyGetSetDef*) slot->pfunc; + while (getset && getset->name) { + if (getset->name[0] == '_' && getset->name[1] == '_' && strcmp(getset->name, "__module__") == 0) { + PyObject *descr = PyDescr_NewGetSet(type, getset); + if (unlikely(!descr)) + return -1; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *pyname = PyUnicode_FromString(getset->name); + if (unlikely(!pyname)) { + Py_DECREF(descr); + return -1; + } + int set_item_result = __Pyx_SetItemOnTypeDict(type, pyname, descr); + Py_DECREF(pyname); + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + int set_item_result = PyDict_SetItem(type->tp_dict, PyDescr_NAME(descr), descr); + #endif + Py_DECREF(descr); + if (unlikely(set_item_result < 0)) { + return -1; + } + changed = 1; + } + ++getset; + } + } + #else + CYTHON_UNUSED_VAR(__Pyx__SetItemOnTypeDict); + #endif // !CYTHON_COMPILING_IN_PYPY + if (changed) + PyType_Modified(type); + #endif // PY_VERSION_HEX > 0x030900B1 + return 0; + } + +/* ValidateBasesTuple */ + #if CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_LIMITED_API || CYTHON_USE_TYPE_SPECS + static int __Pyx_validate_bases_tuple(const char *type_name, Py_ssize_t dictoffset, PyObject *bases) { + Py_ssize_t i, n; + #if CYTHON_ASSUME_SAFE_SIZE + n = PyTuple_GET_SIZE(bases); + #else + n = PyTuple_Size(bases); + if (unlikely(n < 0)) return -1; + #endif + for (i = 1; i < n; i++) + { + PyTypeObject *b; + #if CYTHON_AVOID_BORROWED_REFS + PyObject *b0 = PySequence_GetItem(bases, i); + if (!b0) return -1; + #elif CYTHON_ASSUME_SAFE_MACROS + PyObject *b0 = PyTuple_GET_ITEM(bases, i); + #else + PyObject *b0 = PyTuple_GetItem(bases, i); + if (!b0) return -1; + #endif + b = (PyTypeObject*) b0; + if (!__Pyx_PyType_HasFeature(b, Py_TPFLAGS_HEAPTYPE)) + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "base class '" __Pyx_FMT_TYPENAME "' is not a heap type", b_name); + __Pyx_DECREF_TypeName(b_name); + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); + #endif + return -1; + } + if (dictoffset == 0) + { + Py_ssize_t b_dictoffset = 0; + #if CYTHON_USE_TYPE_SLOTS + b_dictoffset = b->tp_dictoffset; + #else + PyObject *py_b_dictoffset = PyObject_GetAttrString((PyObject*)b, "__dictoffset__"); + if (!py_b_dictoffset) goto dictoffset_return; + b_dictoffset = PyLong_AsSsize_t(py_b_dictoffset); + Py_DECREF(py_b_dictoffset); + if (b_dictoffset == -1 && PyErr_Occurred()) goto dictoffset_return; + #endif + if (b_dictoffset) { + { + __Pyx_TypeName b_name = __Pyx_PyType_GetFullyQualifiedName(b); + PyErr_Format(PyExc_TypeError, + "extension type '%.200s' has no __dict__ slot, " + "but base type '" __Pyx_FMT_TYPENAME "' has: " + "either add 'cdef dict __dict__' to the extension type " + "or add '__slots__ = [...]' to the base type", + type_name, b_name); + __Pyx_DECREF_TypeName(b_name); + } + #if !CYTHON_USE_TYPE_SLOTS + dictoffset_return: + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); + #endif + return -1; + } + } + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(b0); + #endif + } + return 0; + } + #endif + +/* PyType_Ready */ + CYTHON_UNUSED static int __Pyx_PyType_HasMultipleInheritance(PyTypeObject *t) { + while (t) { + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases) { + return 1; + } + t = __Pyx_PyType_GetSlot(t, tp_base, PyTypeObject*); + } + return 0; + } + static int __Pyx_PyType_Ready(PyTypeObject *t) { + #if CYTHON_USE_TYPE_SPECS || !CYTHON_COMPILING_IN_CPYTHON || defined(PYSTON_MAJOR_VERSION) + (void)__Pyx_PyObject_CallMethod0; + #if CYTHON_USE_TYPE_SPECS + (void)__Pyx_validate_bases_tuple; + #endif + return PyType_Ready(t); + #else + int r; + if (!__Pyx_PyType_HasMultipleInheritance(t)) { + return PyType_Ready(t); + } + PyObject *bases = __Pyx_PyType_GetSlot(t, tp_bases, PyObject*); + if (bases && unlikely(__Pyx_validate_bases_tuple(t->tp_name, t->tp_dictoffset, bases) == -1)) + return -1; + #if !defined(PYSTON_MAJOR_VERSION) + { + int gc_was_enabled; + #if PY_VERSION_HEX >= 0x030A00b1 + gc_was_enabled = PyGC_Disable(); + (void)__Pyx_PyObject_CallMethod0; + #else + PyObject *ret, *py_status; + PyObject *gc = NULL; + #if (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM+0 >= 0x07030400) &&\ + !CYTHON_COMPILING_IN_GRAAL + gc = PyImport_GetModule(__pyx_mstate_global->__pyx_kp_u_gc); + #endif + if (unlikely(!gc)) gc = PyImport_Import(__pyx_mstate_global->__pyx_kp_u_gc); + if (unlikely(!gc)) return -1; + py_status = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_isenabled); + if (unlikely(!py_status)) { + Py_DECREF(gc); + return -1; + } + gc_was_enabled = __Pyx_PyObject_IsTrue(py_status); + Py_DECREF(py_status); + if (gc_was_enabled > 0) { + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_disable); + if (unlikely(!ret)) { + Py_DECREF(gc); + return -1; + } + Py_DECREF(ret); + } else if (unlikely(gc_was_enabled == -1)) { + Py_DECREF(gc); + return -1; + } + #endif + t->tp_flags |= Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A0000 + t->tp_flags |= Py_TPFLAGS_IMMUTABLETYPE; + #endif + #else + (void)__Pyx_PyObject_CallMethod0; + #endif + r = PyType_Ready(t); + #if !defined(PYSTON_MAJOR_VERSION) + t->tp_flags &= ~Py_TPFLAGS_HEAPTYPE; + #if PY_VERSION_HEX >= 0x030A00b1 + if (gc_was_enabled) + PyGC_Enable(); + #else + if (gc_was_enabled) { + PyObject *tp, *v, *tb; + PyErr_Fetch(&tp, &v, &tb); + ret = __Pyx_PyObject_CallMethod0(gc, __pyx_mstate_global->__pyx_kp_u_enable); + if (likely(ret || r == -1)) { + Py_XDECREF(ret); + PyErr_Restore(tp, v, tb); + } else { + Py_XDECREF(tp); + Py_XDECREF(v); + Py_XDECREF(tb); + r = -1; + } + } + Py_DECREF(gc); + #endif + } + #endif + return r; + #endif + } + +/* SetVTable */ + static int __Pyx_SetVtable(PyTypeObject *type, void *vtable) { + PyObject *ob = PyCapsule_New(vtable, 0, 0); + if (unlikely(!ob)) + goto bad; + #if CYTHON_COMPILING_IN_LIMITED_API + if (unlikely(PyObject_SetAttr((PyObject *) type, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) + #else + if (unlikely(PyDict_SetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable, ob) < 0)) + #endif + goto bad; + Py_DECREF(ob); + return 0; + bad: + Py_XDECREF(ob); + return -1; + } + +/* GetVTable */ + static void* __Pyx_GetVtable(PyTypeObject *type) { + void* ptr; + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *ob = PyObject_GetAttr((PyObject *)type, __pyx_mstate_global->__pyx_n_u_pyx_vtable); + #else + PyObject *ob = PyObject_GetItem(type->tp_dict, __pyx_mstate_global->__pyx_n_u_pyx_vtable); + #endif + if (!ob) + goto bad; + ptr = PyCapsule_GetPointer(ob, 0); + if (!ptr && !PyErr_Occurred()) + PyErr_SetString(PyExc_RuntimeError, "invalid vtable found for imported type"); + Py_DECREF(ob); + return ptr; + bad: + Py_XDECREF(ob); + return NULL; + } + +/* MergeVTables */ + static int __Pyx_MergeVtables(PyTypeObject *type) { + int i=0; + Py_ssize_t size; + void** base_vtables; + __Pyx_TypeName tp_base_name = NULL; + __Pyx_TypeName base_name = NULL; + void* unknown = (void*)-1; + PyObject* bases = __Pyx_PyType_GetSlot(type, tp_bases, PyObject*); + int base_depth = 0; + { + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + while (base) { + base_depth += 1; + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); + } + } + base_vtables = (void**) PyMem_Malloc(sizeof(void*) * (size_t)(base_depth + 1)); + base_vtables[0] = unknown; + #if CYTHON_COMPILING_IN_LIMITED_API + size = PyTuple_Size(bases); + if (size < 0) goto other_failure; + #else + size = PyTuple_GET_SIZE(bases); + #endif + for (i = 1; i < size; i++) { + PyObject *basei; + void* base_vtable; + #if CYTHON_AVOID_BORROWED_REFS + basei = PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; + #elif !CYTHON_ASSUME_SAFE_MACROS + basei = PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto other_failure; + #else + basei = PyTuple_GET_ITEM(bases, i); + #endif + base_vtable = __Pyx_GetVtable((PyTypeObject*)basei); + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); + #endif + if (base_vtable != NULL) { + int j; + PyTypeObject* base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + for (j = 0; j < base_depth; j++) { + if (base_vtables[j] == unknown) { + base_vtables[j] = __Pyx_GetVtable(base); + base_vtables[j + 1] = unknown; + } + if (base_vtables[j] == base_vtable) { + break; + } else if (base_vtables[j] == NULL) { + goto bad; + } + base = __Pyx_PyType_GetSlot(base, tp_base, PyTypeObject*); + } + } + } + PyErr_Clear(); + PyMem_Free(base_vtables); + return 0; + bad: + { + PyTypeObject* basei = NULL; + PyTypeObject* tp_base = __Pyx_PyType_GetSlot(type, tp_base, PyTypeObject*); + tp_base_name = __Pyx_PyType_GetFullyQualifiedName(tp_base); + #if CYTHON_AVOID_BORROWED_REFS + basei = (PyTypeObject*)PySequence_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; + #elif !CYTHON_ASSUME_SAFE_MACROS + basei = (PyTypeObject*)PyTuple_GetItem(bases, i); + if (unlikely(!basei)) goto really_bad; + #else + basei = (PyTypeObject*)PyTuple_GET_ITEM(bases, i); + #endif + base_name = __Pyx_PyType_GetFullyQualifiedName(basei); + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(basei); + #endif + } + PyErr_Format(PyExc_TypeError, + "multiple bases have vtable conflict: '" __Pyx_FMT_TYPENAME "' and '" __Pyx_FMT_TYPENAME "'", tp_base_name, base_name); + #if CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + really_bad: // bad has failed! + #endif + __Pyx_DECREF_TypeName(tp_base_name); + __Pyx_DECREF_TypeName(base_name); + #if CYTHON_COMPILING_IN_LIMITED_API || CYTHON_AVOID_BORROWED_REFS || !CYTHON_ASSUME_SAFE_MACROS + other_failure: + #endif + PyMem_Free(base_vtables); + return -1; + } + +/* DelItemOnTypeDict */ + static int __Pyx__DelItemOnTypeDict(PyTypeObject *tp, PyObject *k) { + int result; + PyObject *tp_dict; + #if CYTHON_COMPILING_IN_LIMITED_API + tp_dict = __Pyx_GetTypeDict(tp); + if (unlikely(!tp_dict)) return -1; + #else + tp_dict = tp->tp_dict; + #endif + result = PyDict_DelItem(tp_dict, k); + if (likely(!result)) PyType_Modified(tp); + return result; + } + +/* SetupReduce */ + static int __Pyx_setup_reduce_is_named(PyObject* meth, PyObject* name) { + int ret; + PyObject *name_attr; + name_attr = __Pyx_PyObject_GetAttrStrNoError(meth, __pyx_mstate_global->__pyx_n_u_name_2); + if (likely(name_attr)) { + ret = PyObject_RichCompareBool(name_attr, name, Py_EQ); + } else { + ret = -1; + } + if (unlikely(ret < 0)) { + PyErr_Clear(); + ret = 0; + } + Py_XDECREF(name_attr); + return ret; + } + static int __Pyx_setup_reduce(PyObject* type_obj) { + int ret = 0; + PyObject *object_reduce = NULL; + PyObject *object_getstate = NULL; + PyObject *object_reduce_ex = NULL; + PyObject *reduce = NULL; + PyObject *reduce_ex = NULL; + PyObject *reduce_cython = NULL; + PyObject *setstate = NULL; + PyObject *setstate_cython = NULL; + PyObject *getstate = NULL; + #if CYTHON_USE_PYTYPE_LOOKUP + getstate = _PyType_Lookup((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_getstate); + #else + getstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_getstate); + if (!getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } + #endif + if (getstate) { + #if CYTHON_USE_PYTYPE_LOOKUP + object_getstate = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate); + #else + object_getstate = __Pyx_PyObject_GetAttrStrNoError((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_getstate); + if (!object_getstate && PyErr_Occurred()) { + goto __PYX_BAD; + } + #endif + if (object_getstate != getstate) { + goto __PYX_GOOD; + } + } + #if CYTHON_USE_PYTYPE_LOOKUP + object_reduce_ex = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + #else + object_reduce_ex = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (!object_reduce_ex) goto __PYX_BAD; + #endif + reduce_ex = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_ex); if (unlikely(!reduce_ex)) goto __PYX_BAD; + if (reduce_ex == object_reduce_ex) { + #if CYTHON_USE_PYTYPE_LOOKUP + object_reduce = _PyType_Lookup(&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; + #else + object_reduce = __Pyx_PyObject_GetAttrStr((PyObject*)&PyBaseObject_Type, __pyx_mstate_global->__pyx_n_u_reduce); if (!object_reduce) goto __PYX_BAD; + #endif + reduce = __Pyx_PyObject_GetAttrStr(type_obj, __pyx_mstate_global->__pyx_n_u_reduce); if (unlikely(!reduce)) goto __PYX_BAD; + if (reduce == object_reduce || __Pyx_setup_reduce_is_named(reduce, __pyx_mstate_global->__pyx_n_u_reduce_cython)) { + reduce_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); + if (likely(reduce_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce, reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_reduce_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (reduce == object_reduce || PyErr_Occurred()) { + goto __PYX_BAD; + } + setstate = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate); + if (!setstate) PyErr_Clear(); + if (!setstate || __Pyx_setup_reduce_is_named(setstate, __pyx_mstate_global->__pyx_n_u_setstate_cython)) { + setstate_cython = __Pyx_PyObject_GetAttrStrNoError(type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); + if (likely(setstate_cython)) { + ret = __Pyx_SetItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate, setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + ret = __Pyx_DelItemOnTypeDict((PyTypeObject*)type_obj, __pyx_mstate_global->__pyx_n_u_setstate_cython); if (unlikely(ret < 0)) goto __PYX_BAD; + } else if (!setstate || PyErr_Occurred()) { + goto __PYX_BAD; + } + } + PyType_Modified((PyTypeObject*)type_obj); + } + } + goto __PYX_GOOD; + __PYX_BAD: + if (!PyErr_Occurred()) { + __Pyx_TypeName type_obj_name = + __Pyx_PyType_GetFullyQualifiedName((PyTypeObject*)type_obj); + PyErr_Format(PyExc_RuntimeError, + "Unable to initialize pickling for " __Pyx_FMT_TYPENAME, type_obj_name); + __Pyx_DECREF_TypeName(type_obj_name); + } + ret = -1; + __PYX_GOOD: + #if !CYTHON_USE_PYTYPE_LOOKUP + Py_XDECREF(object_reduce); + Py_XDECREF(object_reduce_ex); + Py_XDECREF(object_getstate); + Py_XDECREF(getstate); + #endif + Py_XDECREF(reduce); + Py_XDECREF(reduce_ex); + Py_XDECREF(reduce_cython); + Py_XDECREF(setstate); + Py_XDECREF(setstate_cython); + return ret; + } + +/* TypeImport */ + #ifndef __PYX_HAVE_RT_ImportType_3_2_0 + #define __PYX_HAVE_RT_ImportType_3_2_0 + static PyTypeObject *__Pyx_ImportType_3_2_0(PyObject *module, const char *module_name, const char *class_name, + size_t size, size_t alignment, enum __Pyx_ImportType_CheckSize_3_2_0 check_size) + { + PyObject *result = 0; + Py_ssize_t basicsize; + Py_ssize_t itemsize; + #if defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) + PyObject *py_basicsize; + PyObject *py_itemsize; + #endif + result = PyObject_GetAttrString(module, class_name); + if (!result) + goto bad; + if (!PyType_Check(result)) { + PyErr_Format(PyExc_TypeError, + "%.200s.%.200s is not a type object", + module_name, class_name); + goto bad; + } + #if !( defined(Py_LIMITED_API) || (defined(CYTHON_COMPILING_IN_LIMITED_API) && CYTHON_COMPILING_IN_LIMITED_API) ) + basicsize = ((PyTypeObject *)result)->tp_basicsize; + itemsize = ((PyTypeObject *)result)->tp_itemsize; + #else + if (size == 0) { + return (PyTypeObject *)result; + } + py_basicsize = PyObject_GetAttrString(result, "__basicsize__"); + if (!py_basicsize) + goto bad; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = 0; + if (basicsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; + py_itemsize = PyObject_GetAttrString(result, "__itemsize__"); + if (!py_itemsize) + goto bad; + itemsize = PyLong_AsSsize_t(py_itemsize); + Py_DECREF(py_itemsize); + py_itemsize = 0; + if (itemsize == (Py_ssize_t)-1 && PyErr_Occurred()) + goto bad; + #endif + if (itemsize) { + if (size % alignment) { + alignment = size % alignment; + } + if (itemsize < (Py_ssize_t)alignment) + itemsize = (Py_ssize_t)alignment; + } + if ((size_t)(basicsize + itemsize) < size) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize+itemsize); + goto bad; + } + if (check_size == __Pyx_ImportType_CheckSize_Error_3_2_0 && + ((size_t)basicsize > size || (size_t)(basicsize + itemsize) < size)) { + PyErr_Format(PyExc_ValueError, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd-%zd from PyObject", + module_name, class_name, size, basicsize, basicsize+itemsize); + goto bad; + } + else if (check_size == __Pyx_ImportType_CheckSize_Warn_3_2_0 && (size_t)basicsize > size) { + if (PyErr_WarnFormat(NULL, 0, + "%.200s.%.200s size changed, may indicate binary incompatibility. " + "Expected %zd from C header, got %zd from PyObject", + module_name, class_name, size, basicsize) < 0) { + goto bad; + } + } + return (PyTypeObject *)result; + bad: + Py_XDECREF(result); + return NULL; + } + #endif + +/* dict_setdefault */ + static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value) { + PyObject* value; + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + PyObject *args[] = {d, key, default_value}; + value = PyObject_VectorcallMethod(__pyx_mstate_global->__pyx_n_u_setdefault, args, 3 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + #elif CYTHON_COMPILING_IN_LIMITED_API + value = PyObject_CallMethodObjArgs(d, __pyx_mstate_global->__pyx_n_u_setdefault, key, default_value, NULL); + #elif PY_VERSION_HEX >= 0x030d0000 + PyDict_SetDefaultRef(d, key, default_value, &value); + #else + value = PyDict_SetDefault(d, key, default_value); + if (unlikely(!value)) return NULL; + Py_INCREF(value); + #endif + return value; + } + +/* AddModuleRef */ + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + static PyObject *__Pyx_PyImport_AddModuleObjectRef(PyObject *name) { + PyObject *module_dict = PyImport_GetModuleDict(); + PyObject *m; + if (PyMapping_GetOptionalItem(module_dict, name, &m) < 0) { + return NULL; + } + if (m != NULL && PyModule_Check(m)) { + return m; + } + Py_XDECREF(m); + m = PyModule_NewObject(name); + if (m == NULL) + return NULL; + if (PyDict_CheckExact(module_dict)) { + PyObject *new_m; + (void)PyDict_SetDefaultRef(module_dict, name, m, &new_m); + Py_DECREF(m); + return new_m; + } else { + if (PyObject_SetItem(module_dict, name, m) != 0) { + Py_DECREF(m); + return NULL; + } + return m; + } + } + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *py_name = PyUnicode_FromString(name); + if (!py_name) return NULL; + PyObject *module = __Pyx_PyImport_AddModuleObjectRef(py_name); + Py_DECREF(py_name); + return module; + } + #elif __PYX_LIMITED_VERSION_HEX >= 0x030d0000 + #define __Pyx_PyImport_AddModuleRef(name) PyImport_AddModuleRef(name) + #else + static PyObject *__Pyx_PyImport_AddModuleRef(const char *name) { + PyObject *module = PyImport_AddModule(name); + Py_XINCREF(module); + return module; + } + #endif + +/* FetchSharedCythonModule */ + static PyObject *__Pyx_FetchSharedCythonABIModule(void) { + return __Pyx_PyImport_AddModuleRef(__PYX_ABI_MODULE_NAME); + } + +/* FetchCommonType */ + #if __PYX_LIMITED_VERSION_HEX < 0x030C0000 + static PyObject* __Pyx_PyType_FromMetaclass(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *result = __Pyx_PyType_FromModuleAndSpec(module, spec, bases); + if (result && metaclass) { + PyObject *old_tp = (PyObject*)Py_TYPE(result); + Py_INCREF((PyObject*)metaclass); + #if __PYX_LIMITED_VERSION_HEX >= 0x03090000 + Py_SET_TYPE(result, metaclass); + #else + result->ob_type = metaclass; + #endif + Py_DECREF(old_tp); + } + return result; + } + #else + #define __Pyx_PyType_FromMetaclass(me, mo, s, b) PyType_FromMetaclass(me, mo, s, b) + #endif + static int __Pyx_VerifyCachedType(PyObject *cached_type, + const char *name, + Py_ssize_t expected_basicsize) { + Py_ssize_t basicsize; + if (!PyType_Check(cached_type)) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s is not a type object", name); + return -1; + } + if (expected_basicsize == 0) { + return 0; // size is inherited, nothing useful to check + } + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_basicsize; + py_basicsize = PyObject_GetAttrString(cached_type, "__basicsize__"); + if (unlikely(!py_basicsize)) return -1; + basicsize = PyLong_AsSsize_t(py_basicsize); + Py_DECREF(py_basicsize); + py_basicsize = NULL; + if (unlikely(basicsize == (Py_ssize_t)-1) && PyErr_Occurred()) return -1; + #else + basicsize = ((PyTypeObject*) cached_type)->tp_basicsize; + #endif + if (basicsize != expected_basicsize) { + PyErr_Format(PyExc_TypeError, + "Shared Cython type %.200s has the wrong size, try recompiling", + name); + return -1; + } + return 0; + } + static PyTypeObject *__Pyx_FetchCommonTypeFromSpec(PyTypeObject *metaclass, PyObject *module, PyType_Spec *spec, PyObject *bases) { + PyObject *abi_module = NULL, *cached_type = NULL, *abi_module_dict, *new_cached_type, *py_object_name; + int get_item_ref_result; + const char* object_name = strrchr(spec->name, '.'); + object_name = object_name ? object_name+1 : spec->name; + py_object_name = PyUnicode_FromString(object_name); + if (!py_object_name) return NULL; + abi_module = __Pyx_FetchSharedCythonABIModule(); + if (!abi_module) goto done; + abi_module_dict = PyModule_GetDict(abi_module); + if (!abi_module_dict) goto done; + get_item_ref_result = __Pyx_PyDict_GetItemRef(abi_module_dict, py_object_name, &cached_type); + if (get_item_ref_result == 1) { + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else if (unlikely(get_item_ref_result == -1)) { + goto bad; + } + cached_type = __Pyx_PyType_FromMetaclass( + metaclass, + CYTHON_USE_MODULE_STATE ? module : abi_module, + spec, bases); + if (unlikely(!cached_type)) goto bad; + if (unlikely(__Pyx_fix_up_extension_type_from_spec(spec, (PyTypeObject *) cached_type) < 0)) goto bad; + new_cached_type = __Pyx_PyDict_SetDefault(abi_module_dict, py_object_name, cached_type); + if (unlikely(new_cached_type != cached_type)) { + if (unlikely(!new_cached_type)) goto bad; + Py_DECREF(cached_type); + cached_type = new_cached_type; + if (__Pyx_VerifyCachedType( + cached_type, + object_name, + spec->basicsize) < 0) { + goto bad; + } + goto done; + } else { + Py_DECREF(new_cached_type); + } + done: + Py_XDECREF(abi_module); + Py_DECREF(py_object_name); + assert(cached_type == NULL || PyType_Check(cached_type)); + return (PyTypeObject *) cached_type; + bad: + Py_XDECREF(cached_type); + cached_type = NULL; + goto done; + } + +/* CommonTypesMetaclass */ + static PyObject* __pyx_CommonTypesMetaclass_get_module(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED void* context) { + return PyUnicode_FromString(__PYX_ABI_MODULE_NAME); + } + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + static PyObject* __pyx_CommonTypesMetaclass_call(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *args, CYTHON_UNUSED PyObject *kwds) { + PyErr_SetString(PyExc_TypeError, "Cannot instantiate Cython internal types"); + return NULL; + } + static int __pyx_CommonTypesMetaclass_setattr(CYTHON_UNUSED PyObject *self, CYTHON_UNUSED PyObject *attr, CYTHON_UNUSED PyObject *value) { + PyErr_SetString(PyExc_TypeError, "Cython internal types are immutable"); + return -1; + } + #endif + static PyGetSetDef __pyx_CommonTypesMetaclass_getset[] = { + {"__module__", __pyx_CommonTypesMetaclass_get_module, NULL, NULL, NULL}, + {0, 0, 0, 0, 0} + }; + static PyType_Slot __pyx_CommonTypesMetaclass_slots[] = { + {Py_tp_getset, (void *)__pyx_CommonTypesMetaclass_getset}, + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + {Py_tp_call, (void*)__pyx_CommonTypesMetaclass_call}, + {Py_tp_new, (void*)__pyx_CommonTypesMetaclass_call}, + {Py_tp_setattro, (void*)__pyx_CommonTypesMetaclass_setattr}, + #endif + {0, 0} + }; + static PyType_Spec __pyx_CommonTypesMetaclass_spec = { + __PYX_TYPE_MODULE_PREFIX "_common_types_metatype", + 0, + 0, + Py_TPFLAGS_IMMUTABLETYPE | + Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT, + __pyx_CommonTypesMetaclass_slots + }; + static int __pyx_CommonTypesMetaclass_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + PyObject *bases = PyTuple_Pack(1, &PyType_Type); + if (unlikely(!bases)) { + return -1; + } + mstate->__pyx_CommonTypesMetaclassType = __Pyx_FetchCommonTypeFromSpec(NULL, module, &__pyx_CommonTypesMetaclass_spec, bases); + Py_DECREF(bases); + if (unlikely(mstate->__pyx_CommonTypesMetaclassType == NULL)) { + return -1; + } + return 0; + } + +/* PyMethodNew */ + #if CYTHON_COMPILING_IN_LIMITED_API + static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + PyObject *result; + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + #if __PYX_LIMITED_VERSION_HEX >= 0x030C0000 + { + PyObject *args[] = {func, self}; + result = PyObject_Vectorcall(__pyx_mstate_global->__Pyx_CachedMethodType, args, 2, NULL); + } + #else + result = PyObject_CallFunctionObjArgs(__pyx_mstate_global->__Pyx_CachedMethodType, func, self, NULL); + #endif + return result; + } + #else + static PyObject *__Pyx_PyMethod_New(PyObject *func, PyObject *self, PyObject *typ) { + CYTHON_UNUSED_VAR(typ); + if (!self) + return __Pyx_NewRef(func); + return PyMethod_New(func, self); + } + #endif + +/* PyVectorcallFastCallDict */ + #if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL + static PyObject *__Pyx_PyVectorcall_FastCallDict_kw(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) + { + PyObject *res = NULL; + PyObject *kwnames; + PyObject **newargs; + PyObject **kwvalues; + Py_ssize_t i; + #if CYTHON_AVOID_BORROWED_REFS + PyObject *pos; + #else + Py_ssize_t pos; + #endif + size_t j; + PyObject *key, *value; + unsigned long keys_are_strings; + #if !CYTHON_ASSUME_SAFE_SIZE + Py_ssize_t nkw = PyDict_Size(kw); + if (unlikely(nkw == -1)) return NULL; + #else + Py_ssize_t nkw = PyDict_GET_SIZE(kw); + #endif + newargs = (PyObject **)PyMem_Malloc((nargs + (size_t)nkw) * sizeof(args[0])); + if (unlikely(newargs == NULL)) { + PyErr_NoMemory(); + return NULL; + } + for (j = 0; j < nargs; j++) newargs[j] = args[j]; + kwnames = PyTuple_New(nkw); + if (unlikely(kwnames == NULL)) { + PyMem_Free(newargs); + return NULL; + } + kwvalues = newargs + nargs; + pos = 0; + i = 0; + keys_are_strings = Py_TPFLAGS_UNICODE_SUBCLASS; + while (__Pyx_PyDict_NextRef(kw, &pos, &key, &value)) { + keys_are_strings &= + #if CYTHON_COMPILING_IN_LIMITED_API + PyType_GetFlags(Py_TYPE(key)); + #else + Py_TYPE(key)->tp_flags; + #endif + #if !CYTHON_ASSUME_SAFE_MACROS + if (unlikely(PyTuple_SetItem(kwnames, i, key) < 0)) goto cleanup; + #else + PyTuple_SET_ITEM(kwnames, i, key); + #endif + kwvalues[i] = value; + i++; + } + if (unlikely(!keys_are_strings)) { + PyErr_SetString(PyExc_TypeError, "keywords must be strings"); + goto cleanup; + } + res = vc(func, newargs, nargs, kwnames); + cleanup: + #if CYTHON_AVOID_BORROWED_REFS + Py_DECREF(pos); + #endif + Py_DECREF(kwnames); + for (i = 0; i < nkw; i++) + Py_DECREF(kwvalues[i]); + PyMem_Free(newargs); + return res; + } + static CYTHON_INLINE PyObject *__Pyx_PyVectorcall_FastCallDict(PyObject *func, __pyx_vectorcallfunc vc, PyObject *const *args, size_t nargs, PyObject *kw) + { + Py_ssize_t kw_size = + likely(kw == NULL) ? + 0 : + #if !CYTHON_ASSUME_SAFE_SIZE + PyDict_Size(kw); + #else + PyDict_GET_SIZE(kw); + #endif + if (kw_size == 0) { + return vc(func, args, nargs, NULL); + } + #if !CYTHON_ASSUME_SAFE_SIZE + else if (unlikely(kw_size == -1)) { + return NULL; + } + #endif + return __Pyx_PyVectorcall_FastCallDict_kw(func, vc, args, nargs, kw); + } + #endif + +/* CythonFunctionShared */ + #if CYTHON_COMPILING_IN_LIMITED_API + static CYTHON_INLINE int __Pyx__IsSameCyOrCFunctionNoMethod(PyObject *func, void (*cfunc)(void)) { + if (__Pyx_CyFunction_Check(func)) { + return PyCFunction_GetFunction(((__pyx_CyFunctionObject*)func)->func) == (PyCFunction) cfunc; + } else if (PyCFunction_Check(func)) { + return PyCFunction_GetFunction(func) == (PyCFunction) cfunc; + } + return 0; + } + static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if ((PyObject*)Py_TYPE(func) == __pyx_mstate_global->__Pyx_CachedMethodType) { + int result; + PyObject *newFunc = PyObject_GetAttr(func, __pyx_mstate_global->__pyx_n_u_func); + if (unlikely(!newFunc)) { + PyErr_Clear(); // It's only an optimization, so don't throw an error + return 0; + } + result = __Pyx__IsSameCyOrCFunctionNoMethod(newFunc, cfunc); + Py_DECREF(newFunc); + return result; + } + return __Pyx__IsSameCyOrCFunctionNoMethod(func, cfunc); + } + #else + static CYTHON_INLINE int __Pyx__IsSameCyOrCFunction(PyObject *func, void (*cfunc)(void)) { + if (PyMethod_Check(func)) { + func = PyMethod_GET_FUNCTION(func); + } + return __Pyx_CyOrPyCFunction_Check(func) && __Pyx_CyOrPyCFunction_GET_FUNCTION(func) == (PyCFunction) cfunc; + } + #endif + static CYTHON_INLINE void __Pyx__CyFunction_SetClassObj(__pyx_CyFunctionObject* f, PyObject* classobj) { + #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + __Pyx_Py_XDECREF_SET( + __Pyx_CyFunction_GetClassObj(f), + ((classobj) ? __Pyx_NewRef(classobj) : NULL)); + #else + __Pyx_Py_XDECREF_SET( + ((PyCMethodObject *) (f))->mm_class, + (PyTypeObject*)((classobj) ? __Pyx_NewRef(classobj) : NULL)); + #endif + } + static PyObject * + __Pyx_CyFunction_get_doc_locked(__pyx_CyFunctionObject *op) + { + if (unlikely(op->func_doc == NULL)) { + #if CYTHON_COMPILING_IN_LIMITED_API + op->func_doc = PyObject_GetAttrString(op->func, "__doc__"); + if (unlikely(!op->func_doc)) return NULL; + #else + if (((PyCFunctionObject*)op)->m_ml->ml_doc) { + op->func_doc = PyUnicode_FromString(((PyCFunctionObject*)op)->m_ml->ml_doc); + if (unlikely(op->func_doc == NULL)) + return NULL; + } else { + Py_INCREF(Py_None); + return Py_None; + } + #endif + } + Py_INCREF(op->func_doc); + return op->func_doc; + } + static PyObject * + __Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, void *closure) { + PyObject *result; + CYTHON_UNUSED_VAR(closure); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_doc_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static int + __Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value, void *context) + { + CYTHON_UNUSED_VAR(context); + if (value == NULL) { + value = Py_None; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_doc, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; + } + static PyObject * + __Pyx_CyFunction_get_name_locked(__pyx_CyFunctionObject *op) + { + if (unlikely(op->func_name == NULL)) { + #if CYTHON_COMPILING_IN_LIMITED_API + op->func_name = PyObject_GetAttrString(op->func, "__name__"); + #else + op->func_name = PyUnicode_InternFromString(((PyCFunctionObject*)op)->m_ml->ml_name); + #endif + if (unlikely(op->func_name == NULL)) + return NULL; + } + Py_INCREF(op->func_name); + return op->func_name; + } + static PyObject * + __Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op, void *context) + { + PyObject *result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_name_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static int + __Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value, void *context) + { + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__name__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_name, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; + } + static PyObject * + __Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op, void *context) + { + CYTHON_UNUSED_VAR(context); + PyObject *result; + __Pyx_BEGIN_CRITICAL_SECTION(op); + Py_INCREF(op->func_qualname); + result = op->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static int + __Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value, void *context) + { + CYTHON_UNUSED_VAR(context); + if (unlikely(value == NULL || !PyUnicode_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__qualname__ must be set to a string object"); + return -1; + } + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_qualname, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; + } + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + static PyObject * + __Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op, void *context) + { + CYTHON_UNUSED_VAR(context); + if (unlikely(op->func_dict == NULL)) { + op->func_dict = PyDict_New(); + if (unlikely(op->func_dict == NULL)) + return NULL; + } + Py_INCREF(op->func_dict); + return op->func_dict; + } + #endif + static PyObject * + __Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op, void *context) + { + CYTHON_UNUSED_VAR(context); + Py_INCREF(op->func_globals); + return op->func_globals; + } + static PyObject * + __Pyx_CyFunction_get_closure(__pyx_CyFunctionObject *op, void *context) + { + CYTHON_UNUSED_VAR(op); + CYTHON_UNUSED_VAR(context); + Py_INCREF(Py_None); + return Py_None; + } + static PyObject * + __Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op, void *context) + { + PyObject* result = (op->func_code) ? op->func_code : Py_None; + CYTHON_UNUSED_VAR(context); + Py_INCREF(result); + return result; + } + static int + __Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) { + int result = 0; + PyObject *res = op->defaults_getter((PyObject *) op); + if (unlikely(!res)) + return -1; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + op->defaults_tuple = PyTuple_GET_ITEM(res, 0); + Py_INCREF(op->defaults_tuple); + op->defaults_kwdict = PyTuple_GET_ITEM(res, 1); + Py_INCREF(op->defaults_kwdict); + #else + op->defaults_tuple = __Pyx_PySequence_ITEM(res, 0); + if (unlikely(!op->defaults_tuple)) result = -1; + else { + op->defaults_kwdict = __Pyx_PySequence_ITEM(res, 1); + if (unlikely(!op->defaults_kwdict)) result = -1; + } + #endif + Py_DECREF(res); + return result; + } + static int + __Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyTuple_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__defaults__ must be set to a tuple object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__defaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_tuple, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; + } + static PyObject * + __Pyx_CyFunction_get_defaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_tuple; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_tuple; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; + } + static PyObject * + __Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result = NULL; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_defaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static int + __Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value) { + value = Py_None; + } else if (unlikely(value != Py_None && !PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__kwdefaults__ must be set to a dict object"); + return -1; + } + PyErr_WarnEx(PyExc_RuntimeWarning, "changes to cyfunction.__kwdefaults__ will not " + "currently affect the values used in function calls", 1); + Py_INCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->defaults_kwdict, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; + } + static PyObject * + __Pyx_CyFunction_get_kwdefaults_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->defaults_kwdict; + if (unlikely(!result)) { + if (op->defaults_getter) { + if (unlikely(__Pyx_CyFunction_init_defaults(op) < 0)) return NULL; + result = op->defaults_kwdict; + } else { + result = Py_None; + } + } + Py_INCREF(result); + return result; + } + static PyObject * + __Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op, void *context) { + PyObject* result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_kwdefaults_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static int + __Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + if (!value || value == Py_None) { + value = NULL; + } else if (unlikely(!PyDict_Check(value))) { + PyErr_SetString(PyExc_TypeError, + "__annotations__ must be set to a dict object"); + return -1; + } + Py_XINCREF(value); + __Pyx_BEGIN_CRITICAL_SECTION(op); + __Pyx_Py_XDECREF_SET(op->func_annotations, value); + __Pyx_END_CRITICAL_SECTION(); + return 0; + } + static PyObject * + __Pyx_CyFunction_get_annotations_locked(__pyx_CyFunctionObject *op) { + PyObject* result = op->func_annotations; + if (unlikely(!result)) { + result = PyDict_New(); + if (unlikely(!result)) return NULL; + op->func_annotations = result; + } + Py_INCREF(result); + return result; + } + static PyObject * + __Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + __Pyx_BEGIN_CRITICAL_SECTION(op); + result = __Pyx_CyFunction_get_annotations_locked(op); + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static PyObject * + __Pyx_CyFunction_get_is_coroutine_value(__pyx_CyFunctionObject *op) { + int is_coroutine = op->flags & __Pyx_CYFUNCTION_COROUTINE; + if (is_coroutine) { + PyObject *is_coroutine_value, *module, *fromlist, *marker = __pyx_mstate_global->__pyx_n_u_is_coroutine; + fromlist = PyList_New(1); + if (unlikely(!fromlist)) return NULL; + Py_INCREF(marker); + #if CYTHON_ASSUME_SAFE_MACROS + PyList_SET_ITEM(fromlist, 0, marker); + #else + if (unlikely(PyList_SetItem(fromlist, 0, marker) < 0)) { + Py_DECREF(marker); + Py_DECREF(fromlist); + return NULL; + } + #endif + module = PyImport_ImportModuleLevelObject(__pyx_mstate_global->__pyx_n_u_asyncio_coroutines, NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + if (unlikely(!module)) goto ignore; + is_coroutine_value = __Pyx_PyObject_GetAttrStr(module, marker); + Py_DECREF(module); + if (likely(is_coroutine_value)) { + return is_coroutine_value; + } + ignore: + PyErr_Clear(); + } + return __Pyx_PyBool_FromLong(is_coroutine); + } + static PyObject * + __Pyx_CyFunction_get_is_coroutine(__pyx_CyFunctionObject *op, void *context) { + PyObject *result; + CYTHON_UNUSED_VAR(context); + if (op->func_is_coroutine) { + return __Pyx_NewRef(op->func_is_coroutine); + } + result = __Pyx_CyFunction_get_is_coroutine_value(op); + if (unlikely(!result)) + return NULL; + __Pyx_BEGIN_CRITICAL_SECTION(op); + if (op->func_is_coroutine) { + Py_DECREF(result); + result = __Pyx_NewRef(op->func_is_coroutine); + } else { + op->func_is_coroutine = __Pyx_NewRef(result); + } + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static void __Pyx_CyFunction_raise_argument_count_error(__pyx_CyFunctionObject *func, const char* message, Py_ssize_t size) { + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + py_name, message, size); + Py_DECREF(py_name); + #else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s (%" CYTHON_FORMAT_SSIZE_T "d given)", + name, message, size); + #endif + } + static void __Pyx_CyFunction_raise_type_error(__pyx_CyFunctionObject *func, const char* message) { + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *py_name = __Pyx_CyFunction_get_name(func, NULL); + if (!py_name) return; + PyErr_Format(PyExc_TypeError, + "%.200S() %s", + py_name, message); + Py_DECREF(py_name); + #else + const char* name = ((PyCFunctionObject*)func)->m_ml->ml_name; + PyErr_Format(PyExc_TypeError, + "%.200s() %s", + name, message); + #endif + } + #if CYTHON_COMPILING_IN_LIMITED_API + static PyObject * + __Pyx_CyFunction_get_module(__pyx_CyFunctionObject *op, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_GetAttrString(op->func, "__module__"); + } + static int + __Pyx_CyFunction_set_module(__pyx_CyFunctionObject *op, PyObject* value, void *context) { + CYTHON_UNUSED_VAR(context); + return PyObject_SetAttrString(op->func, "__module__", value); + } + #endif + static PyGetSetDef __pyx_CyFunction_getsets[] = { + {"func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"__doc__", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0}, + {"func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0}, + {"__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0}, + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + {"func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, + {"__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)PyObject_GenericSetDict, 0, 0}, + #else + {"func_dict", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, + {"__dict__", (getter)PyObject_GenericGetDict, (setter)PyObject_GenericSetDict, 0, 0}, + #endif + {"func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0}, + {"func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0}, + {"func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0}, + {"func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0}, + {"__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0}, + {"__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0}, + {"_is_coroutine", (getter)__Pyx_CyFunction_get_is_coroutine, 0, 0, 0}, + #if CYTHON_COMPILING_IN_LIMITED_API + {"__module__", (getter)__Pyx_CyFunction_get_module, (setter)__Pyx_CyFunction_set_module, 0, 0}, + #endif + {0, 0, 0, 0, 0} + }; + static PyMemberDef __pyx_CyFunction_members[] = { + #if !CYTHON_COMPILING_IN_LIMITED_API + {"__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), 0, 0}, + #endif + #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + {"__dictoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_dict), READONLY, 0}, + #endif + #if CYTHON_METH_FASTCALL + #if CYTHON_COMPILING_IN_LIMITED_API + {"__vectorcalloffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_vectorcall), READONLY, 0}, + #else + {"__vectorcalloffset__", T_PYSSIZET, offsetof(PyCFunctionObject, vectorcall), READONLY, 0}, + #endif + #if CYTHON_COMPILING_IN_LIMITED_API + {"__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CyFunctionObject, func_weakreflist), READONLY, 0}, + #else + {"__weaklistoffset__", T_PYSSIZET, offsetof(PyCFunctionObject, m_weakreflist), READONLY, 0}, + #endif + #endif + {0, 0, 0, 0, 0} + }; + static PyObject * + __Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, PyObject *args) + { + PyObject *result = NULL; + CYTHON_UNUSED_VAR(args); + __Pyx_BEGIN_CRITICAL_SECTION(m); + Py_INCREF(m->func_qualname); + result = m->func_qualname; + __Pyx_END_CRITICAL_SECTION(); + return result; + } + static PyMethodDef __pyx_CyFunction_methods[] = { + {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0}, + {0, 0, 0, 0} + }; + #if CYTHON_COMPILING_IN_LIMITED_API + #define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist) + #else + #define __Pyx_CyFunction_weakreflist(cyfunc) (((PyCFunctionObject*)cyfunc)->m_weakreflist) + #endif + static PyObject *__Pyx_CyFunction_Init(__pyx_CyFunctionObject *op, PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + #if !CYTHON_COMPILING_IN_LIMITED_API + PyCFunctionObject *cf = (PyCFunctionObject*) op; + #endif + if (unlikely(op == NULL)) + return NULL; + #if CYTHON_COMPILING_IN_LIMITED_API + op->func = PyCFunction_NewEx(ml, (PyObject*)op, module); + if (unlikely(!op->func)) return NULL; + #endif + op->flags = flags; + __Pyx_CyFunction_weakreflist(op) = NULL; + #if !CYTHON_COMPILING_IN_LIMITED_API + cf->m_ml = ml; + cf->m_self = (PyObject *) op; + #endif + Py_XINCREF(closure); + op->func_closure = closure; + #if !CYTHON_COMPILING_IN_LIMITED_API + Py_XINCREF(module); + cf->m_module = module; + #endif + #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + op->func_dict = NULL; + #endif + op->func_name = NULL; + Py_INCREF(qualname); + op->func_qualname = qualname; + op->func_doc = NULL; + #if PY_VERSION_HEX < 0x030900B1 || CYTHON_COMPILING_IN_LIMITED_API + op->func_classobj = NULL; + #else + ((PyCMethodObject*)op)->mm_class = NULL; + #endif + op->func_globals = globals; + Py_INCREF(op->func_globals); + Py_XINCREF(code); + op->func_code = code; + op->defaults = NULL; + op->defaults_tuple = NULL; + op->defaults_kwdict = NULL; + op->defaults_getter = NULL; + op->func_annotations = NULL; + op->func_is_coroutine = NULL; + #if CYTHON_METH_FASTCALL + switch (ml->ml_flags & (METH_VARARGS | METH_FASTCALL | METH_NOARGS | METH_O | METH_KEYWORDS | METH_METHOD)) { + case METH_NOARGS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_NOARGS; + break; + case METH_O: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_O; + break; + case METH_METHOD | METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD; + break; + case METH_FASTCALL | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS; + break; + case METH_VARARGS | METH_KEYWORDS: + __Pyx_CyFunction_func_vectorcall(op) = NULL; + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + Py_DECREF(op); + return NULL; + } + #endif + return (PyObject *) op; + } + static int + __Pyx_CyFunction_clear(__pyx_CyFunctionObject *m) + { + Py_CLEAR(m->func_closure); + #if CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func); + #else + Py_CLEAR(((PyCFunctionObject*)m)->m_module); + #endif + #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + Py_CLEAR(m->func_dict); + #elif PY_VERSION_HEX < 0x030d0000 + _PyObject_ClearManagedDict((PyObject*)m); + #else + PyObject_ClearManagedDict((PyObject*)m); + #endif + Py_CLEAR(m->func_name); + Py_CLEAR(m->func_qualname); + Py_CLEAR(m->func_doc); + Py_CLEAR(m->func_globals); + Py_CLEAR(m->func_code); + #if !CYTHON_COMPILING_IN_LIMITED_API + #if PY_VERSION_HEX < 0x030900B1 + Py_CLEAR(__Pyx_CyFunction_GetClassObj(m)); + #else + { + PyObject *cls = (PyObject*) ((PyCMethodObject *) (m))->mm_class; + ((PyCMethodObject *) (m))->mm_class = NULL; + Py_XDECREF(cls); + } + #endif + #endif + Py_CLEAR(m->defaults_tuple); + Py_CLEAR(m->defaults_kwdict); + Py_CLEAR(m->func_annotations); + Py_CLEAR(m->func_is_coroutine); + Py_CLEAR(m->defaults); + return 0; + } + static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m) + { + if (__Pyx_CyFunction_weakreflist(m) != NULL) + PyObject_ClearWeakRefs((PyObject *) m); + __Pyx_CyFunction_clear(m); + __Pyx_PyHeapTypeObject_GC_Del(m); + } + static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m) + { + PyObject_GC_UnTrack(m); + __Pyx__CyFunction_dealloc(m); + } + static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg) + { + { + int e = __Pyx_call_type_traverse((PyObject*)m, 1, visit, arg); + if (e) return e; + } + Py_VISIT(m->func_closure); + #if CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func); + #else + Py_VISIT(((PyCFunctionObject*)m)->m_module); + #endif + #if PY_VERSION_HEX < 0x030C0000 || CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(m->func_dict); + #else + { + int e = + #if PY_VERSION_HEX < 0x030d0000 + _PyObject_VisitManagedDict + #else + PyObject_VisitManagedDict + #endif + ((PyObject*)m, visit, arg); + if (e != 0) return e; + } + #endif + __Pyx_VISIT_CONST(m->func_name); + __Pyx_VISIT_CONST(m->func_qualname); + Py_VISIT(m->func_doc); + Py_VISIT(m->func_globals); + __Pyx_VISIT_CONST(m->func_code); + #if !CYTHON_COMPILING_IN_LIMITED_API + Py_VISIT(__Pyx_CyFunction_GetClassObj(m)); + #endif + Py_VISIT(m->defaults_tuple); + Py_VISIT(m->defaults_kwdict); + Py_VISIT(m->func_is_coroutine); + Py_VISIT(m->defaults); + return 0; + } + static PyObject* + __Pyx_CyFunction_repr(__pyx_CyFunctionObject *op) + { + PyObject *repr; + __Pyx_BEGIN_CRITICAL_SECTION(op); + repr = PyUnicode_FromFormat("", + op->func_qualname, (void *)op); + __Pyx_END_CRITICAL_SECTION(); + return repr; + } + static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) { + #if CYTHON_COMPILING_IN_LIMITED_API + PyObject *f = ((__pyx_CyFunctionObject*)func)->func; + PyCFunction meth; + int flags; + meth = PyCFunction_GetFunction(f); + if (unlikely(!meth)) return NULL; + flags = PyCFunction_GetFlags(f); + if (unlikely(flags < 0)) return NULL; + #else + PyCFunctionObject* f = (PyCFunctionObject*)func; + PyCFunction meth = f->m_ml->ml_meth; + int flags = f->m_ml->ml_flags; + #endif + Py_ssize_t size; + switch (flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) { + case METH_VARARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) + return (*meth)(self, arg); + break; + case METH_VARARGS | METH_KEYWORDS: + return (*(PyCFunctionWithKeywords)(void(*)(void))meth)(self, arg, kw); + case METH_NOARGS: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + #if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); + #else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; + #endif + if (likely(size == 0)) + return (*meth)(self, NULL); + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes no arguments", size); + return NULL; + } + break; + case METH_O: + if (likely(kw == NULL || PyDict_Size(kw) == 0)) { + #if CYTHON_ASSUME_SAFE_SIZE + size = PyTuple_GET_SIZE(arg); + #else + size = PyTuple_Size(arg); + if (unlikely(size < 0)) return NULL; + #endif + if (likely(size == 1)) { + PyObject *result, *arg0; + #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS + arg0 = PyTuple_GET_ITEM(arg, 0); + #else + arg0 = __Pyx_PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL; + #endif + result = (*meth)(self, arg0); + #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS) + Py_DECREF(arg0); + #endif + return result; + } + __Pyx_CyFunction_raise_argument_count_error( + (__pyx_CyFunctionObject*)func, + "takes exactly one argument", size); + return NULL; + } + break; + default: + PyErr_SetString(PyExc_SystemError, "Bad call flags for CyFunction"); + return NULL; + } + __Pyx_CyFunction_raise_type_error( + (__pyx_CyFunctionObject*)func, "takes no keyword arguments"); + return NULL; + } + static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) { + PyObject *self, *result; + #if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)func)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; + #else + self = ((PyCFunctionObject*)func)->m_self; + #endif + result = __Pyx_CyFunction_CallMethod(func, self, arg, kw); + return result; + } + static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) { + PyObject *result; + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func; + #if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL + __pyx_vectorcallfunc vc = __Pyx_CyFunction_func_vectorcall(cyfunc); + if (vc) { + #if CYTHON_ASSUME_SAFE_MACROS && CYTHON_ASSUME_SAFE_SIZE + return __Pyx_PyVectorcall_FastCallDict(func, vc, &PyTuple_GET_ITEM(args, 0), (size_t)PyTuple_GET_SIZE(args), kw); + #else + (void) &__Pyx_PyVectorcall_FastCallDict; + return PyVectorcall_Call(func, args, kw); + #endif + } + #endif + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + Py_ssize_t argc; + PyObject *new_args; + PyObject *self; + #if CYTHON_ASSUME_SAFE_SIZE + argc = PyTuple_GET_SIZE(args); + #else + argc = PyTuple_Size(args); + if (unlikely(argc < 0)) return NULL; + #endif + new_args = PyTuple_GetSlice(args, 1, argc); + if (unlikely(!new_args)) + return NULL; + self = PyTuple_GetItem(args, 0); + if (unlikely(!self)) { + Py_DECREF(new_args); + PyErr_Format(PyExc_TypeError, + "unbound method %.200S() needs an argument", + cyfunc->func_qualname); + return NULL; + } + result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw); + Py_DECREF(new_args); + } else { + result = __Pyx_CyFunction_Call(func, args, kw); + } + return result; + } + #if CYTHON_METH_FASTCALL && CYTHON_VECTORCALL + static CYTHON_INLINE int __Pyx_CyFunction_Vectorcall_CheckArgs(__pyx_CyFunctionObject *cyfunc, Py_ssize_t nargs, PyObject *kwnames) + { + int ret = 0; + if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) { + if (unlikely(nargs < 1)) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "needs an argument"); + return -1; + } + ret = 1; + } + if (unlikely(kwnames) && unlikely(__Pyx_PyTuple_GET_SIZE(kwnames))) { + __Pyx_CyFunction_raise_type_error( + cyfunc, "takes no keyword arguments"); + return -1; + } + return ret; + } + static PyObject * __Pyx_CyFunction_Vectorcall_NOARGS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) + { + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; + #if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; + #else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; + #endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + #if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; + #else + self = ((PyCFunctionObject*)cyfunc)->m_self; + #endif + break; + default: + return NULL; + } + if (unlikely(nargs != 0)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes no arguments", nargs); + return NULL; + } + return meth(self, NULL); + } + static PyObject * __Pyx_CyFunction_Vectorcall_O(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) + { + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; + #if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; + #else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; + #endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, kwnames)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + #if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; + #else + self = ((PyCFunctionObject*)cyfunc)->m_self; + #endif + break; + default: + return NULL; + } + if (unlikely(nargs != 1)) { + __Pyx_CyFunction_raise_argument_count_error( + cyfunc, "takes exactly one argument", nargs); + return NULL; + } + return meth(self, args[0]); + } + static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) + { + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; + #if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; + #else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; + #endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + #if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; + #else + self = ((PyCFunctionObject*)cyfunc)->m_self; + #endif + break; + default: + return NULL; + } + return ((__Pyx_PyCFunctionFastWithKeywords)(void(*)(void))meth)(self, args, nargs, kwnames); + } + static PyObject * __Pyx_CyFunction_Vectorcall_FASTCALL_KEYWORDS_METHOD(PyObject *func, PyObject *const *args, size_t nargsf, PyObject *kwnames) + { + __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *)func; + PyTypeObject *cls = (PyTypeObject *) __Pyx_CyFunction_GetClassObj(cyfunc); + Py_ssize_t nargs = PyVectorcall_NARGS(nargsf); + PyObject *self; + #if CYTHON_COMPILING_IN_LIMITED_API + PyCFunction meth = PyCFunction_GetFunction(cyfunc->func); + if (unlikely(!meth)) return NULL; + #else + PyCFunction meth = ((PyCFunctionObject*)cyfunc)->m_ml->ml_meth; + #endif + switch (__Pyx_CyFunction_Vectorcall_CheckArgs(cyfunc, nargs, NULL)) { + case 1: + self = args[0]; + args += 1; + nargs -= 1; + break; + case 0: + #if CYTHON_COMPILING_IN_LIMITED_API + self = PyCFunction_GetSelf(((__pyx_CyFunctionObject*)cyfunc)->func); + if (unlikely(!self) && PyErr_Occurred()) return NULL; + #else + self = ((PyCFunctionObject*)cyfunc)->m_self; + #endif + break; + default: + return NULL; + } + #if PY_VERSION_HEX < 0x030e00A6 + size_t nargs_value = (size_t) nargs; + #else + Py_ssize_t nargs_value = nargs; + #endif + return ((__Pyx_PyCMethod)(void(*)(void))meth)(self, cls, args, nargs_value, kwnames); + } + #endif + static PyType_Slot __pyx_CyFunctionType_slots[] = { + {Py_tp_dealloc, (void *)__Pyx_CyFunction_dealloc}, + {Py_tp_repr, (void *)__Pyx_CyFunction_repr}, + {Py_tp_call, (void *)__Pyx_CyFunction_CallAsMethod}, + {Py_tp_traverse, (void *)__Pyx_CyFunction_traverse}, + {Py_tp_clear, (void *)__Pyx_CyFunction_clear}, + {Py_tp_methods, (void *)__pyx_CyFunction_methods}, + {Py_tp_members, (void *)__pyx_CyFunction_members}, + {Py_tp_getset, (void *)__pyx_CyFunction_getsets}, + {Py_tp_descr_get, (void *)__Pyx_PyMethod_New}, + {0, 0}, + }; + static PyType_Spec __pyx_CyFunctionType_spec = { + __PYX_TYPE_MODULE_PREFIX "cython_function_or_method", + sizeof(__pyx_CyFunctionObject), + 0, + #ifdef Py_TPFLAGS_METHOD_DESCRIPTOR + Py_TPFLAGS_METHOD_DESCRIPTOR | + #endif + #if CYTHON_METH_FASTCALL + #if defined(Py_TPFLAGS_HAVE_VECTORCALL) + Py_TPFLAGS_HAVE_VECTORCALL | + #elif defined(_Py_TPFLAGS_HAVE_VECTORCALL) + _Py_TPFLAGS_HAVE_VECTORCALL | + #endif + #endif // CYTHON_METH_FASTCALL + #if PY_VERSION_HEX >= 0x030C0000 && !CYTHON_COMPILING_IN_LIMITED_API + Py_TPFLAGS_MANAGED_DICT | + #endif + Py_TPFLAGS_IMMUTABLETYPE | Py_TPFLAGS_DISALLOW_INSTANTIATION | + Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, + __pyx_CyFunctionType_slots + }; + static int __pyx_CyFunction_init(PyObject *module) { + __pyx_mstatetype *mstate = __Pyx_PyModule_GetState(module); + mstate->__pyx_CyFunctionType = __Pyx_FetchCommonTypeFromSpec( + mstate->__pyx_CommonTypesMetaclassType, module, &__pyx_CyFunctionType_spec, NULL); + if (unlikely(mstate->__pyx_CyFunctionType == NULL)) { + return -1; + } + return 0; + } + static CYTHON_INLINE PyObject *__Pyx_CyFunction_InitDefaults(PyObject *func, PyTypeObject *defaults_type) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults = PyObject_CallObject((PyObject*)defaults_type, NULL); // _PyObject_New(defaults_type); + if (unlikely(!m->defaults)) + return NULL; + return m->defaults; + } + static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_tuple = tuple; + Py_INCREF(tuple); + } + static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->defaults_kwdict = dict; + Py_INCREF(dict); + } + static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) { + __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func; + m->func_annotations = dict; + Py_INCREF(dict); + } + +/* CythonFunction */ + static PyObject *__Pyx_CyFunction_New(PyMethodDef *ml, int flags, PyObject* qualname, + PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) { + PyObject *op = __Pyx_CyFunction_Init( + PyObject_GC_New(__pyx_CyFunctionObject, __pyx_mstate_global->__pyx_CyFunctionType), + ml, flags, qualname, closure, module, globals, code + ); + if (likely(op)) { + PyObject_GC_Track(op); + } + return op; + } + +/* CLineInTraceback */ + #if CYTHON_CLINE_IN_TRACEBACK && CYTHON_CLINE_IN_TRACEBACK_RUNTIME + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + #define __Pyx_PyProbablyModule_GetDict(o) __Pyx_XNewRef(PyModule_GetDict(o)) + #elif !CYTHON_COMPILING_IN_CPYTHON || CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + #define __Pyx_PyProbablyModule_GetDict(o) PyObject_GenericGetDict(o, NULL); + #else + PyObject* __Pyx_PyProbablyModule_GetDict(PyObject *o) { + PyObject **dict_ptr = _PyObject_GetDictPtr(o); + return dict_ptr ? __Pyx_XNewRef(*dict_ptr) : NULL; + } + #endif + static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) { + PyObject *use_cline = NULL; + PyObject *ptype, *pvalue, *ptraceback; + PyObject *cython_runtime_dict; + CYTHON_MAYBE_UNUSED_VAR(tstate); + if (unlikely(!__pyx_mstate_global->__pyx_cython_runtime)) { + return c_line; + } + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + cython_runtime_dict = __Pyx_PyProbablyModule_GetDict(__pyx_mstate_global->__pyx_cython_runtime); + if (likely(cython_runtime_dict)) { + __PYX_PY_DICT_LOOKUP_IF_MODIFIED( + use_cline, cython_runtime_dict, + __Pyx_PyDict_SetDefault(cython_runtime_dict, __pyx_mstate_global->__pyx_n_u_cline_in_traceback, Py_False)) + } + if (use_cline == NULL || use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) { + c_line = 0; + } + Py_XDECREF(use_cline); + Py_XDECREF(cython_runtime_dict); + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + return c_line; + } + #endif + +/* CodeObjectCache */ + static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line) { + int start = 0, mid = 0, end = count - 1; + if (end >= 0 && code_line > entries[end].code_line) { + return count; + } + while (start < end) { + mid = start + (end - start) / 2; + if (code_line < entries[mid].code_line) { + end = mid; + } else if (code_line > entries[mid].code_line) { + start = mid + 1; + } else { + return mid; + } + } + if (code_line <= entries[mid].code_line) { + return mid; + } else { + return mid + 1; + } + } + static __Pyx_CachedCodeObjectType *__pyx__find_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line) { + __Pyx_CachedCodeObjectType* code_object; + int pos; + if (unlikely(!code_line) || unlikely(!code_cache->entries)) { + return NULL; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if (unlikely(pos >= code_cache->count) || unlikely(code_cache->entries[pos].code_line != code_line)) { + return NULL; + } + code_object = code_cache->entries[pos].code_object; + Py_INCREF(code_object); + return code_object; + } + static __Pyx_CachedCodeObjectType *__pyx_find_code_object(int code_line) { + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__find_code_object; + return NULL; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just miss. + #else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type old_count = __pyx_atomic_incr_acq_rel(&code_cache->accessor_count); + if (old_count < 0) { + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + return NULL; + } + #endif + __Pyx_CachedCodeObjectType *result = __pyx__find_code_object(code_cache, code_line); + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_decr_acq_rel(&code_cache->accessor_count); + #endif + return result; + #endif + } + static void __pyx__insert_code_object(struct __Pyx_CodeObjectCache *code_cache, int code_line, __Pyx_CachedCodeObjectType* code_object) + { + int pos, i; + __Pyx_CodeObjectCacheEntry* entries = code_cache->entries; + if (unlikely(!code_line)) { + return; + } + if (unlikely(!entries)) { + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Malloc(64*sizeof(__Pyx_CodeObjectCacheEntry)); + if (likely(entries)) { + code_cache->entries = entries; + code_cache->max_count = 64; + code_cache->count = 1; + entries[0].code_line = code_line; + entries[0].code_object = code_object; + Py_INCREF(code_object); + } + return; + } + pos = __pyx_bisect_code_objects(code_cache->entries, code_cache->count, code_line); + if ((pos < code_cache->count) && unlikely(code_cache->entries[pos].code_line == code_line)) { + __Pyx_CachedCodeObjectType* tmp = entries[pos].code_object; + entries[pos].code_object = code_object; + Py_INCREF(code_object); + Py_DECREF(tmp); + return; + } + if (code_cache->count == code_cache->max_count) { + int new_max = code_cache->max_count + 64; + entries = (__Pyx_CodeObjectCacheEntry*)PyMem_Realloc( + code_cache->entries, ((size_t)new_max) * sizeof(__Pyx_CodeObjectCacheEntry)); + if (unlikely(!entries)) { + return; + } + code_cache->entries = entries; + code_cache->max_count = new_max; + } + for (i=code_cache->count; i>pos; i--) { + entries[i] = entries[i-1]; + } + entries[pos].code_line = code_line; + entries[pos].code_object = code_object; + code_cache->count++; + Py_INCREF(code_object); + } + static void __pyx_insert_code_object(int code_line, __Pyx_CachedCodeObjectType* code_object) { + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING && !CYTHON_ATOMICS + (void)__pyx__insert_code_object; + return; // Most implementation should have atomics. But otherwise, don't make it thread-safe, just fail. + #else + struct __Pyx_CodeObjectCache *code_cache = &__pyx_mstate_global->__pyx_code_cache; + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_nonatomic_int_type expected = 0; + if (!__pyx_atomic_int_cmp_exchange(&code_cache->accessor_count, &expected, INT_MIN)) { + return; + } + #endif + __pyx__insert_code_object(code_cache, code_line, code_object); + #if CYTHON_COMPILING_IN_CPYTHON_FREETHREADING + __pyx_atomic_sub(&code_cache->accessor_count, INT_MIN); + #endif + #endif + } + +/* AddTraceback */ + #include "compile.h" + #include "frameobject.h" + #include "traceback.h" + #if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API && !defined(PYPY_VERSION) + #ifndef Py_BUILD_CORE + #define Py_BUILD_CORE 1 + #endif + #include "internal/pycore_frame.h" + #endif + #if CYTHON_COMPILING_IN_LIMITED_API + static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict, + PyObject *firstlineno, PyObject *name) { + PyObject *replace = NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL; + if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL; + replace = PyObject_GetAttrString(code, "replace"); + if (likely(replace)) { + PyObject *result = PyObject_Call(replace, __pyx_mstate_global->__pyx_empty_tuple, scratch_dict); + Py_DECREF(replace); + return result; + } + PyErr_Clear(); + return NULL; + } + static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL; + PyObject *replace = NULL, *getframe = NULL, *frame = NULL; + PyObject *exc_type, *exc_value, *exc_traceback; + int success = 0; + if (c_line) { + c_line = __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line); + } + PyErr_Fetch(&exc_type, &exc_value, &exc_traceback); + code_object = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!code_object) { + code_object = Py_CompileString("_getframe()", filename, Py_eval_input); + if (unlikely(!code_object)) goto bad; + py_py_line = PyLong_FromLong(py_line); + if (unlikely(!py_py_line)) goto bad; + if (c_line) { + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + } else { + py_funcname = PyUnicode_FromString(funcname); + } + if (unlikely(!py_funcname)) goto bad; + dict = PyDict_New(); + if (unlikely(!dict)) goto bad; + { + PyObject *old_code_object = code_object; + code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname); + Py_DECREF(old_code_object); + } + if (unlikely(!code_object)) goto bad; + __pyx_insert_code_object(c_line ? -c_line : py_line, code_object); + } else { + dict = PyDict_New(); + } + getframe = PySys_GetObject("_getframe"); + if (unlikely(!getframe)) goto bad; + if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad; + frame = PyEval_EvalCode(code_object, dict, dict); + if (unlikely(!frame) || frame == Py_None) goto bad; + success = 1; + bad: + PyErr_Restore(exc_type, exc_value, exc_traceback); + Py_XDECREF(code_object); + Py_XDECREF(py_py_line); + Py_XDECREF(py_funcname); + Py_XDECREF(dict); + Py_XDECREF(replace); + if (success) { + PyTraceBack_Here( + (struct _frame*)frame); + } + Py_XDECREF(frame); + } + #else + static PyCodeObject* __Pyx_CreateCodeObjectForTraceback( + const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = NULL; + PyObject *py_funcname = NULL; + if (c_line) { + py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, __pyx_cfilenm, c_line); + if (!py_funcname) goto bad; + funcname = PyUnicode_AsUTF8(py_funcname); + if (!funcname) goto bad; + } + py_code = PyCode_NewEmpty(filename, funcname, py_line); + Py_XDECREF(py_funcname); + return py_code; + bad: + Py_XDECREF(py_funcname); + return NULL; + } + static void __Pyx_AddTraceback(const char *funcname, int c_line, + int py_line, const char *filename) { + PyCodeObject *py_code = 0; + PyFrameObject *py_frame = 0; + PyThreadState *tstate = __Pyx_PyThreadState_Current; + PyObject *ptype, *pvalue, *ptraceback; + if (c_line) { + c_line = __Pyx_CLineForTraceback(tstate, c_line); + } + py_code = __pyx_find_code_object(c_line ? -c_line : py_line); + if (!py_code) { + __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback); + py_code = __Pyx_CreateCodeObjectForTraceback( + funcname, c_line, py_line, filename); + if (!py_code) { + /* If the code object creation fails, then we should clear the + fetched exception references and propagate the new exception */ + Py_XDECREF(ptype); + Py_XDECREF(pvalue); + Py_XDECREF(ptraceback); + goto bad; + } + __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback); + __pyx_insert_code_object(c_line ? -c_line : py_line, py_code); + } + py_frame = PyFrame_New( + tstate, /*PyThreadState *tstate,*/ + py_code, /*PyCodeObject *code,*/ + __pyx_mstate_global->__pyx_d, /*PyObject *globals,*/ + 0 /*PyObject *locals*/ + ); + if (!py_frame) goto bad; + __Pyx_PyFrame_SetLineNumber(py_frame, py_line); + PyTraceBack_Here(py_frame); + bad: + Py_XDECREF(py_code); + Py_XDECREF(py_frame); + } + #endif + +/* MemviewRefcount */ + #include + #ifndef _Py_NO_RETURN + #define _Py_NO_RETURN + #endif + _Py_NO_RETURN + static void __pyx_fatalerror(const char *fmt, ...) { + va_list vargs; + char msg[200]; + #if PY_VERSION_HEX >= 0x030A0000 || defined(HAVE_STDARG_PROTOTYPES) + va_start(vargs, fmt); + #else + va_start(vargs); + #endif + vsnprintf(msg, 200, fmt, vargs); + va_end(vargs); + Py_FatalError(msg); + } + static CYTHON_INLINE int + __pyx_add_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, + PyThread_type_lock lock) + { + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)++; + PyThread_release_lock(lock); + return result; + } + static CYTHON_INLINE int + __pyx_sub_acquisition_count_locked(__pyx_atomic_int_type *acquisition_count, + PyThread_type_lock lock) + { + int result; + PyThread_acquire_lock(lock, 1); + result = (*acquisition_count)--; + PyThread_release_lock(lock); + return result; + } + static CYTHON_INLINE void + __Pyx_INC_MEMVIEW(__Pyx_memviewslice *memslice, int have_gil, int lineno) + { + __pyx_nonatomic_int_type old_acquisition_count; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + return; + } + old_acquisition_count = __pyx_add_acquisition_count(memview); + if (unlikely(old_acquisition_count <= 0)) { + if (likely(old_acquisition_count == 0)) { + if (have_gil) { + Py_INCREF((PyObject *) memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_INCREF((PyObject *) memview); + PyGILState_Release(_gilstate); + } + } else { + __pyx_fatalerror("Acquisition count is %d (line %d)", + old_acquisition_count+1, lineno); + } + } + } + static CYTHON_INLINE void __Pyx_XCLEAR_MEMVIEW(__Pyx_memviewslice *memslice, + int have_gil, int lineno) { + __pyx_nonatomic_int_type old_acquisition_count; + struct __pyx_memoryview_obj *memview = memslice->memview; + if (unlikely(!memview || (PyObject *) memview == Py_None)) { + memslice->memview = NULL; + return; + } + old_acquisition_count = __pyx_sub_acquisition_count(memview); + memslice->data = NULL; + if (likely(old_acquisition_count > 1)) { + memslice->memview = NULL; + } else if (likely(old_acquisition_count == 1)) { + if (have_gil) { + Py_CLEAR(memslice->memview); + } else { + PyGILState_STATE _gilstate = PyGILState_Ensure(); + Py_CLEAR(memslice->memview); + PyGILState_Release(_gilstate); + } + } else { + __pyx_fatalerror("Acquisition count is %d (line %d)", + old_acquisition_count-1, lineno); + } + } + +/* MemviewSliceIsContig */ + static int + __pyx_memviewslice_is_contig(const __Pyx_memviewslice mvs, char order, int ndim) + { + int i, index, step, start; + Py_ssize_t itemsize = mvs.memview->view.itemsize; + if (order == 'F') { + step = 1; + start = 0; + } else { + step = -1; + start = ndim - 1; + } + for (i = 0; i < ndim; i++) { + index = start + step * i; + if (mvs.suboffsets[index] >= 0 || mvs.strides[index] != itemsize) + return 0; + itemsize *= mvs.shape[index]; + } + return 1; + } + +/* OverlappingSlices */ + static void + __pyx_get_array_memory_extents(__Pyx_memviewslice *slice, + void **out_start, void **out_end, + int ndim, size_t itemsize) + { + char *start, *end; + int i; + start = end = slice->data; + for (i = 0; i < ndim; i++) { + Py_ssize_t stride = slice->strides[i]; + Py_ssize_t extent = slice->shape[i]; + if (extent == 0) { + *out_start = *out_end = start; + return; + } else { + if (stride > 0) + end += stride * (extent - 1); + else + start += stride * (extent - 1); + } + } + *out_start = start; + *out_end = end + itemsize; + } + static int + __pyx_slices_overlap(__Pyx_memviewslice *slice1, + __Pyx_memviewslice *slice2, + int ndim, size_t itemsize) + { + void *start1, *end1, *start2, *end2; + __pyx_get_array_memory_extents(slice1, &start1, &end1, ndim, itemsize); + __pyx_get_array_memory_extents(slice2, &start2, &end2, ndim, itemsize); + return (start1 < end2) && (start2 < end1); + } + +/* MemviewSliceInit */ + static int + __Pyx_init_memviewslice(struct __pyx_memoryview_obj *memview, + int ndim, + __Pyx_memviewslice *memviewslice, + int memview_is_new_reference) + { + __Pyx_RefNannyDeclarations + int i, retval=-1; + Py_buffer *buf = &memview->view; + __Pyx_RefNannySetupContext("init_memviewslice", 0); + if (unlikely(memviewslice->memview || memviewslice->data)) { + PyErr_SetString(PyExc_ValueError, + "memviewslice is already initialized!"); + goto fail; + } + if (buf->strides) { + for (i = 0; i < ndim; i++) { + memviewslice->strides[i] = buf->strides[i]; + } + } else { + Py_ssize_t stride = buf->itemsize; + for (i = ndim - 1; i >= 0; i--) { + memviewslice->strides[i] = stride; + stride *= buf->shape[i]; + } + } + for (i = 0; i < ndim; i++) { + memviewslice->shape[i] = buf->shape[i]; + if (buf->suboffsets) { + memviewslice->suboffsets[i] = buf->suboffsets[i]; + } else { + memviewslice->suboffsets[i] = -1; + } + } + memviewslice->memview = memview; + memviewslice->data = (char *)buf->buf; + if (__pyx_add_acquisition_count(memview) == 0 && !memview_is_new_reference) { + Py_INCREF((PyObject*)memview); + } + retval = 0; + goto no_fail; + fail: + memviewslice->memview = 0; + memviewslice->data = 0; + retval = -1; + no_fail: + __Pyx_RefNannyFinishContext(); + return retval; + } + +/* CIntFromPyVerify */ + #define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0) + #define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)\ + __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1) + #define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc)\ + {\ + func_type value = func_value;\ + if (sizeof(target_type) < sizeof(func_type)) {\ + if (unlikely(value != (func_type) (target_type) value)) {\ + func_type zero = 0;\ + if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))\ + return (target_type) -1;\ + if (is_unsigned && unlikely(value < zero))\ + goto raise_neg_overflow;\ + else\ + goto raise_overflow;\ + }\ + }\ + return (target_type) value;\ + } + +/* TypeInfoCompare */ + static int + __pyx_typeinfo_cmp(const __Pyx_TypeInfo *a, const __Pyx_TypeInfo *b) + { + int i; + if (!a || !b) + return 0; + if (a == b) + return 1; + if (a->size != b->size || a->typegroup != b->typegroup || + a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) { + if (a->typegroup == 'H' || b->typegroup == 'H') { + return a->size == b->size; + } else { + return 0; + } + } + if (a->ndim) { + for (i = 0; i < a->ndim; i++) + if (a->arraysize[i] != b->arraysize[i]) + return 0; + } + if (a->typegroup == 'S') { + if (a->flags != b->flags) + return 0; + if (a->fields || b->fields) { + if (!(a->fields && b->fields)) + return 0; + for (i = 0; a->fields[i].type && b->fields[i].type; i++) { + const __Pyx_StructField *field_a = a->fields + i; + const __Pyx_StructField *field_b = b->fields + i; + if (field_a->offset != field_b->offset || + !__pyx_typeinfo_cmp(field_a->type, field_b->type)) + return 0; + } + return !a->fields[i].type && !b->fields[i].type; + } + } + return 1; + } + +/* MemviewSliceValidateAndInit */ + static int + __pyx_check_strides(Py_buffer *buf, int dim, int ndim, int spec) + { + if (buf->shape[dim] <= 1) + return 1; + if (buf->strides) { + if (spec & __Pyx_MEMVIEW_CONTIG) { + if (spec & (__Pyx_MEMVIEW_PTR|__Pyx_MEMVIEW_FULL)) { + if (unlikely(buf->strides[dim] != sizeof(void *))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly contiguous " + "in dimension %d.", dim); + goto fail; + } + } else if (unlikely(buf->strides[dim] != buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + if (spec & __Pyx_MEMVIEW_FOLLOW) { + Py_ssize_t stride = buf->strides[dim]; + if (stride < 0) + stride = -stride; + if (unlikely(stride < buf->itemsize)) { + PyErr_SetString(PyExc_ValueError, + "Buffer and memoryview are not contiguous " + "in the same dimension."); + goto fail; + } + } + } else { + if (unlikely(spec & __Pyx_MEMVIEW_CONTIG && dim != ndim - 1)) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not contiguous in " + "dimension %d", dim); + goto fail; + } else if (unlikely(spec & (__Pyx_MEMVIEW_PTR))) { + PyErr_Format(PyExc_ValueError, + "C-contiguous buffer is not indirect in " + "dimension %d", dim); + goto fail; + } else if (unlikely(buf->suboffsets)) { + PyErr_SetString(PyExc_ValueError, + "Buffer exposes suboffsets but no strides"); + goto fail; + } + } + return 1; + fail: + return 0; + } + static int + __pyx_check_suboffsets(Py_buffer *buf, int dim, int ndim, int spec) + { + CYTHON_UNUSED_VAR(ndim); + if (spec & __Pyx_MEMVIEW_DIRECT) { + if (unlikely(buf->suboffsets && buf->suboffsets[dim] >= 0)) { + PyErr_Format(PyExc_ValueError, + "Buffer not compatible with direct access " + "in dimension %d.", dim); + goto fail; + } + } + if (spec & __Pyx_MEMVIEW_PTR) { + if (unlikely(!buf->suboffsets || (buf->suboffsets[dim] < 0))) { + PyErr_Format(PyExc_ValueError, + "Buffer is not indirectly accessible " + "in dimension %d.", dim); + goto fail; + } + } + return 1; + fail: + return 0; + } + static int + __pyx_verify_contig(Py_buffer *buf, int ndim, int c_or_f_flag) + { + int i; + if (c_or_f_flag & __Pyx_IS_F_CONTIG) { + Py_ssize_t stride = 1; + for (i = 0; i < ndim; i++) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not fortran contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } else if (c_or_f_flag & __Pyx_IS_C_CONTIG) { + Py_ssize_t stride = 1; + for (i = ndim - 1; i >- 1; i--) { + if (unlikely(stride * buf->itemsize != buf->strides[i] && buf->shape[i] > 1)) { + PyErr_SetString(PyExc_ValueError, + "Buffer not C contiguous."); + goto fail; + } + stride = stride * buf->shape[i]; + } + } + return 1; + fail: + return 0; + } + static int __Pyx_ValidateAndInit_memviewslice( + int *axes_specs, + int c_or_f_flag, + int buf_flags, + int ndim, + const __Pyx_TypeInfo *dtype, + __Pyx_BufFmt_StackElem stack[], + __Pyx_memviewslice *memviewslice, + PyObject *original_obj) + { + struct __pyx_memoryview_obj *memview, *new_memview; + __Pyx_RefNannyDeclarations + Py_buffer *buf; + int i, spec = 0, retval = -1; + __Pyx_BufFmt_Context ctx; + int from_memoryview = __pyx_memoryview_check(original_obj); + __Pyx_RefNannySetupContext("ValidateAndInit_memviewslice", 0); + if (from_memoryview && __pyx_typeinfo_cmp(dtype, ((struct __pyx_memoryview_obj *) + original_obj)->typeinfo)) { + memview = (struct __pyx_memoryview_obj *) original_obj; + new_memview = NULL; + } else { + memview = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + original_obj, buf_flags, 0, dtype); + new_memview = memview; + if (unlikely(!memview)) + goto fail; + } + buf = &memview->view; + if (unlikely(buf->ndim != ndim)) { + PyErr_Format(PyExc_ValueError, + "Buffer has wrong number of dimensions (expected %d, got %d)", + ndim, buf->ndim); + goto fail; + } + if (new_memview) { + __Pyx_BufFmt_Init(&ctx, stack, dtype); + if (unlikely(!__Pyx_BufFmt_CheckString(&ctx, buf->format))) goto fail; + } + if (unlikely((unsigned) buf->itemsize != dtype->size)) { + PyErr_Format(PyExc_ValueError, + "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "u byte%s) " + "does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "u byte%s)", + buf->itemsize, + (buf->itemsize > 1) ? "s" : "", + dtype->name, + dtype->size, + (dtype->size > 1) ? "s" : ""); + goto fail; + } + if (buf->len > 0) { + for (i = 0; i < ndim; i++) { + spec = axes_specs[i]; + if (unlikely(!__pyx_check_strides(buf, i, ndim, spec))) + goto fail; + if (unlikely(!__pyx_check_suboffsets(buf, i, ndim, spec))) + goto fail; + } + if (unlikely(buf->strides && !__pyx_verify_contig(buf, ndim, c_or_f_flag))) + goto fail; + } + if (unlikely(__Pyx_init_memviewslice(memview, ndim, memviewslice, + new_memview != NULL) == -1)) { + goto fail; + } + retval = 0; + goto no_fail; + fail: + Py_XDECREF((PyObject*)new_memview); + retval = -1; + no_fail: + __Pyx_RefNannyFinishContext(); + return retval; + } + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_ds_float(PyObject *obj, int writable_flag) { + __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_BufFmt_StackElem stack[1]; + int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, + PyBUF_RECORDS_RO | writable_flag, 1, + &__Pyx_TypeInfo_float, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; + __pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; + } + +/* Declarations */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return ::std::complex< double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + return x + y*(__pyx_t_double_complex)_Complex_I; + } + #endif + #else + static CYTHON_INLINE __pyx_t_double_complex __pyx_t_double_complex_from_parts(double x, double y) { + __pyx_t_double_complex z; + z.real = x; + z.imag = y; + return z; + } + #endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #else + static CYTHON_INLINE int __Pyx_c_eq_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_sum_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_diff_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_prod_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabs(b.real) >= fabs(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + double r = b.imag / b.real; + double s = (double)(1.0) / (b.real + b.imag * r); + return __pyx_t_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + double r = b.real / b.imag; + double s = (double)(1.0) / (b.imag + b.real * r); + return __pyx_t_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_quot_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + if (b.imag == 0) { + return __pyx_t_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_neg_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_double(__pyx_t_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_conj_double(__pyx_t_double_complex a) { + __pyx_t_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE double __Pyx_c_abs_double(__pyx_t_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrt(z.real*z.real + z.imag*z.imag); + #else + return hypot(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_double_complex __Pyx_c_pow_double(__pyx_t_double_complex a, __pyx_t_double_complex b) { + __pyx_t_double_complex z; + double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_double(a, a); + case 3: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, a); + case 4: + z = __Pyx_c_prod_double(a, a); + return __Pyx_c_prod_double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if ((b.imag == 0) && (a.real >= 0)) { + z.real = pow(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_double(a); + theta = atan2(a.imag, a.real); + } + lnr = log(r); + z_r = exp(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cos(z_theta); + z.imag = z_r * sin(z_theta); + return z; + } + #endif + #endif + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsds_float(PyObject *obj, int writable_flag) { + __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_BufFmt_StackElem stack[1]; + int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, + PyBUF_RECORDS_RO | writable_flag, 2, + &__Pyx_TypeInfo_float, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; + __pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; + } + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsdsds_float(PyObject *obj, int writable_flag) { + __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_BufFmt_StackElem stack[1]; + int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, + PyBUF_RECORDS_RO | writable_flag, 3, + &__Pyx_TypeInfo_float, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; + __pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; + } + +/* ObjectToMemviewSlice */ + static CYTHON_INLINE __Pyx_memviewslice __Pyx_PyObject_to_MemoryviewSlice_dsdsds_int(PyObject *obj, int writable_flag) { + __Pyx_memviewslice result = { 0, 0, { 0 }, { 0 }, { 0 } }; + __Pyx_BufFmt_StackElem stack[1]; + int axes_specs[] = { (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED), (__Pyx_MEMVIEW_DIRECT | __Pyx_MEMVIEW_STRIDED) }; + int retcode; + if (obj == Py_None) { + result.memview = (struct __pyx_memoryview_obj *) Py_None; + return result; + } + retcode = __Pyx_ValidateAndInit_memviewslice(axes_specs, 0, + PyBUF_RECORDS_RO | writable_flag, 3, + &__Pyx_TypeInfo_int, stack, + &result, obj); + if (unlikely(retcode == -1)) + goto __pyx_fail; + return result; + __pyx_fail: + result.memview = NULL; + result.data = NULL; + return result; + } + +/* MemviewDtypeToObject */ + static CYTHON_INLINE PyObject *__pyx_memview_get_float(const char *itemp) { + return (PyObject *) PyFloat_FromDouble(*(float const *) itemp); + } + static CYTHON_INLINE int __pyx_memview_set_float(char *itemp, PyObject *obj) { + float value = __Pyx_PyFloat_AsFloat(obj); + if (unlikely((value == (float)-1) && PyErr_Occurred())) + return 0; + *(float *) itemp = value; + return 1; + } + +/* Declarations */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return ::std::complex< float >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + return x + y*(__pyx_t_float_complex)_Complex_I; + } + #endif + #else + static CYTHON_INLINE __pyx_t_float_complex __pyx_t_float_complex_from_parts(float x, float y) { + __pyx_t_float_complex z; + z.real = x; + z.imag = y; + return z; + } + #endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #else + static CYTHON_INLINE int __Pyx_c_eq_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_sum_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_diff_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_prod_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsf(b.real) >= fabsf(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + float r = b.imag / b.real; + float s = (float)(1.0) / (b.real + b.imag * r); + return __pyx_t_float_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + float r = b.real / b.imag; + float s = (float)(1.0) / (b.imag + b.real * r); + return __pyx_t_float_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_quot_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + if (b.imag == 0) { + return __pyx_t_float_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + float denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_float_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_neg_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_float(__pyx_t_float_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_conj_float(__pyx_t_float_complex a) { + __pyx_t_float_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE float __Pyx_c_abs_float(__pyx_t_float_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtf(z.real*z.real + z.imag*z.imag); + #else + return hypotf(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_float_complex __Pyx_c_pow_float(__pyx_t_float_complex a, __pyx_t_float_complex b) { + __pyx_t_float_complex z; + float r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + float denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_float(a, a); + case 3: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, a); + case 4: + z = __Pyx_c_prod_float(a, a); + return __Pyx_c_prod_float(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if ((b.imag == 0) && (a.real >= 0)) { + z.real = powf(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2f(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_float(a); + theta = atan2f(a.imag, a.real); + } + lnr = logf(r); + z_r = expf(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosf(z_theta); + z.imag = z_r * sinf(z_theta); + return z; + } + #endif + #endif + +/* Declarations */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #ifdef __cplusplus + static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { + return ::std::complex< long double >(x, y); + } + #else + static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { + return x + y*(__pyx_t_long_double_complex)_Complex_I; + } + #endif + #else + static CYTHON_INLINE __pyx_t_long_double_complex __pyx_t_long_double_complex_from_parts(long double x, long double y) { + __pyx_t_long_double_complex z; + z.real = x; + z.imag = y; + return z; + } + #endif + +/* Arithmetic */ + #if CYTHON_CCOMPLEX && (1) && (!0 || __cplusplus) + #else + static CYTHON_INLINE int __Pyx_c_eq_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + return (a.real == b.real) && (a.imag == b.imag); + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_sum_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + z.real = a.real + b.real; + z.imag = a.imag + b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_diff_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + z.real = a.real - b.real; + z.imag = a.imag - b.imag; + return z; + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_prod_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + z.real = a.real * b.real - a.imag * b.imag; + z.imag = a.real * b.imag + a.imag * b.real; + return z; + } + #if 1 + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + if (b.imag == 0) { + return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else if (fabsl(b.real) >= fabsl(b.imag)) { + if (b.real == 0 && b.imag == 0) { + return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.imag); + } else { + long double r = b.imag / b.real; + long double s = (long double)(1.0) / (b.real + b.imag * r); + return __pyx_t_long_double_complex_from_parts( + (a.real + a.imag * r) * s, (a.imag - a.real * r) * s); + } + } else { + long double r = b.real / b.imag; + long double s = (long double)(1.0) / (b.imag + b.real * r); + return __pyx_t_long_double_complex_from_parts( + (a.real * r + a.imag) * s, (a.imag * r - a.real) * s); + } + } + #else + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_quot_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + if (b.imag == 0) { + return __pyx_t_long_double_complex_from_parts(a.real / b.real, a.imag / b.real); + } else { + long double denom = b.real * b.real + b.imag * b.imag; + return __pyx_t_long_double_complex_from_parts( + (a.real * b.real + a.imag * b.imag) / denom, + (a.imag * b.real - a.real * b.imag) / denom); + } + } + #endif + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_neg_long__double(__pyx_t_long_double_complex a) { + __pyx_t_long_double_complex z; + z.real = -a.real; + z.imag = -a.imag; + return z; + } + static CYTHON_INLINE int __Pyx_c_is_zero_long__double(__pyx_t_long_double_complex a) { + return (a.real == 0) && (a.imag == 0); + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_conj_long__double(__pyx_t_long_double_complex a) { + __pyx_t_long_double_complex z; + z.real = a.real; + z.imag = -a.imag; + return z; + } + #if 1 + static CYTHON_INLINE long double __Pyx_c_abs_long__double(__pyx_t_long_double_complex z) { + #if !defined(HAVE_HYPOT) || defined(_MSC_VER) + return sqrtl(z.real*z.real + z.imag*z.imag); + #else + return hypotl(z.real, z.imag); + #endif + } + static CYTHON_INLINE __pyx_t_long_double_complex __Pyx_c_pow_long__double(__pyx_t_long_double_complex a, __pyx_t_long_double_complex b) { + __pyx_t_long_double_complex z; + long double r, lnr, theta, z_r, z_theta; + if (b.imag == 0 && b.real == (int)b.real) { + if (b.real < 0) { + long double denom = a.real * a.real + a.imag * a.imag; + a.real = a.real / denom; + a.imag = -a.imag / denom; + b.real = -b.real; + } + switch ((int)b.real) { + case 0: + z.real = 1; + z.imag = 0; + return z; + case 1: + return a; + case 2: + return __Pyx_c_prod_long__double(a, a); + case 3: + z = __Pyx_c_prod_long__double(a, a); + return __Pyx_c_prod_long__double(z, a); + case 4: + z = __Pyx_c_prod_long__double(a, a); + return __Pyx_c_prod_long__double(z, z); + } + } + if (a.imag == 0) { + if (a.real == 0) { + return a; + } else if ((b.imag == 0) && (a.real >= 0)) { + z.real = powl(a.real, b.real); + z.imag = 0; + return z; + } else if (a.real > 0) { + r = a.real; + theta = 0; + } else { + r = -a.real; + theta = atan2l(0.0, -1.0); + } + } else { + r = __Pyx_c_abs_long__double(a); + theta = atan2l(a.imag, a.real); + } + lnr = logl(r); + z_r = expl(lnr * b.real - theta * b.imag); + z_theta = theta * b.real + lnr * b.imag; + z.real = z_r * cosl(z_theta); + z.imag = z_r * sinl(z_theta); + return z; + } + #endif + #endif + +/* MemviewSliceCopyTemplate */ + static __Pyx_memviewslice + __pyx_memoryview_copy_new_contig(const __Pyx_memviewslice *from_mvs, + const char *mode, int ndim, + size_t sizeof_dtype, int contig_flag, + int dtype_is_object) + { + __Pyx_RefNannyDeclarations + int i; + __Pyx_memviewslice new_mvs = { 0, 0, { 0 }, { 0 }, { 0 } }; + struct __pyx_memoryview_obj *from_memview = from_mvs->memview; + Py_buffer *buf = &from_memview->view; + PyObject *shape_tuple = NULL; + PyObject *temp_int = NULL; + struct __pyx_array_obj *array_obj = NULL; + struct __pyx_memoryview_obj *memview_obj = NULL; + __Pyx_RefNannySetupContext("__pyx_memoryview_copy_new_contig", 0); + for (i = 0; i < ndim; i++) { + if (unlikely(from_mvs->suboffsets[i] >= 0)) { + PyErr_Format(PyExc_ValueError, "Cannot copy memoryview slice with " + "indirect dimensions (axis %d)", i); + goto fail; + } + } + shape_tuple = PyTuple_New(ndim); + if (unlikely(!shape_tuple)) { + goto fail; + } + __Pyx_GOTREF(shape_tuple); + for(i = 0; i < ndim; i++) { + temp_int = PyLong_FromSsize_t(from_mvs->shape[i]); + if(unlikely(!temp_int)) { + goto fail; + } else { + #if CYTHON_ASSUME_SAFE_MACROS + PyTuple_SET_ITEM(shape_tuple, i, temp_int); + #else + if (PyTuple_SetItem(shape_tuple, i, temp_int) < 0) { + goto fail; + } + #endif + temp_int = NULL; + } + } + array_obj = __pyx_array_new(shape_tuple, sizeof_dtype, buf->format, mode, NULL); + if (unlikely(!array_obj)) { + goto fail; + } + __Pyx_GOTREF(array_obj); + memview_obj = (struct __pyx_memoryview_obj *) __pyx_memoryview_new( + (PyObject *) array_obj, contig_flag, + dtype_is_object, + from_mvs->memview->typeinfo); + if (unlikely(!memview_obj)) + goto fail; + if (unlikely(__Pyx_init_memviewslice(memview_obj, ndim, &new_mvs, 1) < 0)) + goto fail; + if (unlikely(__pyx_memoryview_copy_contents(*from_mvs, new_mvs, ndim, ndim, + dtype_is_object) < 0)) + goto fail; + goto no_fail; + fail: + __Pyx_XDECREF((PyObject *) new_mvs.memview); + new_mvs.memview = NULL; + new_mvs.data = NULL; + no_fail: + __Pyx_XDECREF(shape_tuple); + __Pyx_XDECREF(temp_int); + __Pyx_XDECREF((PyObject *) array_obj); + __Pyx_RefNannyFinishContext(); + return new_mvs; + } + +/* CIntFromPy */ + static CYTHON_INLINE int __Pyx_PyLong_As_int(PyObject *x) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const int neg_one = (int) -1, const_zero = (int) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (int) -1; + val = __Pyx_PyLong_As_int(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 2 * PyLong_SHIFT)) { + return (int) (((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 3 * PyLong_SHIFT)) { + return (int) (((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) >= 4 * PyLong_SHIFT)) { + return (int) (((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0])); + } + } + break; + } + } + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } + #else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } + #endif + if ((sizeof(int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + return (int) ((((((int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + return (int) ((((((((int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) (((int)-1)*(((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(int) - 1 > 4 * PyLong_SHIFT)) { + return (int) ((((((((((int)digits[3]) << PyLong_SHIFT) | (int)digits[2]) << PyLong_SHIFT) | (int)digits[1]) << PyLong_SHIFT) | (int)digits[0]))); + } + } + break; + } + } + #endif + if ((sizeof(int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(int, long, PyLong_AsLong(x)) + } else if ((sizeof(int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + int val; + int ret = -1; + #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } + #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + #else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (int) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (int) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (int) -1; + } else { + stepval = v; + } + v = NULL; + val = (int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((int) 1) << (sizeof(int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); + #endif + if (unlikely(ret)) + return (int) -1; + return val; + } + raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to int"); + return (int) -1; + raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to int"); + return (int) -1; + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyLong_From_int(int value) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const int neg_one = (int) -1, const_zero = (int) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + #if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + #endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; + #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } + #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + #else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; + #endif + } + } + +/* CIntFromPy */ + static CYTHON_INLINE unsigned int __Pyx_PyLong_As_unsigned_int(PyObject *x) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const unsigned int neg_one = (unsigned int) -1, const_zero = (unsigned int) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + unsigned int val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (unsigned int) -1; + val = __Pyx_PyLong_As_unsigned_int(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 2 * PyLong_SHIFT)) { + return (unsigned int) (((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 3 * PyLong_SHIFT)) { + return (unsigned int) (((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) >= 4 * PyLong_SHIFT)) { + return (unsigned int) (((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0])); + } + } + break; + } + } + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } + #else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (unsigned int) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } + #endif + if ((sizeof(unsigned int) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(unsigned int) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(unsigned int, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(unsigned int) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(unsigned int) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + return (unsigned int) ((((((unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(unsigned int) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(unsigned int) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + return (unsigned int) ((((((((unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(unsigned int) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) (((unsigned int)-1)*(((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(unsigned int) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(unsigned int, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(unsigned int) - 1 > 4 * PyLong_SHIFT)) { + return (unsigned int) ((((((((((unsigned int)digits[3]) << PyLong_SHIFT) | (unsigned int)digits[2]) << PyLong_SHIFT) | (unsigned int)digits[1]) << PyLong_SHIFT) | (unsigned int)digits[0]))); + } + } + break; + } + } + #endif + if ((sizeof(unsigned int) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, long, PyLong_AsLong(x)) + } else if ((sizeof(unsigned int) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(unsigned int, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + unsigned int val; + int ret = -1; + #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } + #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + #else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (unsigned int) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (unsigned int) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (unsigned int) -1; + } else { + stepval = v; + } + v = NULL; + val = (unsigned int) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(unsigned int) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((unsigned int) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(unsigned int) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((unsigned int) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((unsigned int) 1) << (sizeof(unsigned int) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); + #endif + if (unlikely(ret)) + return (unsigned int) -1; + return val; + } + raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to unsigned int"); + return (unsigned int) -1; + raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to unsigned int"); + return (unsigned int) -1; + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyLong_From_long(long value) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const long neg_one = (long) -1, const_zero = (long) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(long) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + #if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(long) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + #endif + } + } else { + if (sizeof(long) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(long) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; + #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } + #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(long), + little, !is_unsigned); + #else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(long)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; + #endif + } + } + +/* CIntFromPy */ + static CYTHON_INLINE npy_intp __Pyx_PyLong_As_npy_intp(PyObject *x) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const npy_intp neg_one = (npy_intp) -1, const_zero = (npy_intp) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + npy_intp val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (npy_intp) -1; + val = __Pyx_PyLong_As_npy_intp(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(npy_intp, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(npy_intp) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_intp, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_intp) >= 2 * PyLong_SHIFT)) { + return (npy_intp) (((((npy_intp)digits[1]) << PyLong_SHIFT) | (npy_intp)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(npy_intp) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_intp, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_intp) >= 3 * PyLong_SHIFT)) { + return (npy_intp) (((((((npy_intp)digits[2]) << PyLong_SHIFT) | (npy_intp)digits[1]) << PyLong_SHIFT) | (npy_intp)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(npy_intp) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_intp, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_intp) >= 4 * PyLong_SHIFT)) { + return (npy_intp) (((((((((npy_intp)digits[3]) << PyLong_SHIFT) | (npy_intp)digits[2]) << PyLong_SHIFT) | (npy_intp)digits[1]) << PyLong_SHIFT) | (npy_intp)digits[0])); + } + } + break; + } + } + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } + #else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (npy_intp) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } + #endif + if ((sizeof(npy_intp) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(npy_intp, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(npy_intp) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(npy_intp, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(npy_intp, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(npy_intp) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_intp, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_intp) - 1 > 2 * PyLong_SHIFT)) { + return (npy_intp) (((npy_intp)-1)*(((((npy_intp)digits[1]) << PyLong_SHIFT) | (npy_intp)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(npy_intp) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_intp, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_intp) - 1 > 2 * PyLong_SHIFT)) { + return (npy_intp) ((((((npy_intp)digits[1]) << PyLong_SHIFT) | (npy_intp)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(npy_intp) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_intp, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_intp) - 1 > 3 * PyLong_SHIFT)) { + return (npy_intp) (((npy_intp)-1)*(((((((npy_intp)digits[2]) << PyLong_SHIFT) | (npy_intp)digits[1]) << PyLong_SHIFT) | (npy_intp)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(npy_intp) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_intp, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_intp) - 1 > 3 * PyLong_SHIFT)) { + return (npy_intp) ((((((((npy_intp)digits[2]) << PyLong_SHIFT) | (npy_intp)digits[1]) << PyLong_SHIFT) | (npy_intp)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(npy_intp) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_intp, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_intp) - 1 > 4 * PyLong_SHIFT)) { + return (npy_intp) (((npy_intp)-1)*(((((((((npy_intp)digits[3]) << PyLong_SHIFT) | (npy_intp)digits[2]) << PyLong_SHIFT) | (npy_intp)digits[1]) << PyLong_SHIFT) | (npy_intp)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(npy_intp) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(npy_intp, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(npy_intp) - 1 > 4 * PyLong_SHIFT)) { + return (npy_intp) ((((((((((npy_intp)digits[3]) << PyLong_SHIFT) | (npy_intp)digits[2]) << PyLong_SHIFT) | (npy_intp)digits[1]) << PyLong_SHIFT) | (npy_intp)digits[0]))); + } + } + break; + } + } + #endif + if ((sizeof(npy_intp) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(npy_intp, long, PyLong_AsLong(x)) + } else if ((sizeof(npy_intp) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(npy_intp, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + npy_intp val; + int ret = -1; + #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } + #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + #else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (npy_intp) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (npy_intp) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (npy_intp) -1; + } else { + stepval = v; + } + v = NULL; + val = (npy_intp) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(npy_intp) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((npy_intp) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(npy_intp) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((npy_intp) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((npy_intp) 1) << (sizeof(npy_intp) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); + #endif + if (unlikely(ret)) + return (npy_intp) -1; + return val; + } + raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to npy_intp"); + return (npy_intp) -1; + raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to npy_intp"); + return (npy_intp) -1; + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyLong_From_npy_intp(npy_intp value) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const npy_intp neg_one = (npy_intp) -1, const_zero = (npy_intp) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(npy_intp) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(npy_intp) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + #if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(npy_intp) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + #endif + } + } else { + if (sizeof(npy_intp) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(npy_intp) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; + #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } + #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(npy_intp), + little, !is_unsigned); + #else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(npy_intp)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; + #endif + } + } + +/* CIntToPy */ + static CYTHON_INLINE PyObject* __Pyx_PyLong_From___pyx_anon_enum(int value) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const int neg_one = (int) -1, const_zero = (int) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (is_unsigned) { + if (sizeof(int) < sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(unsigned long)) { + return PyLong_FromUnsignedLong((unsigned long) value); + #if !CYTHON_COMPILING_IN_PYPY + } else if (sizeof(int) <= sizeof(unsigned PY_LONG_LONG)) { + return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value); + #endif + } + } else { + if (sizeof(int) <= sizeof(long)) { + return PyLong_FromLong((long) value); + } else if (sizeof(int) <= sizeof(PY_LONG_LONG)) { + return PyLong_FromLongLong((PY_LONG_LONG) value); + } + } + { + unsigned char *bytes = (unsigned char *)&value; + #if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4 + if (is_unsigned) { + return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1); + } else { + return PyLong_FromNativeBytes(bytes, sizeof(value), -1); + } + #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000 + int one = 1; int little = (int)*(unsigned char *)&one; + return _PyLong_FromByteArray(bytes, sizeof(int), + little, !is_unsigned); + #else + int one = 1; int little = (int)*(unsigned char *)&one; + PyObject *from_bytes, *result = NULL, *kwds = NULL; + PyObject *py_bytes = NULL, *order_str = NULL; + from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes"); + if (!from_bytes) return NULL; + py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof(int)); + if (!py_bytes) goto limited_bad; + order_str = PyUnicode_FromString(little ? "little" : "big"); + if (!order_str) goto limited_bad; + { + PyObject *args[3+(CYTHON_VECTORCALL ? 1 : 0)] = { NULL, py_bytes, order_str }; + if (!is_unsigned) { + kwds = __Pyx_MakeVectorcallBuilderKwds(1); + if (!kwds) goto limited_bad; + if (__Pyx_VectorcallBuilder_AddArgStr("signed", __Pyx_NewRef(Py_True), kwds, args+3, 0) < 0) goto limited_bad; + } + result = __Pyx_Object_Vectorcall_CallFromBuilder(from_bytes, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET, kwds); + } + limited_bad: + Py_XDECREF(kwds); + Py_XDECREF(order_str); + Py_XDECREF(py_bytes); + Py_XDECREF(from_bytes); + return result; + #endif + } + } + +/* PyObjectCall2Args */ + static CYTHON_INLINE PyObject* __Pyx_PyObject_Call2Args(PyObject* function, PyObject* arg1, PyObject* arg2) { + PyObject *args[3] = {NULL, arg1, arg2}; + return __Pyx_PyObject_FastCall(function, args+1, 2 | __Pyx_PY_VECTORCALL_ARGUMENTS_OFFSET); + } + +/* PyObjectCallMethod1 */ + #if !(CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000))) + static PyObject* __Pyx__PyObject_CallMethod1(PyObject* method, PyObject* arg) { + PyObject *result = __Pyx_PyObject_CallOneArg(method, arg); + Py_DECREF(method); + return result; + } + #endif + static PyObject* __Pyx_PyObject_CallMethod1(PyObject* obj, PyObject* method_name, PyObject* arg) { + #if CYTHON_VECTORCALL && (__PYX_LIMITED_VERSION_HEX >= 0x030C0000 || (!CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x03090000)) + PyObject *args[2] = {obj, arg}; + (void) __Pyx_PyObject_CallOneArg; + (void) __Pyx_PyObject_Call2Args; + return PyObject_VectorcallMethod(method_name, args, 2 | PY_VECTORCALL_ARGUMENTS_OFFSET, NULL); + #else + PyObject *method = NULL, *result; + int is_method = __Pyx_PyObject_GetMethod(obj, method_name, &method); + if (likely(is_method)) { + result = __Pyx_PyObject_Call2Args(method, obj, arg); + Py_DECREF(method); + return result; + } + if (unlikely(!method)) return NULL; + return __Pyx__PyObject_CallMethod1(method, arg); + #endif + } + +/* UpdateUnpickledDict */ + static int __Pyx__UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index) { + PyObject *state_dict = __Pyx_PySequence_ITEM(state, index); + if (unlikely(!state_dict)) { + return -1; + } + int non_empty = PyObject_IsTrue(state_dict); + if (non_empty == 0) { + Py_DECREF(state_dict); + return 0; + } else if (unlikely(non_empty == -1)) { + return -1; + } + PyObject *dict; + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030A0000 + dict = PyObject_GetAttrString(obj, "__dict__"); + #else + dict = PyObject_GenericGetDict(obj, NULL); + #endif + if (unlikely(!dict)) { + Py_DECREF(state_dict); + return -1; + } + int result; + if (likely(PyDict_CheckExact(dict))) { + result = PyDict_Update(dict, state_dict); + } else { + PyObject *obj_result = __Pyx_PyObject_CallMethod1(dict, __pyx_mstate_global->__pyx_n_u_update, state_dict); + if (likely(obj_result)) { + Py_DECREF(obj_result); + result = 0; + } else { + result = -1; + } + } + Py_DECREF(state_dict); + Py_DECREF(dict); + return result; + } + static int __Pyx_UpdateUnpickledDict(PyObject *obj, PyObject *state, Py_ssize_t index) { + Py_ssize_t state_size = __Pyx_PyTuple_GET_SIZE(state); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(state_size == -1)) return -1; + #endif + if (state_size <= index) { + return 0; + } + return __Pyx__UpdateUnpickledDict(obj, state, index); + } + +/* CheckUnpickleChecksum */ + static void __Pyx_RaiseUnpickleChecksumError(long checksum, long checksum1, long checksum2, long checksum3, const char *members) { + PyObject *pickle_module = PyImport_ImportModule("pickle"); + if (unlikely(!pickle_module)) return; + PyObject *pickle_error = PyObject_GetAttrString(pickle_module, "PickleError"); + Py_DECREF(pickle_module); + if (unlikely(!pickle_error)) return; + if (checksum2 == checksum1) { + PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x) = (%s))", + checksum, checksum1, members); + } else if (checksum3 == checksum2) { + PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x, 0x%x) = (%s))", + checksum, checksum1, checksum2, members); + } else { + PyErr_Format(pickle_error, "Incompatible checksums (0x%x vs (0x%x, 0x%x, 0x%x) = (%s))", + checksum, checksum1, checksum2, checksum3, members); + } + Py_DECREF(pickle_error); + } + static int __Pyx_CheckUnpickleChecksum(long checksum, long checksum1, long checksum2, long checksum3, const char *members) { + int found = 0; + found |= checksum1 == checksum; + found |= checksum2 == checksum; + found |= checksum3 == checksum; + if (likely(found)) + return 0; + __Pyx_RaiseUnpickleChecksumError(checksum, checksum1, checksum2, checksum3, members); + return -1; + } + +/* CIntFromPy */ + static CYTHON_INLINE long __Pyx_PyLong_As_long(PyObject *x) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const long neg_one = (long) -1, const_zero = (long) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + long val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (long) -1; + val = __Pyx_PyLong_As_long(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 2 * PyLong_SHIFT)) { + return (long) (((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 3 * PyLong_SHIFT)) { + return (long) (((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) >= 4 * PyLong_SHIFT)) { + return (long) (((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0])); + } + } + break; + } + } + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } + #else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (long) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } + #endif + if ((sizeof(long) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(long) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(long, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(long) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(long) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + return (long) ((((((long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(long) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(long) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + return (long) ((((((((long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(long) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) (((long)-1)*(((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(long) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(long, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(long) - 1 > 4 * PyLong_SHIFT)) { + return (long) ((((((((((long)digits[3]) << PyLong_SHIFT) | (long)digits[2]) << PyLong_SHIFT) | (long)digits[1]) << PyLong_SHIFT) | (long)digits[0]))); + } + } + break; + } + } + #endif + if ((sizeof(long) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(long, long, PyLong_AsLong(x)) + } else if ((sizeof(long) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(long, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + long val; + int ret = -1; + #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } + #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + #else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (long) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (long) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (long) -1; + } else { + stepval = v; + } + v = NULL; + val = (long) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(long) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((long) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(long) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((long) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((long) 1) << (sizeof(long) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); + #endif + if (unlikely(ret)) + return (long) -1; + return val; + } + raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to long"); + return (long) -1; + raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to long"); + return (long) -1; + } + +/* CIntFromPy */ + static CYTHON_INLINE char __Pyx_PyLong_As_char(PyObject *x) { + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wconversion" + #endif + const char neg_one = (char) -1, const_zero = (char) 0; + #ifdef __Pyx_HAS_GCC_DIAGNOSTIC + #pragma GCC diagnostic pop + #endif + const int is_unsigned = neg_one > const_zero; + if (unlikely(!PyLong_Check(x))) { + char val; + PyObject *tmp = __Pyx_PyNumber_Long(x); + if (!tmp) return (char) -1; + val = __Pyx_PyLong_As_char(tmp); + Py_DECREF(tmp); + return val; + } + if (is_unsigned) { + #if CYTHON_USE_PYLONG_INTERNALS + if (unlikely(__Pyx_PyLong_IsNeg(x))) { + goto raise_neg_overflow; + } else if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_DigitCount(x)) { + case 2: + if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) >= 2 * PyLong_SHIFT)) { + return (char) (((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 3: + if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) >= 3 * PyLong_SHIFT)) { + return (char) (((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + case 4: + if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) >= 4 * PyLong_SHIFT)) { + return (char) (((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0])); + } + } + break; + } + } + #endif + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7 + if (unlikely(Py_SIZE(x) < 0)) { + goto raise_neg_overflow; + } + #else + { + int result = PyObject_RichCompareBool(x, Py_False, Py_LT); + if (unlikely(result < 0)) + return (char) -1; + if (unlikely(result == 1)) + goto raise_neg_overflow; + } + #endif + if ((sizeof(char) <= sizeof(unsigned long))) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned long, PyLong_AsUnsignedLong(x)) + } else if ((sizeof(char) <= sizeof(unsigned PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(char, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x)) + } + } else { + #if CYTHON_USE_PYLONG_INTERNALS + if (__Pyx_PyLong_IsCompact(x)) { + __PYX_VERIFY_RETURN_INT(char, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x)) + } else { + const digit* digits = __Pyx_PyLong_Digits(x); + assert(__Pyx_PyLong_DigitCount(x) > 1); + switch (__Pyx_PyLong_SignedDigitCount(x)) { + case -2: + if ((8 * sizeof(char) - 1 > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { + return (char) (((char)-1)*(((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 2: + if ((8 * sizeof(char) > 1 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 2 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { + return (char) ((((((char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -3: + if ((8 * sizeof(char) - 1 > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) { + return (char) (((char)-1)*(((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 3: + if ((8 * sizeof(char) > 2 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 3 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) { + return (char) ((((((((char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case -4: + if ((8 * sizeof(char) - 1 > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, long, -(long) (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) - 1 > 4 * PyLong_SHIFT)) { + return (char) (((char)-1)*(((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + case 4: + if ((8 * sizeof(char) > 3 * PyLong_SHIFT)) { + if ((8 * sizeof(unsigned long) > 4 * PyLong_SHIFT)) { + __PYX_VERIFY_RETURN_INT(char, unsigned long, (((((((((unsigned long)digits[3]) << PyLong_SHIFT) | (unsigned long)digits[2]) << PyLong_SHIFT) | (unsigned long)digits[1]) << PyLong_SHIFT) | (unsigned long)digits[0]))) + } else if ((8 * sizeof(char) - 1 > 4 * PyLong_SHIFT)) { + return (char) ((((((((((char)digits[3]) << PyLong_SHIFT) | (char)digits[2]) << PyLong_SHIFT) | (char)digits[1]) << PyLong_SHIFT) | (char)digits[0]))); + } + } + break; + } + } + #endif + if ((sizeof(char) <= sizeof(long))) { + __PYX_VERIFY_RETURN_INT_EXC(char, long, PyLong_AsLong(x)) + } else if ((sizeof(char) <= sizeof(PY_LONG_LONG))) { + __PYX_VERIFY_RETURN_INT_EXC(char, PY_LONG_LONG, PyLong_AsLongLong(x)) + } + } + { + char val; + int ret = -1; + #if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API + Py_ssize_t bytes_copied = PyLong_AsNativeBytes( + x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0)); + if (unlikely(bytes_copied == -1)) { + } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) { + goto raise_overflow; + } else { + ret = 0; + } + #elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray) + int one = 1; int is_little = (int)*(unsigned char *)&one; + unsigned char *bytes = (unsigned char *)&val; + ret = _PyLong_AsByteArray((PyLongObject *)x, + bytes, sizeof(val), + is_little, !is_unsigned); + #else + PyObject *v; + PyObject *stepval = NULL, *mask = NULL, *shift = NULL; + int bits, remaining_bits, is_negative = 0; + int chunk_size = (sizeof(long) < 8) ? 30 : 62; + if (likely(PyLong_CheckExact(x))) { + v = __Pyx_NewRef(x); + } else { + v = PyNumber_Long(x); + if (unlikely(!v)) return (char) -1; + assert(PyLong_CheckExact(v)); + } + { + int result = PyObject_RichCompareBool(v, Py_False, Py_LT); + if (unlikely(result < 0)) { + Py_DECREF(v); + return (char) -1; + } + is_negative = result == 1; + } + if (is_unsigned && unlikely(is_negative)) { + Py_DECREF(v); + goto raise_neg_overflow; + } else if (is_negative) { + stepval = PyNumber_Invert(v); + Py_DECREF(v); + if (unlikely(!stepval)) + return (char) -1; + } else { + stepval = v; + } + v = NULL; + val = (char) 0; + mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done; + shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done; + for (bits = 0; bits < (int) sizeof(char) * 8 - chunk_size; bits += chunk_size) { + PyObject *tmp, *digit; + long idigit; + digit = PyNumber_And(stepval, mask); + if (unlikely(!digit)) goto done; + idigit = PyLong_AsLong(digit); + Py_DECREF(digit); + if (unlikely(idigit < 0)) goto done; + val |= ((char) idigit) << bits; + tmp = PyNumber_Rshift(stepval, shift); + if (unlikely(!tmp)) goto done; + Py_DECREF(stepval); stepval = tmp; + } + Py_DECREF(shift); shift = NULL; + Py_DECREF(mask); mask = NULL; + { + long idigit = PyLong_AsLong(stepval); + if (unlikely(idigit < 0)) goto done; + remaining_bits = ((int) sizeof(char) * 8) - bits - (is_unsigned ? 0 : 1); + if (unlikely(idigit >= (1L << remaining_bits))) + goto raise_overflow; + val |= ((char) idigit) << bits; + } + if (!is_unsigned) { + if (unlikely(val & (((char) 1) << (sizeof(char) * 8 - 1)))) + goto raise_overflow; + if (is_negative) + val = ~val; + } + ret = 0; + done: + Py_XDECREF(shift); + Py_XDECREF(mask); + Py_XDECREF(stepval); + #endif + if (unlikely(ret)) + return (char) -1; + return val; + } + raise_overflow: + PyErr_SetString(PyExc_OverflowError, + "value too large to convert to char"); + return (char) -1; + raise_neg_overflow: + PyErr_SetString(PyExc_OverflowError, + "can't convert negative value to char"); + return (char) -1; + } + +/* FormatTypeName */ + #if CYTHON_COMPILING_IN_LIMITED_API && __PYX_LIMITED_VERSION_HEX < 0x030d0000 + static __Pyx_TypeName + __Pyx_PyType_GetFullyQualifiedName(PyTypeObject* tp) + { + PyObject *module = NULL, *name = NULL, *result = NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + name = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_qualname); + #else + name = PyType_GetQualName(tp); + #endif + if (unlikely(name == NULL) || unlikely(!PyUnicode_Check(name))) goto bad; + module = __Pyx_PyObject_GetAttrStr((PyObject *)tp, + __pyx_mstate_global->__pyx_n_u_module); + if (unlikely(module == NULL) || unlikely(!PyUnicode_Check(module))) goto bad; + if (PyUnicode_CompareWithASCIIString(module, "builtins") == 0) { + result = name; + name = NULL; + goto done; + } + result = PyUnicode_FromFormat("%U.%U", module, name); + if (unlikely(result == NULL)) goto bad; + done: + Py_XDECREF(name); + Py_XDECREF(module); + return result; + bad: + PyErr_Clear(); + if (name) { + result = name; + name = NULL; + } else { + result = __Pyx_NewRef(__pyx_mstate_global->__pyx_kp_u__6); + } + goto done; + } + #endif + +/* GetRuntimeVersion */ + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + void __Pyx_init_runtime_version(void) { + if (__Pyx_cached_runtime_version == 0) { + const char* rt_version = Py_GetVersion(); + unsigned long version = 0; + unsigned long factor = 0x01000000UL; + unsigned int digit = 0; + int i = 0; + while (factor) { + while ('0' <= rt_version[i] && rt_version[i] <= '9') { + digit = digit * 10 + (unsigned int) (rt_version[i] - '0'); + ++i; + } + version += factor * digit; + if (rt_version[i] != '.') + break; + digit = 0; + factor >>= 8; + ++i; + } + __Pyx_cached_runtime_version = version; + } + } + #endif + static unsigned long __Pyx_get_runtime_version(void) { + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + return Py_Version & ~0xFFUL; + #else + return __Pyx_cached_runtime_version; + #endif + } + +/* CheckBinaryVersion */ + static int __Pyx_check_binary_version(unsigned long ct_version, unsigned long rt_version, int allow_newer) { + const unsigned long MAJOR_MINOR = 0xFFFF0000UL; + if ((rt_version & MAJOR_MINOR) == (ct_version & MAJOR_MINOR)) + return 0; + if (likely(allow_newer && (rt_version & MAJOR_MINOR) > (ct_version & MAJOR_MINOR))) + return 1; + { + char message[200]; + PyOS_snprintf(message, sizeof(message), + "compile time Python version %d.%d " + "of module '%.100s' " + "%s " + "runtime version %d.%d", + (int) (ct_version >> 24), (int) ((ct_version >> 16) & 0xFF), + __Pyx_MODULE_NAME, + (allow_newer) ? "was newer than" : "does not match", + (int) (rt_version >> 24), (int) ((rt_version >> 16) & 0xFF) + ); + return PyErr_WarnEx(NULL, message, 1); + } + } + +/* NewCodeObj */ + #if CYTHON_COMPILING_IN_LIMITED_API + static PyObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyObject *exception_table = NULL; + PyObject *types_module=NULL, *code_type=NULL, *result=NULL; + #if __PYX_LIMITED_VERSION_HEX < 0x030b0000 + PyObject *version_info; + PyObject *py_minor_version = NULL; + #endif + long minor_version = 0; + PyObject *type, *value, *traceback; + PyErr_Fetch(&type, &value, &traceback); + #if __PYX_LIMITED_VERSION_HEX >= 0x030b0000 + minor_version = 11; + #else + if (!(version_info = PySys_GetObject("version_info"))) goto end; + if (!(py_minor_version = PySequence_GetItem(version_info, 1))) goto end; + minor_version = PyLong_AsLong(py_minor_version); + Py_DECREF(py_minor_version); + if (minor_version == -1 && PyErr_Occurred()) goto end; + #endif + if (!(types_module = PyImport_ImportModule("types"))) goto end; + if (!(code_type = PyObject_GetAttrString(types_module, "CodeType"))) goto end; + if (minor_version <= 7) { + (void)p; + result = PyObject_CallFunction(code_type, "iiiiiOOOOOOiOOO", a, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else if (minor_version <= 10) { + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOiOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, fline, lnos, fv, cell); + } else { + if (!(exception_table = PyBytes_FromStringAndSize(NULL, 0))) goto end; + result = PyObject_CallFunction(code_type, "iiiiiiOOOOOOOiOOOO", a,p, k, l, s, f, code, + c, n, v, fn, name, name, fline, lnos, exception_table, fv, cell); + } + end: + Py_XDECREF(code_type); + Py_XDECREF(exception_table); + Py_XDECREF(types_module); + if (type) { + PyErr_Restore(type, value, traceback); + } + return result; + } + #elif PY_VERSION_HEX >= 0x030B0000 + static PyCodeObject* __Pyx__PyCode_New(int a, int p, int k, int l, int s, int f, + PyObject *code, PyObject *c, PyObject* n, PyObject *v, + PyObject *fv, PyObject *cell, PyObject* fn, + PyObject *name, int fline, PyObject *lnos) { + PyCodeObject *result; + result = + #if PY_VERSION_HEX >= 0x030C0000 + PyUnstable_Code_NewWithPosOnlyArgs + #else + PyCode_NewWithPosOnlyArgs + #endif + (a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, name, fline, lnos, __pyx_mstate_global->__pyx_empty_bytes); + #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030c00A1 + if (likely(result)) + result->_co_firsttraceable = 0; + #endif + return result; + } + #elif !CYTHON_COMPILING_IN_PYPY + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_NewWithPosOnlyArgs(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #else + #define __Pyx__PyCode_New(a, p, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\ + PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos) + #endif + static PyObject* __Pyx_PyCode_New( + const __Pyx_PyCode_New_function_description descr, + PyObject * const *varnames, + PyObject *filename, + PyObject *funcname, + PyObject *line_table, + PyObject *tuple_dedup_map + ) { + PyObject *code_obj = NULL, *varnames_tuple_dedup = NULL, *code_bytes = NULL; + Py_ssize_t var_count = (Py_ssize_t) descr.nlocals; + PyObject *varnames_tuple = PyTuple_New(var_count); + if (unlikely(!varnames_tuple)) return NULL; + for (Py_ssize_t i=0; i < var_count; i++) { + Py_INCREF(varnames[i]); + if (__Pyx_PyTuple_SET_ITEM(varnames_tuple, i, varnames[i]) != (0)) goto done; + } + #if CYTHON_COMPILING_IN_LIMITED_API + varnames_tuple_dedup = PyDict_GetItem(tuple_dedup_map, varnames_tuple); + if (!varnames_tuple_dedup) { + if (unlikely(PyDict_SetItem(tuple_dedup_map, varnames_tuple, varnames_tuple) < 0)) goto done; + varnames_tuple_dedup = varnames_tuple; + } + #else + varnames_tuple_dedup = PyDict_SetDefault(tuple_dedup_map, varnames_tuple, varnames_tuple); + if (unlikely(!varnames_tuple_dedup)) goto done; + #endif + #if CYTHON_AVOID_BORROWED_REFS + Py_INCREF(varnames_tuple_dedup); + #endif + if (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table != NULL && !CYTHON_COMPILING_IN_GRAAL) { + Py_ssize_t line_table_length = __Pyx_PyBytes_GET_SIZE(line_table); + #if !CYTHON_ASSUME_SAFE_SIZE + if (unlikely(line_table_length == -1)) goto done; + #endif + Py_ssize_t code_len = (line_table_length * 2 + 4) & ~3LL; + code_bytes = PyBytes_FromStringAndSize(NULL, code_len); + if (unlikely(!code_bytes)) goto done; + char* c_code_bytes = PyBytes_AsString(code_bytes); + if (unlikely(!c_code_bytes)) goto done; + memset(c_code_bytes, 0, (size_t) code_len); + } + code_obj = (PyObject*) __Pyx__PyCode_New( + (int) descr.argcount, + (int) descr.num_posonly_args, + (int) descr.num_kwonly_args, + (int) descr.nlocals, + 0, + (int) descr.flags, + code_bytes ? code_bytes : __pyx_mstate_global->__pyx_empty_bytes, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + varnames_tuple_dedup, + __pyx_mstate_global->__pyx_empty_tuple, + __pyx_mstate_global->__pyx_empty_tuple, + filename, + funcname, + (int) descr.first_line, + (__PYX_LIMITED_VERSION_HEX >= (0x030b0000) && line_table) ? line_table : __pyx_mstate_global->__pyx_empty_bytes + ); + done: + Py_XDECREF(code_bytes); + #if CYTHON_AVOID_BORROWED_REFS + Py_XDECREF(varnames_tuple_dedup); + #endif + Py_DECREF(varnames_tuple); + return code_obj; + } + +/* DecompressString */ + static PyObject *__Pyx_DecompressString(const char *s, Py_ssize_t length, int algo) { + PyObject *module, *decompress, *compressed_bytes, *decompressed; + const char* module_name = algo == 3 ? "compression.zstd" : algo == 2 ? "bz2" : "zlib"; + PyObject *methodname = PyUnicode_FromString("decompress"); + if (unlikely(!methodname)) return NULL; + #if __PYX_LIMITED_VERSION_HEX >= 0x030e0000 + if (algo == 3) { + PyObject *fromlist = Py_BuildValue("[O]", methodname); + if (unlikely(!fromlist)) return NULL; + module = PyImport_ImportModuleLevel("compression.zstd", NULL, NULL, fromlist, 0); + Py_DECREF(fromlist); + } else + #endif + module = PyImport_ImportModule(module_name); + if (unlikely(!module)) goto import_failed; + decompress = PyObject_GetAttr(module, methodname); + if (unlikely(!decompress)) goto import_failed; + { + #ifdef __cplusplus + char *memview_bytes = const_cast(s); + #else + #if defined(__clang__) + #pragma clang diagnostic push + #pragma clang diagnostic ignored "-Wcast-qual" + #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) + #pragma GCC diagnostic push + #pragma GCC diagnostic ignored "-Wcast-qual" + #endif + char *memview_bytes = (char*) s; + #if defined(__clang__) + #pragma clang diagnostic pop + #elif !defined(__INTEL_COMPILER) && defined(__GNUC__) + #pragma GCC diagnostic pop + #endif + #endif + #if CYTHON_COMPILING_IN_LIMITED_API && !defined(PyBUF_READ) + int memview_flags = 0x100; + #else + int memview_flags = PyBUF_READ; + #endif + compressed_bytes = PyMemoryView_FromMemory(memview_bytes, length, memview_flags); + } + if (unlikely(!compressed_bytes)) { + Py_DECREF(decompress); + goto bad; + } + decompressed = PyObject_CallFunctionObjArgs(decompress, compressed_bytes, NULL); + Py_DECREF(compressed_bytes); + Py_DECREF(decompress); + Py_DECREF(module); + Py_DECREF(methodname); + return decompressed; + import_failed: + PyErr_Format(PyExc_ImportError, + "Failed to import '%.20s.decompress' - cannot initialise module strings. " + "String compression was configured with the C macro 'CYTHON_COMPRESS_STRINGS=%d'.", + module_name, algo); + bad: + Py_XDECREF(module); + Py_DECREF(methodname); + return NULL; + } + +#include +static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) { + size_t len = strlen(s); + if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) { + PyErr_SetString(PyExc_OverflowError, "byte string is too long"); + return -1; + } + return (Py_ssize_t) len; +} +static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return __Pyx_PyUnicode_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) { + Py_ssize_t len = __Pyx_ssize_strlen(c_str); + if (unlikely(len < 0)) return NULL; + return PyByteArray_FromStringAndSize(c_str, len); +} +static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) { + Py_ssize_t ignore; + return __Pyx_PyObject_AsStringAndSize(o, &ignore); +} +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 +static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) { + if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL; +#if CYTHON_COMPILING_IN_LIMITED_API + { + const char* result; + Py_ssize_t unicode_length; + CYTHON_MAYBE_UNUSED_VAR(unicode_length); // only for __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + #if __PYX_LIMITED_VERSION_HEX < 0x030A0000 + if (unlikely(PyArg_Parse(o, "s#", &result, length) < 0)) return NULL; + #else + result = PyUnicode_AsUTF8AndSize(o, length); + #endif + #if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + unicode_length = PyUnicode_GetLength(o); + if (unlikely(unicode_length < 0)) return NULL; + if (unlikely(unicode_length != *length)) { + PyUnicode_AsASCIIString(o); + return NULL; + } + #endif + return result; + } +#else +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII + if (likely(PyUnicode_IS_ASCII(o))) { + *length = PyUnicode_GET_LENGTH(o); + return PyUnicode_AsUTF8(o); + } else { + PyUnicode_AsASCIIString(o); + return NULL; + } +#else + return PyUnicode_AsUTF8AndSize(o, length); +#endif +#endif +} +#endif +static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) { +#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_UTF8 + if (PyUnicode_Check(o)) { + return __Pyx_PyUnicode_AsStringAndSize(o, length); + } else +#endif + if (PyByteArray_Check(o)) { +#if (CYTHON_ASSUME_SAFE_SIZE && CYTHON_ASSUME_SAFE_MACROS) || (CYTHON_COMPILING_IN_PYPY && (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))) + *length = PyByteArray_GET_SIZE(o); + return PyByteArray_AS_STRING(o); +#else + *length = PyByteArray_Size(o); + if (*length == -1) return NULL; + return PyByteArray_AsString(o); +#endif + } else + { + char* result; + int r = PyBytes_AsStringAndSize(o, &result, length); + if (unlikely(r < 0)) { + return NULL; + } else { + return result; + } + } +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) { + int is_true = x == Py_True; + if (is_true | (x == Py_False) | (x == Py_None)) return is_true; + else return PyObject_IsTrue(x); +} +static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) { + int retval; + if (unlikely(!x)) return -1; + retval = __Pyx_PyObject_IsTrue(x); + Py_DECREF(x); + return retval; +} +static PyObject* __Pyx_PyNumber_LongWrongResultType(PyObject* result) { + __Pyx_TypeName result_type_name = __Pyx_PyType_GetFullyQualifiedName(Py_TYPE(result)); + if (PyLong_Check(result)) { + if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME "). " + "The ability to return an instance of a strict subclass of int is deprecated, " + "and may be removed in a future version of Python.", + result_type_name)) { + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; + } + __Pyx_DECREF_TypeName(result_type_name); + return result; + } + PyErr_Format(PyExc_TypeError, + "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ")", + result_type_name); + __Pyx_DECREF_TypeName(result_type_name); + Py_DECREF(result); + return NULL; +} +static CYTHON_INLINE PyObject* __Pyx_PyNumber_Long(PyObject* x) { +#if CYTHON_USE_TYPE_SLOTS + PyNumberMethods *m; +#endif + PyObject *res = NULL; + if (likely(PyLong_Check(x))) + return __Pyx_NewRef(x); +#if CYTHON_USE_TYPE_SLOTS + m = Py_TYPE(x)->tp_as_number; + if (likely(m && m->nb_int)) { + res = m->nb_int(x); + } +#else + if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) { + res = PyNumber_Long(x); + } +#endif + if (likely(res)) { + if (unlikely(!PyLong_CheckExact(res))) { + return __Pyx_PyNumber_LongWrongResultType(res); + } + } + else if (!PyErr_Occurred()) { + PyErr_SetString(PyExc_TypeError, + "an integer is required"); + } + return res; +} +static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) { + Py_ssize_t ival; + PyObject *x; + if (likely(PyLong_CheckExact(b))) { + #if CYTHON_USE_PYLONG_INTERNALS + if (likely(__Pyx_PyLong_IsCompact(b))) { + return __Pyx_PyLong_CompactValue(b); + } else { + const digit* digits = __Pyx_PyLong_Digits(b); + const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b); + switch (size) { + case 2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return (Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -2: + if (8 * sizeof(Py_ssize_t) > 2 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -3: + if (8 * sizeof(Py_ssize_t) > 3 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case 4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return (Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + case -4: + if (8 * sizeof(Py_ssize_t) > 4 * PyLong_SHIFT) { + return -(Py_ssize_t) (((((((((size_t)digits[3]) << PyLong_SHIFT) | (size_t)digits[2]) << PyLong_SHIFT) | (size_t)digits[1]) << PyLong_SHIFT) | (size_t)digits[0])); + } + break; + } + } + #endif + return PyLong_AsSsize_t(b); + } + x = PyNumber_Index(b); + if (!x) return -1; + ival = PyLong_AsSsize_t(x); + Py_DECREF(x); + return ival; +} +static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) { + if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) { + return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o); + } else { + Py_ssize_t ival; + PyObject *x; + x = PyNumber_Index(o); + if (!x) return -1; + ival = PyLong_AsLong(x); + Py_DECREF(x); + return ival; + } +} +static CYTHON_INLINE PyObject *__Pyx_Owned_Py_None(int b) { + CYTHON_UNUSED_VAR(b); + return __Pyx_NewRef(Py_None); +} +static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) { + return __Pyx_NewRef(b ? Py_True: Py_False); +} +static CYTHON_INLINE PyObject * __Pyx_PyLong_FromSize_t(size_t ival) { + return PyLong_FromSize_t(ival); +} + + + /* MultiPhaseInitModuleState */ + #if CYTHON_PEP489_MULTI_PHASE_INIT && CYTHON_USE_MODULE_STATE + #ifndef CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + #if (CYTHON_COMPILING_IN_LIMITED_API || PY_VERSION_HEX >= 0x030C0000) + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 1 + #else + #define CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE 0 + #endif + #endif + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE && !CYTHON_ATOMICS + #error "Module state with PEP489 requires atomics. Currently that's one of\ + C11, C++11, gcc atomic intrinsics or MSVC atomic intrinsics" + #endif + #if !CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + #define __Pyx_ModuleStateLookup_Lock() + #define __Pyx_ModuleStateLookup_Unlock() + #elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d0000 + static PyMutex __Pyx_ModuleStateLookup_mutex = {0}; + #define __Pyx_ModuleStateLookup_Lock() PyMutex_Lock(&__Pyx_ModuleStateLookup_mutex) + #define __Pyx_ModuleStateLookup_Unlock() PyMutex_Unlock(&__Pyx_ModuleStateLookup_mutex) + #elif defined(__cplusplus) && __cplusplus >= 201103L + #include + static std::mutex __Pyx_ModuleStateLookup_mutex; + #define __Pyx_ModuleStateLookup_Lock() __Pyx_ModuleStateLookup_mutex.lock() + #define __Pyx_ModuleStateLookup_Unlock() __Pyx_ModuleStateLookup_mutex.unlock() + #elif defined(__STDC_VERSION__) && (__STDC_VERSION__ > 201112L) && !defined(__STDC_NO_THREADS__) + #include + static mtx_t __Pyx_ModuleStateLookup_mutex; + static once_flag __Pyx_ModuleStateLookup_mutex_once_flag = ONCE_FLAG_INIT; + static void __Pyx_ModuleStateLookup_initialize_mutex(void) { + mtx_init(&__Pyx_ModuleStateLookup_mutex, mtx_plain); + } + #define __Pyx_ModuleStateLookup_Lock()\ + call_once(&__Pyx_ModuleStateLookup_mutex_once_flag, __Pyx_ModuleStateLookup_initialize_mutex);\ + mtx_lock(&__Pyx_ModuleStateLookup_mutex) + #define __Pyx_ModuleStateLookup_Unlock() mtx_unlock(&__Pyx_ModuleStateLookup_mutex) + #elif defined(HAVE_PTHREAD_H) + #include + static pthread_mutex_t __Pyx_ModuleStateLookup_mutex = PTHREAD_MUTEX_INITIALIZER; + #define __Pyx_ModuleStateLookup_Lock() pthread_mutex_lock(&__Pyx_ModuleStateLookup_mutex) + #define __Pyx_ModuleStateLookup_Unlock() pthread_mutex_unlock(&__Pyx_ModuleStateLookup_mutex) + #elif defined(_WIN32) + #include // synchapi.h on its own doesn't work + static SRWLOCK __Pyx_ModuleStateLookup_mutex = SRWLOCK_INIT; + #define __Pyx_ModuleStateLookup_Lock() AcquireSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) + #define __Pyx_ModuleStateLookup_Unlock() ReleaseSRWLockExclusive(&__Pyx_ModuleStateLookup_mutex) + #else + #error "No suitable lock available for CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE.\ + Requires C standard >= C11, or C++ standard >= C++11,\ + or pthreads, or the Windows 32 API, or Python >= 3.13." + #endif + typedef struct { + int64_t id; + PyObject *module; + } __Pyx_InterpreterIdAndModule; + typedef struct { + char interpreter_id_as_index; + Py_ssize_t count; + Py_ssize_t allocated; + __Pyx_InterpreterIdAndModule table[1]; + } __Pyx_ModuleStateLookupData; + #define __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE 32 + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + static __pyx_atomic_int_type __Pyx_ModuleStateLookup_read_counter = 0; + #endif + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + static __pyx_atomic_ptr_type __Pyx_ModuleStateLookup_data = 0; + #else + static __Pyx_ModuleStateLookupData* __Pyx_ModuleStateLookup_data = NULL; + #endif + static __Pyx_InterpreterIdAndModule* __Pyx_State_FindModuleStateLookupTableLowerBound( + __Pyx_InterpreterIdAndModule* table, + Py_ssize_t count, + int64_t interpreterId) { + __Pyx_InterpreterIdAndModule* begin = table; + __Pyx_InterpreterIdAndModule* end = begin + count; + if (begin->id == interpreterId) { + return begin; + } + while ((end - begin) > __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + __Pyx_InterpreterIdAndModule* halfway = begin + (end - begin)/2; + if (halfway->id == interpreterId) { + return halfway; + } + if (halfway->id < interpreterId) { + begin = halfway; + } else { + end = halfway; + } + } + for (; begin < end; ++begin) { + if (begin->id >= interpreterId) return begin; + } + return begin; + } + static PyObject *__Pyx_State_FindModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return NULL; + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData* data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + { + __pyx_atomic_incr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + if (likely(data)) { + __Pyx_ModuleStateLookupData* new_data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_acquire(&__Pyx_ModuleStateLookup_data); + if (likely(data == new_data)) { + goto read_finished; + } + } + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + __Pyx_ModuleStateLookup_Lock(); + __pyx_atomic_incr_relaxed(&__Pyx_ModuleStateLookup_read_counter); + data = (__Pyx_ModuleStateLookupData*)__pyx_atomic_pointer_load_relaxed(&__Pyx_ModuleStateLookup_data); + __Pyx_ModuleStateLookup_Unlock(); + } + read_finished:; + #else + __Pyx_ModuleStateLookupData* data = __Pyx_ModuleStateLookup_data; + #endif + __Pyx_InterpreterIdAndModule* found = NULL; + if (unlikely(!data)) goto end; + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + found = data->table+interpreter_id; + } + } else { + found = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + } + end: + { + PyObject *result=NULL; + if (found && found->id == interpreter_id) { + result = found->module; + } + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_decr_acq_rel(&__Pyx_ModuleStateLookup_read_counter); + #endif + return result; + } + } + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + static void __Pyx_ModuleStateLookup_wait_until_no_readers(void) { + while (__pyx_atomic_load(&__Pyx_ModuleStateLookup_read_counter) != 0); + } + #else + #define __Pyx_ModuleStateLookup_wait_until_no_readers() + #endif + static int __Pyx_State_AddModuleInterpIdAsIndex(__Pyx_ModuleStateLookupData **old_data, PyObject* module, int64_t interpreter_id) { + Py_ssize_t to_allocate = (*old_data)->allocated; + while (to_allocate <= interpreter_id) { + if (to_allocate == 0) to_allocate = 1; + else to_allocate *= 2; + } + __Pyx_ModuleStateLookupData *new_data = *old_data; + if (to_allocate != (*old_data)->allocated) { + new_data = (__Pyx_ModuleStateLookupData *)realloc( + *old_data, + sizeof(__Pyx_ModuleStateLookupData)+(to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + PyErr_NoMemory(); + return -1; + } + for (Py_ssize_t i = new_data->allocated; i < to_allocate; ++i) { + new_data->table[i].id = i; + new_data->table[i].module = NULL; + } + new_data->allocated = to_allocate; + } + new_data->table[interpreter_id].module = module; + if (new_data->count < interpreter_id+1) { + new_data->count = interpreter_id+1; + } + *old_data = new_data; + return 0; + } + static void __Pyx_State_ConvertFromInterpIdAsIndex(__Pyx_ModuleStateLookupData *data) { + __Pyx_InterpreterIdAndModule *read = data->table; + __Pyx_InterpreterIdAndModule *write = data->table; + __Pyx_InterpreterIdAndModule *end = read + data->count; + for (; readmodule) { + write->id = read->id; + write->module = read->module; + ++write; + } + } + data->count = write - data->table; + for (; writeid = 0; + write->module = NULL; + } + data->interpreter_id_as_index = 0; + } + static int __Pyx_State_AddModule(PyObject* module, CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + int result = 0; + __Pyx_ModuleStateLookup_Lock(); + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *old_data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); + #else + __Pyx_ModuleStateLookupData *old_data = __Pyx_ModuleStateLookup_data; + #endif + __Pyx_ModuleStateLookupData *new_data = old_data; + if (!new_data) { + new_data = (__Pyx_ModuleStateLookupData *)calloc(1, sizeof(__Pyx_ModuleStateLookupData)); + if (!new_data) { + result = -1; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = 1; + new_data->interpreter_id_as_index = 1; + } + __Pyx_ModuleStateLookup_wait_until_no_readers(); + if (new_data->interpreter_id_as_index) { + if (interpreter_id < __PYX_MODULE_STATE_LOOKUP_SMALL_SIZE) { + result = __Pyx_State_AddModuleInterpIdAsIndex(&new_data, module, interpreter_id); + goto end; + } + __Pyx_State_ConvertFromInterpIdAsIndex(new_data); + } + { + Py_ssize_t insert_at = 0; + { + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + new_data->table, new_data->count, interpreter_id); + assert(lower_bound); + insert_at = lower_bound - new_data->table; + if (unlikely(insert_at < new_data->count && lower_bound->id == interpreter_id)) { + lower_bound->module = module; + goto end; // already in table, nothing more to do + } + } + if (new_data->count+1 >= new_data->allocated) { + Py_ssize_t to_allocate = (new_data->count+1)*2; + new_data = + (__Pyx_ModuleStateLookupData*)realloc( + new_data, + sizeof(__Pyx_ModuleStateLookupData) + + (to_allocate-1)*sizeof(__Pyx_InterpreterIdAndModule)); + if (!new_data) { + result = -1; + new_data = old_data; + PyErr_NoMemory(); + goto end; + } + new_data->allocated = to_allocate; + } + ++new_data->count; + int64_t last_id = interpreter_id; + PyObject *last_module = module; + for (Py_ssize_t i=insert_at; icount; ++i) { + int64_t current_id = new_data->table[i].id; + new_data->table[i].id = last_id; + last_id = current_id; + PyObject *current_module = new_data->table[i].module; + new_data->table[i].module = last_module; + last_module = current_module; + } + } + end: + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, new_data); + #else + __Pyx_ModuleStateLookup_data = new_data; + #endif + __Pyx_ModuleStateLookup_Unlock(); + return result; + } + static int __Pyx_State_RemoveModule(CYTHON_UNUSED void* dummy) { + int64_t interpreter_id = PyInterpreterState_GetID(__Pyx_PyInterpreterState_Get()); + if (interpreter_id == -1) return -1; + __Pyx_ModuleStateLookup_Lock(); + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __Pyx_ModuleStateLookupData *data = (__Pyx_ModuleStateLookupData *) + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, 0); + #else + __Pyx_ModuleStateLookupData *data = __Pyx_ModuleStateLookup_data; + #endif + if (data->interpreter_id_as_index) { + if (interpreter_id < data->count) { + data->table[interpreter_id].module = NULL; + } + goto done; + } + { + __Pyx_ModuleStateLookup_wait_until_no_readers(); + __Pyx_InterpreterIdAndModule* lower_bound = __Pyx_State_FindModuleStateLookupTableLowerBound( + data->table, data->count, interpreter_id); + if (!lower_bound) goto done; + if (lower_bound->id != interpreter_id) goto done; + __Pyx_InterpreterIdAndModule *end = data->table+data->count; + for (;lower_boundid = (lower_bound+1)->id; + lower_bound->module = (lower_bound+1)->module; + } + } + --data->count; + if (data->count == 0) { + free(data); + data = NULL; + } + done: + #if CYTHON_MODULE_STATE_LOOKUP_THREAD_SAFE + __pyx_atomic_pointer_exchange(&__Pyx_ModuleStateLookup_data, data); + #else + __Pyx_ModuleStateLookup_data = data; + #endif + __Pyx_ModuleStateLookup_Unlock(); + return 0; + } + #endif + +/* #### Code section: utility_code_pragmas_end ### */ +#ifdef _MSC_VER +#pragma warning( pop ) +#endif + + + +/* #### Code section: end ### */ +#endif /* Py_PYTHON_H */ diff --git a/src/cssm/__init__.py b/src/cssm/__init__.py index 3943603..df9bd27 100644 --- a/src/cssm/__init__.py +++ b/src/cssm/__init__.py @@ -23,6 +23,10 @@ ddm_flexbound_tradeoff, ) +from .addm_models import ( + addm +) + from .race_models import race_model, lca, racing_diffusion_model from .poisson_race_models import poisson_race from .lba_models import lba_vanilla, lba_angle, rlwm_lba_pw_v1, rlwm_lba_race @@ -52,6 +56,8 @@ "full_ddm", "ddm_sdv", "ddm_flexbound_tradeoff", + # ADDM model + "addm", # Race models "race_model", "lca", diff --git a/src/cssm/addm_models.pyx b/src/cssm/addm_models.pyx new file mode 100644 index 0000000..eb1f212 --- /dev/null +++ b/src/cssm/addm_models.pyx @@ -0,0 +1,235 @@ +# cython: cdivision=True +# cython: wraparound=False +# cython: boundscheck=False +# cython: initializedcheck=False + +""" +Attentional Drift Diffusion Model (ADDM) Simulator. + +Model parameters (per-trial arrays of length n_trials): + eta – attention discount + kappa – drift scaling + a – boundary height (upper = +a, lower = -a) + z – starting point bias (relative, in [0,1]; 0.5 = unbiased) + t – non-decision time (added to simulated RT) + +All other quantities (r1, r2, fixation durations, flag, mu1, mu2) are +sampled internally on every (trial, sample) pair. + +The function signature and return format mirror ddm_models.pyx so that +the rest of the pipeline (dataset generation, config, etc.) can treat +this model identically. +""" + +import cython +from libc.math cimport sqrt, fabs, log, exp, fmax, fmin +from libc.stdlib cimport rand, RAND_MAX +import numpy as np +cimport numpy as np + +# Import utility functions from the _utils module +from cssm._utils import ( + set_seed, + random_uniform, + draw_gaussian, + draw_uniform, + sign, + setup_simulation, + compute_boundary, + compute_smooth_unif, + enforce_deadline, + compute_deadline_tmp, + build_full_metadata, + build_minimal_metadata, + build_return_dict, +) + + +include "_rng_wrappers.pxi" +include "_constants.pxi" + + +DTYPE = np.float32 + + +# --------------------------------------------------------------------------- +# Internal C-level helper: look up piecewise-constant drift at time t +# --------------------------------------------------------------------------- +cdef double _piecewise_drift(double t, + double* mu_arr, + double* sacc_arr, + int d) nogil: + cdef int i + for i in range(d - 1, -1, -1): + if t >= sacc_arr[i]: + return mu_arr[i] + return mu_arr[0] + + + +def addm(np.ndarray[float, ndim=1] eta, + np.ndarray[float, ndim=1] kappa, + np.ndarray[float, ndim=1] a, + np.ndarray[float, ndim=1] z, + np.ndarray[float, ndim=1] b, + np.ndarray[float, ndim=1] t, + np.ndarray[float, ndim=1] deadline, + np.ndarray[float, ndim=1] s, + # ---- simulation settings (not model params) ---- + float gamma_shape = 6.0, + float gamma_scale = 0.1, + int max_fixations = 100, + float delta_t = 0.0001, + float max_t = 20.0, + int n_samples = 1000, + int n_trials = 10, + return_option = 'full', + smooth_unif = False, + random_state = None, + int n_threads = 1, + **kwargs): + """ + Simulate the aDDM with constant symmetric boundaries. + + Returns a dict with the same structure as ddm_constant so that + downstream code (dataset builders, etc.) can consume it uniformly. + + The returned ``rts`` array has shape ``(n_samples, n_trials, 1)`` + and ``choices`` has the same shape, following the convention in + ddm_models.pyx. + """ + + + cdef uint64_t seed = random_state if random_state is not None else np.random.randint(0, 2**31) + rng = np.random.default_rng(seed) + setup = setup_simulation(n_samples, n_trials, max_t, delta_t, random_state) + traj = setup['traj'] + rts = setup['rts'] + choices = setup['choices'] + cdef float[:, :] traj_view = traj + cdef float[:, :, :] rts_view = rts + cdef int[:, :, :] choices_view = choices + cdef float[:] gaussian_values = setup['gaussian_values'] + cdef float[:] uniform_values = setup['uniform_values'] + t_s = setup['t_s'] + cdef int num_draws = setup['num_draws'] + cdef float delta_t_sqrt = setup['delta_t_sqrt'] + + # Param Views + cdef float[:] eta_view = eta + cdef float[:] kappa_view = kappa + cdef float[:] a_view = a + cdef float[:] z_view = z + cdef float[:] b_view = b + cdef float[:] t_view = t + cdef float[:] s_view = s + cdef float[:] deadline_view = deadline + + + cdef int k, n, ix, d, flag, r1, r2 + cdef float y, t_particle, drift_val, deadline_tmp, sqrt_st + cdef float mu1, mu2 + cdef int m = 0 + cdef int mu = 0 + + cdef double[::1] mu_view + cdef double[::1] sacc_view + + for k in range(n_trials): + deadline_tmp = compute_deadline_tmp(max_t, deadline_view[k], t_view[k]) + sqrt_st = delta_t_sqrt * s_view[k] + for n in range(n_samples): + # ========================================================= + # (a) Sample latent trial-level variables + # ========================================================= + r1 = int(rng.integers(1, 6, endpoint=False)) + r2 = int(rng.integers(1, 6, endpoint=False)) + flag = int(rng.integers(0, 2)) # 0 or 1 + + mu1 = kappa_view[k] * (r1 - eta_view[k] * r2) + mu2 = kappa_view[k] * (eta_view[k] * r1 - r2) + + # ---- fixation durations → saccade switch-times ---------- + fixations_np = rng.gamma(gamma_shape, gamma_scale, max_fixations) + sacc_full = np.insert(np.cumsum(fixations_np), 0, 0.0) + sacc_np = sacc_full[sacc_full < max_t].astype(np.float64) + + d = len(sacc_np) + if d == 0: + d = 1 + sacc_np = np.array([0.0], dtype=np.float64) + + # ---- alternating drift array ---------------------------- + mu_np = np.empty(d, dtype=np.float64) + for i in range(d): + if flag == 0: + mu_np[i] = mu1 if (i % 2 == 0) else mu2 + else: + mu_np[i] = mu2 if (i % 2 == 0) else mu1 + + # typed views for the C-level helper + mu_view = mu_np + sacc_view = sacc_np + + + # ========================================================= + # (b) Euler-Maruyama diffusion (constant boundaries) + # ========================================================= + y = z_view[k] # actual starting position + t_particle = 0.0 + ix = 0 + while y <= a_view[k] - b_view[k] * t_particle and y >= -a_view[k] + b_view[k] * t_particle and t_particle <= deadline_tmp: + # --- step the particle --- + drift_val = _piecewise_drift(t_particle, + &mu_view[0], + &sacc_view[0], + d) + y += drift_val * delta_t + sqrt_st * gaussian_values[ix] + t_particle += delta_t + m += 1 + ix += 1 + + if n == 0: + if k == 0: + traj_view[ix, 0] = y + + if m == num_draws: + gaussian_values = draw_gaussian(num_draws) + m = 0 + + # Apply smoothing + smooth_u = compute_smooth_unif(smooth_unif, t_particle, deadline_tmp, delta_t, uniform_values[mu]) + mu += 1 + if mu == num_draws: + uniform_values = draw_uniform(num_draws) + mu = 0 + + rts_view[n, k, 0] = t_particle + t_view[k] + smooth_u + choices_view[n, k, 0] = sign(y) + + minimal_meta = build_minimal_metadata( + simulator_name = 'addm', + possible_choices = [-1, 1], + n_samples = n_samples, + n_trials = n_trials, + boundary_fun_name = 'constant' + ) + if return_option == 'full': + sim_config = {'delta_t': delta_t, 'max_t': max_t} + params = { + 'eta': eta, + 'kappa': kappa, + 'a': a, + 'z': z, + 'b': b, + 't': t, + 's': s + } + full_meta = build_full_metadata(minimal_metadata= minimal_meta, sim_config=sim_config, params=params, traj=traj) + return build_return_dict(rts, choices, full_meta) + + elif return_option == 'minimal': + return build_return_dict(rts, choices, minimal_meta) + + else: + raise ValueError(f"Invalid return_option: {return_option}. Must be 'full' or 'minimal'.") \ No newline at end of file diff --git a/ssms/config/_modelconfig/__init__.py b/ssms/config/_modelconfig/__init__.py index 8360627..91b18d9 100644 --- a/ssms/config/_modelconfig/__init__.py +++ b/ssms/config/_modelconfig/__init__.py @@ -132,6 +132,10 @@ get_shrink_spot_simple_config, get_shrink_spot_simple_extended_config, ) + +from .addm import ( + get_addm_config +) from .validation import get_invalid_configs @@ -225,6 +229,7 @@ def get_model_config(): "ddm_mic2_multinoise_conflict_gamma_no_bias": get_ddm_mic2_multinoise_conflict_gamma_no_bias_config(), "ddm_mic2_multinoise_angle_no_bias": get_ddm_mic2_multinoise_angle_no_bias_config(), "ddm_mic2_multinoise_weibull_no_bias": get_ddm_mic2_multinoise_weibull_no_bias_config(), + "addm": get_addm_config(), "full_ddm": get_full_ddm_config(), "full_ddm_rv": get_full_ddm_rv_config(), "levy": get_levy_config(), @@ -337,6 +342,7 @@ def get_model_config(): "get_ddm_mic2_multinoise_angle_no_bias_config", "get_ddm_mic2_multinoise_weibull_no_bias_config", "get_poisson_race_config", + "get_addm_config", ] # Validate diff --git a/ssms/config/_modelconfig/addm.py b/ssms/config/_modelconfig/addm.py new file mode 100644 index 0000000..422cbbc --- /dev/null +++ b/ssms/config/_modelconfig/addm.py @@ -0,0 +1,26 @@ +"""ADDM model configuration.""" + +import cssm +from ssms.basic_simulators import boundary_functions as bf + + +def get_addm_config(): + """Get the configuration for the ADDM model.""" + return { + "name": "addm", + "params": ["eta", "kappa", "a", "z", "b", "t"], + "param_bounds": [[0.0, 0.0, -2.5, -2.5, 0.01, 0.01], [3.0, 3.0, 2.5, 2.5, 3.0, 1.0]], + "boundary_name": "constant", + "boundary": bf.constant, + "boundary_params": [], + "n_params": 6, + "default_params": [0.5, 0.5, 2.0, 0.5, 0.2, 0.1], + "nchoices": 2, + "choices": [-1, 1], + "n_particles": 1, + "simulator": cssm.addm, + "parameter_transforms": { + "sampling": [], + "simulation": [], + }, + }