Skip to content

Instantly share code, notes, and snippets.

@AbdealiLoKo

AbdealiLoKo/0-demo-jit.ipynb

Last active August 19, 2023 19:51
Show Gist options
  • Save AbdealiLoKo/c06045e94867f59ac1ed19cc41fe812b to your computer and use it in GitHub Desktop.
Save AbdealiLoKo/c06045e94867f59ac1ed19cc41fe812b to your computer and use it in GitHub Desktop.
Download ZIP
JIT In Python
Display the source blob
Display the rendered blob
Raw
0-demo-jit.ipynb
{
"cells": [
{
"cell_type": "markdown",
"id": "ac32060c-061a-45fb-aa6d-31fd886cbec4",
"metadata": {
"tags": []
},
"source": [
"# Normal Python"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "c1ce72be-85df-44be-8de7-a210d8a404d2",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:03:38.220427Z",
"iopub.status.busy": "2023-08-19T17:03:38.220176Z",
"iopub.status.idle": "2023-08-19T17:03:38.467495Z",
"shell.execute_reply": "2023-08-19T17:03:38.466632Z",
"shell.execute_reply.started": "2023-08-19T17:03:38.220403Z"
},
"tags": []
},
"outputs": [],
"source": [
"from blackscholes import blackscholes"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "13ab9951-108c-410e-b740-c7f289cef61c",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:03:38.470828Z",
"iopub.status.busy": "2023-08-19T17:03:38.469981Z",
"iopub.status.idle": "2023-08-19T17:03:38.559559Z",
"shell.execute_reply": "2023-08-19T17:03:38.558152Z",
"shell.execute_reply.started": "2023-08-19T17:03:38.470795Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 78.5 ms, sys: 0 ns, total: 78.5 ms\n",
"Wall time: 75.5 ms\n"
]
}
],
"source": [
"# First run\n",
"%time blackscholes(1)"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "4d420f11-6c00-4391-a082-27910f56d247",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:03:38.560551Z",
"iopub.status.busy": "2023-08-19T17:03:38.560374Z",
"iopub.status.idle": "2023-08-19T17:03:38.638099Z",
"shell.execute_reply": "2023-08-19T17:03:38.636722Z",
"shell.execute_reply.started": "2023-08-19T17:03:38.560534Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 68 ms, sys: 0 ns, total: 68 ms\n",
"Wall time: 65.7 ms\n"
]
}
],
"source": [
"# Second run\n",
"%time blackscholes(2)"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "91435c24-7fc4-4fb2-96f9-dd142b7c17c6",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:09:21.121527Z",
"iopub.status.busy": "2023-08-19T16:09:21.121248Z",
"iopub.status.idle": "2023-08-19T16:09:25.556970Z",
"shell.execute_reply": "2023-08-19T16:09:25.553749Z",
"shell.execute_reply.started": "2023-08-19T16:09:21.121506Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"53.9 ms ± 931 µs per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
]
}
],
"source": [
"%timeit blackscholes(3)"
]
},
{
"cell_type": "markdown",
"id": "3253f0ce-ceff-4e2f-a7b7-125558897ba5",
"metadata": {
"tags": []
},
"source": [
"# Let's try it with numba"
]
},
{
"cell_type": "code",
"execution_count": 17,
"id": "bc93b705-b34b-4081-a0d0-076b917c8cd4",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T18:40:59.630269Z",
"iopub.status.busy": "2023-08-19T18:40:59.629233Z",
"iopub.status.idle": "2023-08-19T18:40:59.815318Z",
"shell.execute_reply": "2023-08-19T18:40:59.811746Z",
"shell.execute_reply.started": "2023-08-19T18:40:59.630220Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\u001b[0;31m*** blackscholes.py\t2023-08-19 21:39:06.344570844 +0530\u001b[0;0m\n",
"\u001b[0;32m--- blackscholes_numba.py\t2023-08-19 22:31:49.034569807 +0530\u001b[0;0m\n",
"\u001b[0;33m***************\u001b[0;0m\n",
"\u001b[0;33m*** 4,9 ****\u001b[0;0m\n",
"\u001b[0;33m--- 4,10 ----\u001b[0;0m\n",
"\u001b[0;30m \u001b[0;0m\n",
"\u001b[0;30m import math\u001b[0;0m\n",
"\u001b[0;30m import numpy as np\u001b[0;0m\n",
"\u001b[0;32m+ from numba import jit\u001b[0;0m\n",
"\u001b[0;30m \u001b[0;0m\n",
"\u001b[0;30m # Taken from numba.tests.test_blackscholes\u001b[0;0m\n",
"\u001b[0;30m N = 16384\u001b[0;0m\n",
"\u001b[0;33m***************\u001b[0;0m\n",
"\u001b[0;33m*** 19,24 ****\u001b[0;0m\n",
"\u001b[0;33m--- 20,26 ----\u001b[0;0m\n",
"\u001b[0;30m RSQRT2PI = 0.39894228040143267793994605993438\u001b[0;0m\n",
"\u001b[0;30m \u001b[0;0m\n",
"\u001b[0;30m \u001b[0;0m\n",
"\u001b[0;32m+ @jit(nopython=True)\u001b[0;0m\n",
"\u001b[0;30m def cnd(d: float):\u001b[0;0m\n",
"\u001b[0;30m K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\u001b[0;0m\n",
"\u001b[0;30m ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *\u001b[0;0m\n",
"\u001b[0;33m***************\u001b[0;0m\n",
"\u001b[0;33m*** 28,33 ****\u001b[0;0m\n",
"\u001b[0;33m--- 30,36 ----\u001b[0;0m\n",
"\u001b[0;30m return ret_val\u001b[0;0m\n",
"\u001b[0;30m \u001b[0;0m\n",
"\u001b[0;30m \u001b[0;0m\n",
"\u001b[0;32m+ @jit(nopython=True)\u001b[0;0m\n",
"\u001b[0;30m def blackscholes(seed: int):\u001b[0;0m\n",
"\u001b[0;30m R = RISKFREE\u001b[0;0m\n",
"\u001b[0;30m V = VOLATILITY\u001b[0;0m\n"
]
}
],
"source": [
"!colordiff -c blackscholes.py blackscholes_numba.py"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "26089362-0f4c-4731-a55c-175bfc4df14f",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:12:50.984314Z",
"iopub.status.busy": "2023-08-19T16:12:50.983830Z",
"iopub.status.idle": "2023-08-19T16:12:50.993401Z",
"shell.execute_reply": "2023-08-19T16:12:50.991996Z",
"shell.execute_reply.started": "2023-08-19T16:12:50.984292Z"
},
"tags": []
},
"outputs": [],
"source": [
"from blackscholes_numba import blackscholes as blackscholes_numba"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "43379b9c-e779-40a5-b4ef-d09d46084198",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:12:51.600435Z",
"iopub.status.busy": "2023-08-19T16:12:51.600175Z",
"iopub.status.idle": "2023-08-19T16:12:52.299719Z",
"shell.execute_reply": "2023-08-19T16:12:52.298746Z",
"shell.execute_reply.started": "2023-08-19T16:12:51.600414Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 672 ms, sys: 20.8 ms, total: 693 ms\n",
"Wall time: 690 ms\n"
]
}
],
"source": [
"# First run\n",
"%time blackscholes_numba(1)"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "4c77f462-0adf-4f44-895b-7449f08a622b",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:16:20.238278Z",
"iopub.status.busy": "2023-08-19T16:16:20.237978Z",
"iopub.status.idle": "2023-08-19T16:16:20.250257Z",
"shell.execute_reply": "2023-08-19T16:16:20.248748Z",
"shell.execute_reply.started": "2023-08-19T16:16:20.238257Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 987 µs, sys: 52 µs, total: 1.04 ms\n",
"Wall time: 1.04 ms\n"
]
}
],
"source": [
"# Second run\n",
"%time blackscholes_numba(2)"
]
},
{
"cell_type": "code",
"execution_count": 7,
"id": "110c8428-212c-43bf-b7dc-4a044bd619fc",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:12:56.671003Z",
"iopub.status.busy": "2023-08-19T16:12:56.670671Z",
"iopub.status.idle": "2023-08-19T16:13:06.046293Z",
"shell.execute_reply": "2023-08-19T16:13:06.045060Z",
"shell.execute_reply.started": "2023-08-19T16:12:56.670983Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"1.16 ms ± 52.3 µs per loop (mean ± std. dev. of 7 runs, 1000 loops each)\n"
]
}
],
"source": [
"%timeit blackscholes_numba(3)"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "cf47e7b8-2ecb-45cc-b617-ae2f1675c90d",
"metadata": {},
"outputs": [],
"source": [
"blackscholes_numba.i"
]
},
{
"cell_type": "code",
"execution_count": 8,
"id": "9f42683d-b338-4461-9358-4458f90e42fc",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:13:06.051033Z",
"iopub.status.busy": "2023-08-19T16:13:06.050296Z",
"iopub.status.idle": "2023-08-19T16:13:06.105510Z",
"shell.execute_reply": "2023-08-19T16:13:06.104565Z",
"shell.execute_reply.started": "2023-08-19T16:13:06.051004Z"
},
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"dict_keys([(int64,)])"
]
},
"execution_count": 8,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# numba has generated some assembly code for us\n",
"blackscholes_numba.inspect_asm().keys()"
]
},
{
"cell_type": "code",
"execution_count": 21,
"id": "ed6aab1a-4dde-48e3-bfb7-8fdb3a127fe8",
"metadata": {
"collapsed": true,
"execution": {
"iopub.execute_input": "2023-08-19T16:15:20.848691Z",
"iopub.status.busy": "2023-08-19T16:15:20.848044Z",
"iopub.status.idle": "2023-08-19T16:15:20.893481Z",
"shell.execute_reply": "2023-08-19T16:15:20.892506Z",
"shell.execute_reply.started": "2023-08-19T16:15:20.848665Z"
},
"jupyter": {
"outputs_hidden": true
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\t.text\n",
"\t.file\t\"<string>\"\n",
"\t.section\t.rodata.cst8,\"aM\",@progbits,8\n",
"\t.p2align\t3\n",
".LCPI0_0:\n",
"\t.quad\t0x4190000000000000\n",
".LCPI0_1:\n",
"\t.quad\t0x3ca0000000000000\n",
".LCPI0_2:\n",
"\t.quad\t0x4039000000000000\n",
".LCPI0_3:\n",
"\t.quad\t0x4014000000000000\n",
".LCPI0_4:\n",
"\t.quad\t0x4058c00000000000\n",
".LCPI0_5:\n",
"\t.quad\t0x3ff0000000000000\n",
".LCPI0_6:\n",
"\t.quad\t0x4023800000000000\n",
".LCPI0_7:\n",
"\t.quad\t0x3fd0000000000000\n",
".LCPI0_8:\n",
"\t.quad\t0x3fd3333333333333\n",
".LCPI0_9:\n",
"\t.quad\t0x3fb0a3d70a3d70a4\n",
".LCPI0_11:\n",
"\t.quad\t0x3fcda6711871100e\n",
".LCPI0_12:\n",
"\t.quad\t0xbfe0000000000000\n",
".LCPI0_13:\n",
"\t.quad\t0x3fd9884533d43651\n",
".LCPI0_14:\n",
"\t.quad\t0x3ff548cdd6f42943\n",
".LCPI0_15:\n",
"\t.quad\t0xbffd23dd4ef278d0\n",
".LCPI0_16:\n",
"\t.quad\t0x3ffc80ef025f5e68\n",
".LCPI0_17:\n",
"\t.quad\t0xbfd6d1f0e5a8325b\n",
".LCPI0_18:\n",
"\t.quad\t0x3fd470bf3a92f8ec\n",
".LCPI0_19:\n",
"\t.quad\t0xbf947ae147ae147b\n",
"\t.section\t.rodata.cst16,\"aM\",@progbits,16\n",
"\t.p2align\t4\n",
".LCPI0_10:\n",
"\t.quad\t0x7fffffffffffffff\n",
"\t.quad\t0x7fffffffffffffff\n",
"\t.text\n",
"\t.globl\t_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\n",
"\t.p2align\t4, 0x90\n",
"\t.type\t_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx,@function\n",
"_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx:\n",
"\t.cfi_startproc\n",
"\tpushq\t%rbp\n",
"\t.cfi_def_cfa_offset 16\n",
"\tpushq\t%r15\n",
"\t.cfi_def_cfa_offset 24\n",
"\tpushq\t%r14\n",
"\t.cfi_def_cfa_offset 32\n",
"\tpushq\t%r13\n",
"\t.cfi_def_cfa_offset 40\n",
"\tpushq\t%r12\n",
"\t.cfi_def_cfa_offset 48\n",
"\tpushq\t%rbx\n",
"\t.cfi_def_cfa_offset 56\n",
"\tsubq\t$264, %rsp\n",
"\t.cfi_def_cfa_offset 320\n",
"\t.cfi_offset %rbx, -56\n",
"\t.cfi_offset %r12, -48\n",
"\t.cfi_offset %r13, -40\n",
"\t.cfi_offset %r14, -32\n",
"\t.cfi_offset %r15, -24\n",
"\t.cfi_offset %rbp, -16\n",
"\tmovq\t%rdx, %rbp\n",
"\tmovq\t%rsi, 56(%rsp)\n",
"\tmovq\t%rdi, %r15\n",
"\tmovabsq\t$numba_get_np_random_state, %rax\n",
"\tcallq\t*%rax\n",
"\tmovq\t%rax, %r14\n",
"\tmovabsq\t$numba_rnd_init, %rax\n",
"\tmovq\t%r14, %rdi\n",
"\tmovl\t%ebp, %esi\n",
"\tcallq\t*%rax\n",
"\tmovabsq\t$NRT_MemInfo_alloc_safe_aligned, %rax\n",
"\tmovl\t$131072, %edi\n",
"\tmovl\t$32, %esi\n",
"\tcallq\t*%rax\n",
"\tmovabsq\t$.const.picklebuf.139903554669456, %rbx\n",
"\ttestq\t%rax, %rax\n",
"\tje\t.LBB0_33\n",
"\tmovq\t%rax, %r12\n",
"\tmovq\t24(%rax), %r13\n",
"\txorl\t%ebp, %ebp\n",
"\tmovabsq\t$.LCPI0_0, %rax\n",
"\tvmovsd\t(%rax), %xmm2\n",
"\tmovabsq\t$.LCPI0_1, %rax\n",
"\tvmovsd\t(%rax), %xmm3\n",
"\tmovabsq\t$.LCPI0_2, %rax\n",
"\tvmovsd\t(%rax), %xmm4\n",
"\tmovabsq\t$.LCPI0_3, %rax\n",
"\tvmovsd\t(%rax), %xmm5\n",
"\tvmovsd\t%xmm2, (%rsp)\n",
"\tvmovsd\t%xmm3, 16(%rsp)\n",
"\t.p2align\t4, 0x90\n",
".LBB0_2:\n",
"\tmovl\t(%r14), %ecx\n",
"\tcmpl\t$624, %ecx\n",
"\tjae\t.LBB0_5\n",
".LBB0_3:\n",
"\tmovl\t%ecx, %eax\n",
"\tmovl\t4(%r14,%rax,4), %edx\n",
"\tleal\t1(%rcx), %eax\n",
"\tmovl\t%eax, (%r14)\n",
"\tmovl\t%edx, %esi\n",
"\tshrl\t$11, %esi\n",
"\txorl\t%edx, %esi\n",
"\tmovl\t%esi, %edx\n",
"\tshll\t$7, %edx\n",
"\tandl\t$-1658038656, %edx\n",
"\txorl\t%esi, %edx\n",
"\tmovl\t%edx, %ebx\n",
"\tshll\t$15, %ebx\n",
"\tandl\t$-272236544, %ebx\n",
"\txorl\t%edx, %ebx\n",
"\tcmpl\t$623, %ecx\n",
"\tjae\t.LBB0_6\n",
".LBB0_4:\n",
"\tmovl\t%ebx, %ecx\n",
"\tshrl\t$23, %ecx\n",
"\tshrl\t$5, %ebx\n",
"\txorl\t%ecx, %ebx\n",
"\tmovl\t%eax, %ecx\n",
"\tmovl\t4(%r14,%rcx,4), %ecx\n",
"\tincl\t%eax\n",
"\tmovl\t%eax, (%r14)\n",
"\tmovl\t%ecx, %eax\n",
"\tshrl\t$11, %eax\n",
"\txorl\t%ecx, %eax\n",
"\tmovl\t%eax, %ecx\n",
"\tshll\t$7, %ecx\n",
"\tandl\t$-1658038656, %ecx\n",
"\txorl\t%eax, %ecx\n",
"\tmovl\t%ecx, %eax\n",
"\tshll\t$15, %eax\n",
"\tandl\t$-272236544, %eax\n",
"\txorl\t%ecx, %eax\n",
"\tmovl\t%eax, %ecx\n",
"\tshrl\t$24, %ecx\n",
"\tshrl\t$6, %eax\n",
"\tvcvtsi2sd\t%ebx, %xmm6, %xmm0\n",
"\txorl\t%ecx, %eax\n",
"\tvcvtsi2sd\t%eax, %xmm6, %xmm1\n",
"\tvmulsd\t%xmm2, %xmm0, %xmm0\n",
"\tvaddsd\t%xmm1, %xmm0, %xmm0\n",
"\tvmulsd\t%xmm3, %xmm0, %xmm0\n",
"\tvmulsd\t%xmm4, %xmm0, %xmm0\n",
"\tvaddsd\t%xmm5, %xmm0, %xmm0\n",
"\tvmovsd\t%xmm0, (%r13,%rbp,8)\n",
"\tincq\t%rbp\n",
"\tcmpq\t$16384, %rbp\n",
"\tjne\t.LBB0_2\n",
"\tjmp\t.LBB0_7\n",
".LBB0_5:\n",
"\tmovq\t%r14, %rdi\n",
"\tmovabsq\t$numba_rnd_shuffle, %rax\n",
"\tvmovsd\t%xmm4, 8(%rsp)\n",
"\tvmovsd\t%xmm5, 32(%rsp)\n",
"\tcallq\t*%rax\n",
"\tvmovsd\t32(%rsp), %xmm5\n",
"\tvmovsd\t8(%rsp), %xmm4\n",
"\tvmovsd\t16(%rsp), %xmm3\n",
"\tvmovsd\t(%rsp), %xmm2\n",
"\tmovl\t$0, (%r14)\n",
"\txorl\t%ecx, %ecx\n",
"\tjmp\t.LBB0_3\n",
".LBB0_6:\n",
"\tmovq\t%r14, %rdi\n",
"\tmovabsq\t$numba_rnd_shuffle, %rax\n",
"\tvmovsd\t%xmm4, 8(%rsp)\n",
"\tvmovsd\t%xmm5, 32(%rsp)\n",
"\tcallq\t*%rax\n",
"\tvmovsd\t32(%rsp), %xmm5\n",
"\tvmovsd\t8(%rsp), %xmm4\n",
"\tvmovsd\t16(%rsp), %xmm3\n",
"\tvmovsd\t(%rsp), %xmm2\n",
"\tmovl\t$0, (%r14)\n",
"\txorl\t%eax, %eax\n",
"\tjmp\t.LBB0_4\n",
".LBB0_7:\n",
"\tmovl\t$131072, %edi\n",
"\tmovl\t$32, %esi\n",
"\tmovabsq\t$NRT_MemInfo_alloc_safe_aligned, %rax\n",
"\tcallq\t*%rax\n",
"\ttestq\t%rax, %rax\n",
"\tje\t.LBB0_36\n",
"\tmovq\t%r12, 192(%rsp)\n",
"\tmovq\t%rax, 184(%rsp)\n",
"\tmovq\t24(%rax), %r12\n",
"\txorl\t%ebp, %ebp\n",
"\tmovabsq\t$.LCPI0_4, %rax\n",
"\tvmovsd\t(%rax), %xmm5\n",
"\tmovabsq\t$.LCPI0_5, %rax\n",
"\tvmovsd\t(%rax), %xmm2\n",
"\tvmovsd\t%xmm2, 8(%rsp)\n",
"\tvmovsd\t(%rsp), %xmm3\n",
"\tvmovsd\t16(%rsp), %xmm4\n",
"\t.p2align\t4, 0x90\n",
".LBB0_9:\n",
"\tmovl\t(%r14), %ecx\n",
"\tcmpl\t$624, %ecx\n",
"\tjae\t.LBB0_12\n",
".LBB0_10:\n",
"\tmovl\t%ecx, %eax\n",
"\tmovl\t4(%r14,%rax,4), %edx\n",
"\tleal\t1(%rcx), %eax\n",
"\tmovl\t%eax, (%r14)\n",
"\tmovl\t%edx, %esi\n",
"\tshrl\t$11, %esi\n",
"\txorl\t%edx, %esi\n",
"\tmovl\t%esi, %edx\n",
"\tshll\t$7, %edx\n",
"\tandl\t$-1658038656, %edx\n",
"\txorl\t%esi, %edx\n",
"\tmovl\t%edx, %ebx\n",
"\tshll\t$15, %ebx\n",
"\tandl\t$-272236544, %ebx\n",
"\txorl\t%edx, %ebx\n",
"\tcmpl\t$623, %ecx\n",
"\tjae\t.LBB0_13\n",
".LBB0_11:\n",
"\tmovl\t%ebx, %ecx\n",
"\tshrl\t$23, %ecx\n",
"\tshrl\t$5, %ebx\n",
"\txorl\t%ecx, %ebx\n",
"\tmovl\t%eax, %ecx\n",
"\tmovl\t4(%r14,%rcx,4), %ecx\n",
"\tincl\t%eax\n",
"\tmovl\t%eax, (%r14)\n",
"\tmovl\t%ecx, %eax\n",
"\tshrl\t$11, %eax\n",
"\txorl\t%ecx, %eax\n",
"\tmovl\t%eax, %ecx\n",
"\tshll\t$7, %ecx\n",
"\tandl\t$-1658038656, %ecx\n",
"\txorl\t%eax, %ecx\n",
"\tmovl\t%ecx, %eax\n",
"\tshll\t$15, %eax\n",
"\tandl\t$-272236544, %eax\n",
"\txorl\t%ecx, %eax\n",
"\tmovl\t%eax, %ecx\n",
"\tshrl\t$24, %ecx\n",
"\tshrl\t$6, %eax\n",
"\tvcvtsi2sd\t%ebx, %xmm6, %xmm0\n",
"\txorl\t%ecx, %eax\n",
"\tvcvtsi2sd\t%eax, %xmm6, %xmm1\n",
"\tvmulsd\t%xmm3, %xmm0, %xmm0\n",
"\tvaddsd\t%xmm1, %xmm0, %xmm0\n",
"\tvmulsd\t%xmm4, %xmm0, %xmm0\n",
"\tvmulsd\t%xmm5, %xmm0, %xmm0\n",
"\tvaddsd\t%xmm2, %xmm0, %xmm0\n",
"\tvmovsd\t%xmm0, (%r12,%rbp,8)\n",
"\tincq\t%rbp\n",
"\tcmpq\t$16384, %rbp\n",
"\tjne\t.LBB0_9\n",
"\tjmp\t.LBB0_14\n",
".LBB0_12:\n",
"\tmovq\t%r14, %rdi\n",
"\tmovabsq\t$numba_rnd_shuffle, %rax\n",
"\tvmovsd\t%xmm5, 32(%rsp)\n",
"\tcallq\t*%rax\n",
"\tvmovsd\t32(%rsp), %xmm5\n",
"\tvmovsd\t16(%rsp), %xmm4\n",
"\tvmovsd\t(%rsp), %xmm3\n",
"\tvmovsd\t8(%rsp), %xmm2\n",
"\tmovl\t$0, (%r14)\n",
"\txorl\t%ecx, %ecx\n",
"\tjmp\t.LBB0_10\n",
".LBB0_13:\n",
"\tmovq\t%r14, %rdi\n",
"\tmovabsq\t$numba_rnd_shuffle, %rax\n",
"\tvmovsd\t%xmm5, 32(%rsp)\n",
"\tcallq\t*%rax\n",
"\tvmovsd\t32(%rsp), %xmm5\n",
"\tvmovsd\t16(%rsp), %xmm4\n",
"\tvmovsd\t(%rsp), %xmm3\n",
"\tvmovsd\t8(%rsp), %xmm2\n",
"\tmovl\t$0, (%r14)\n",
"\txorl\t%eax, %eax\n",
"\tjmp\t.LBB0_11\n",
".LBB0_14:\n",
"\tmovq\t%r15, 200(%rsp)\n",
"\tmovl\t$131072, %edi\n",
"\tmovl\t$32, %esi\n",
"\tmovabsq\t$NRT_MemInfo_alloc_safe_aligned, %rax\n",
"\tcallq\t*%rax\n",
"\tmovq\t%rax, 64(%rsp)\n",
"\ttestq\t%rax, %rax\n",
"\tmovabsq\t$.const.picklebuf.139903554669456, %rbx\n",
"\tje\t.LBB0_33\n",
"\tmovq\t64(%rsp), %rax\n",
"\tmovq\t24(%rax), %r15\n",
"\txorl\t%ebp, %ebp\n",
"\tmovabsq\t$.LCPI0_6, %rax\n",
"\tvmovsd\t(%rax), %xmm4\n",
"\tmovabsq\t$.LCPI0_7, %rax\n",
"\tvmovsd\t(%rax), %xmm5\n",
"\tvmovsd\t(%rsp), %xmm2\n",
"\tvmovsd\t16(%rsp), %xmm3\n",
"\t.p2align\t4, 0x90\n",
".LBB0_16:\n",
"\tmovl\t(%r14), %ecx\n",
"\tcmpl\t$624, %ecx\n",
"\tjae\t.LBB0_19\n",
".LBB0_17:\n",
"\tmovl\t%ecx, %eax\n",
"\tmovl\t4(%r14,%rax,4), %edx\n",
"\tleal\t1(%rcx), %eax\n",
"\tmovl\t%eax, (%r14)\n",
"\tmovl\t%edx, %esi\n",
"\tshrl\t$11, %esi\n",
"\txorl\t%edx, %esi\n",
"\tmovl\t%esi, %edx\n",
"\tshll\t$7, %edx\n",
"\tandl\t$-1658038656, %edx\n",
"\txorl\t%esi, %edx\n",
"\tmovl\t%edx, %ebx\n",
"\tshll\t$15, %ebx\n",
"\tandl\t$-272236544, %ebx\n",
"\txorl\t%edx, %ebx\n",
"\tcmpl\t$623, %ecx\n",
"\tjae\t.LBB0_20\n",
".LBB0_18:\n",
"\tmovl\t%ebx, %ecx\n",
"\tshrl\t$23, %ecx\n",
"\tshrl\t$5, %ebx\n",
"\txorl\t%ecx, %ebx\n",
"\tmovl\t%eax, %ecx\n",
"\tmovl\t4(%r14,%rcx,4), %ecx\n",
"\tincl\t%eax\n",
"\tmovl\t%eax, (%r14)\n",
"\tmovl\t%ecx, %eax\n",
"\tshrl\t$11, %eax\n",
"\txorl\t%ecx, %eax\n",
"\tmovl\t%eax, %ecx\n",
"\tshll\t$7, %ecx\n",
"\tandl\t$-1658038656, %ecx\n",
"\txorl\t%eax, %ecx\n",
"\tmovl\t%ecx, %eax\n",
"\tshll\t$15, %eax\n",
"\tandl\t$-272236544, %eax\n",
"\txorl\t%ecx, %eax\n",
"\tmovl\t%eax, %ecx\n",
"\tshrl\t$24, %ecx\n",
"\tshrl\t$6, %eax\n",
"\tvcvtsi2sd\t%ebx, %xmm6, %xmm0\n",
"\txorl\t%ecx, %eax\n",
"\tvcvtsi2sd\t%eax, %xmm6, %xmm1\n",
"\tvmulsd\t%xmm2, %xmm0, %xmm0\n",
"\tvaddsd\t%xmm1, %xmm0, %xmm0\n",
"\tvmulsd\t%xmm3, %xmm0, %xmm0\n",
"\tvmulsd\t%xmm4, %xmm0, %xmm0\n",
"\tvaddsd\t%xmm5, %xmm0, %xmm0\n",
"\tvmovsd\t%xmm0, (%r15,%rbp,8)\n",
"\tincq\t%rbp\n",
"\tcmpq\t$16384, %rbp\n",
"\tjne\t.LBB0_16\n",
"\tjmp\t.LBB0_21\n",
".LBB0_19:\n",
"\tmovq\t%r14, %rdi\n",
"\tmovabsq\t$numba_rnd_shuffle, %rax\n",
"\tvmovsd\t%xmm4, 32(%rsp)\n",
"\tvmovsd\t%xmm5, 48(%rsp)\n",
"\tcallq\t*%rax\n",
"\tvmovsd\t48(%rsp), %xmm5\n",
"\tvmovsd\t32(%rsp), %xmm4\n",
"\tvmovsd\t16(%rsp), %xmm3\n",
"\tvmovsd\t(%rsp), %xmm2\n",
"\tmovl\t$0, (%r14)\n",
"\txorl\t%ecx, %ecx\n",
"\tjmp\t.LBB0_17\n",
".LBB0_20:\n",
"\tmovq\t%r14, %rdi\n",
"\tmovabsq\t$numba_rnd_shuffle, %rax\n",
"\tvmovsd\t%xmm4, 32(%rsp)\n",
"\tvmovsd\t%xmm5, 48(%rsp)\n",
"\tcallq\t*%rax\n",
"\tvmovsd\t48(%rsp), %xmm5\n",
"\tvmovsd\t32(%rsp), %xmm4\n",
"\tvmovsd\t16(%rsp), %xmm3\n",
"\tvmovsd\t(%rsp), %xmm2\n",
"\tmovl\t$0, (%r14)\n",
"\txorl\t%eax, %eax\n",
"\tjmp\t.LBB0_18\n",
".LBB0_21:\n",
"\tmovl\t$131072, %edi\n",
"\tmovl\t$32, %esi\n",
"\tmovabsq\t$NRT_MemInfo_alloc_safe_aligned, %rbp\n",
"\tcallq\t*%rbp\n",
"\tmovabsq\t$.const.picklebuf.139903554669456.8, %rbx\n",
"\ttestq\t%rax, %rax\n",
"\tje\t.LBB0_33\n",
"\tmovq\t%rax, 176(%rsp)\n",
"\tmovq\t24(%rax), %rdi\n",
"\tmovabsq\t$memset, %r14\n",
"\tmovl\t$131072, %edx\n",
"\tmovq\t%rdi, 224(%rsp)\n",
"\txorl\t%esi, %esi\n",
"\tcallq\t*%r14\n",
"\tmovl\t$131072, %edi\n",
"\tmovl\t$32, %esi\n",
"\tcallq\t*%rbp\n",
"\ttestq\t%rax, %rax\n",
"\tje\t.LBB0_33\n",
"\tmovq\t%rax, 168(%rsp)\n",
"\tmovq\t24(%rax), %rdi\n",
"\txorl\t%ebx, %ebx\n",
"\tmovl\t$131072, %edx\n",
"\tmovq\t%rdi, 216(%rsp)\n",
"\txorl\t%esi, %esi\n",
"\tcallq\t*%r14\n",
"\tmovabsq\t$.LCPI0_8, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 240(%rsp)\n",
"\tmovabsq\t$.LCPI0_9, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 232(%rsp)\n",
"\tmovabsq\t$.LCPI0_10, %rax\n",
"\tvmovapd\t(%rax), %xmm3\n",
"\tmovabsq\t$.LCPI0_11, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 48(%rsp)\n",
"\tmovabsq\t$.LCPI0_12, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 120(%rsp)\n",
"\tmovabsq\t$exp, %r14\n",
"\tmovabsq\t$.LCPI0_13, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 112(%rsp)\n",
"\tmovabsq\t$.LCPI0_14, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 104(%rsp)\n",
"\tmovabsq\t$.LCPI0_15, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 96(%rsp)\n",
"\tmovabsq\t$.LCPI0_16, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 88(%rsp)\n",
"\tmovabsq\t$.LCPI0_17, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 80(%rsp)\n",
"\tmovabsq\t$.LCPI0_18, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 72(%rsp)\n",
"\tmovabsq\t$.LCPI0_19, %rax\n",
"\tvmovsd\t(%rax), %xmm0\n",
"\tvmovsd\t%xmm0, 208(%rsp)\n",
"\tvmovapd\t%xmm3, 32(%rsp)\n",
"\t.p2align\t4, 0x90\n",
".LBB0_24:\n",
"\tvmovsd\t(%r12,%rbx,8), %xmm1\n",
"\tvxorpd\t%xmm0, %xmm0, %xmm0\n",
"\tvucomisd\t%xmm0, %xmm1\n",
"\tjne\t.LBB0_25\n",
"\tjnp\t.LBB0_30\n",
".LBB0_25:\n",
"\tvmovsd\t(%r15,%rbx,8), %xmm2\n",
"\tvsqrtsd\t%xmm2, %xmm2, %xmm0\n",
"\tvmulsd\t240(%rsp), %xmm0, %xmm4\n",
"\tvxorpd\t%xmm0, %xmm0, %xmm0\n",
"\tvucomisd\t%xmm0, %xmm4\n",
"\tjne\t.LBB0_26\n",
"\tjnp\t.LBB0_30\n",
".LBB0_26:\n",
"\tvmovsd\t(%r13,%rbx,8), %xmm0\n",
"\tvmovsd\t%xmm1, 256(%rsp)\n",
"\tvmovsd\t%xmm0, 248(%rsp)\n",
"\tvdivsd\t%xmm1, %xmm0, %xmm0\n",
"\tmovabsq\t$log, %rax\n",
"\tvmovsd\t%xmm2, (%rsp)\n",
"\tvmovsd\t%xmm4, 16(%rsp)\n",
"\tcallq\t*%rax\n",
"\tvmovsd\t16(%rsp), %xmm5\n",
"\tvmovsd\t8(%rsp), %xmm2\n",
"\tvmovsd\t(%rsp), %xmm1\n",
"\tvmulsd\t232(%rsp), %xmm1, %xmm1\n",
"\tvaddsd\t%xmm0, %xmm1, %xmm0\n",
"\tvdivsd\t%xmm5, %xmm0, %xmm4\n",
"\tvandpd\t32(%rsp), %xmm4, %xmm0\n",
"\tvmovsd\t48(%rsp), %xmm3\n",
"\tvmulsd\t%xmm3, %xmm0, %xmm0\n",
"\tvaddsd\t%xmm2, %xmm0, %xmm0\n",
"\tvxorpd\t%xmm1, %xmm1, %xmm1\n",
"\tvucomisd\t%xmm1, %xmm0\n",
"\tjne\t.LBB0_27\n",
"\tjnp\t.LBB0_32\n",
".LBB0_27:\n",
"\tvsubsd\t%xmm5, %xmm4, %xmm1\n",
"\tvmovapd\t%xmm1, 16(%rsp)\n",
"\tvdivsd\t%xmm0, %xmm2, %xmm0\n",
"\tvmovsd\t%xmm0, 144(%rsp)\n",
"\tvmulsd\t120(%rsp), %xmm4, %xmm0\n",
"\tvmovapd\t%xmm4, 128(%rsp)\n",
"\tvmulsd\t%xmm0, %xmm4, %xmm0\n",
"\tcallq\t*%r14\n",
"\tvmovsd\t144(%rsp), %xmm6\n",
"\tvmovsd\t112(%rsp), %xmm8\n",
"\tvmulsd\t%xmm0, %xmm8, %xmm10\n",
"\tvmovsd\t104(%rsp), %xmm9\n",
"\tvmulsd\t%xmm6, %xmm9, %xmm1\n",
"\tvmovsd\t96(%rsp), %xmm11\n",
"\tvaddsd\t%xmm1, %xmm11, %xmm1\n",
"\tvmulsd\t%xmm1, %xmm6, %xmm1\n",
"\tvmovsd\t88(%rsp), %xmm7\n",
"\tvaddsd\t%xmm7, %xmm1, %xmm1\n",
"\tvmulsd\t%xmm1, %xmm6, %xmm1\n",
"\tvmovsd\t80(%rsp), %xmm4\n",
"\tvaddsd\t%xmm4, %xmm1, %xmm1\n",
"\tvmulsd\t%xmm1, %xmm6, %xmm1\n",
"\tvmovsd\t72(%rsp), %xmm5\n",
"\tvaddsd\t%xmm5, %xmm1, %xmm2\n",
"\tvmovapd\t16(%rsp), %xmm0\n",
"\tvmovapd\t%xmm0, %xmm12\n",
"\tvandpd\t32(%rsp), %xmm0, %xmm1\n",
"\tvmulsd\t48(%rsp), %xmm1, %xmm1\n",
"\tvmovsd\t8(%rsp), %xmm3\n",
"\tvmovapd\t%xmm3, %xmm0\n",
"\tvaddsd\t%xmm3, %xmm1, %xmm1\n",
"\tvxorpd\t%xmm3, %xmm3, %xmm3\n",
"\tvucomisd\t%xmm3, %xmm1\n",
"\tjne\t.LBB0_28\n",
"\tjnp\t.LBB0_32\n",
".LBB0_28:\n",
"\tleaq\t1(%rbx), %rbp\n",
"\tvmulsd\t%xmm2, %xmm6, %xmm2\n",
"\tvmulsd\t%xmm2, %xmm10, %xmm2\n",
"\tvmovapd\t%xmm0, %xmm3\n",
"\tvsubsd\t%xmm2, %xmm0, %xmm0\n",
"\tvxorpd\t%xmm6, %xmm6, %xmm6\n",
"\tvcmpltsd\t128(%rsp), %xmm6, %k1\n",
"\tvmovsd\t%xmm0, %xmm2, %xmm2 {%k1}\n",
"\tvmovapd\t%xmm2, 144(%rsp)\n",
"\tvdivsd\t%xmm1, %xmm3, %xmm0\n",
"\tvmovsd\t%xmm0, 128(%rsp)\n",
"\tvmulsd\t120(%rsp), %xmm12, %xmm0\n",
"\tvmulsd\t%xmm0, %xmm12, %xmm0\n",
"\tcallq\t*%r14\n",
"\tvmulsd\t112(%rsp), %xmm0, %xmm0\n",
"\tvmovsd\t128(%rsp), %xmm2\n",
"\tvmulsd\t104(%rsp), %xmm2, %xmm1\n",
"\tvaddsd\t96(%rsp), %xmm1, %xmm1\n",
"\tvmulsd\t%xmm1, %xmm2, %xmm1\n",
"\tvaddsd\t88(%rsp), %xmm1, %xmm1\n",
"\tvmulsd\t%xmm1, %xmm2, %xmm1\n",
"\tvaddsd\t80(%rsp), %xmm1, %xmm1\n",
"\tvmulsd\t%xmm1, %xmm2, %xmm1\n",
"\tvaddsd\t72(%rsp), %xmm1, %xmm1\n",
"\tvmulsd\t%xmm1, %xmm2, %xmm1\n",
"\tvmulsd\t%xmm1, %xmm0, %xmm2\n",
"\tvmovsd\t8(%rsp), %xmm0\n",
"\tvsubsd\t%xmm2, %xmm0, %xmm0\n",
"\tvxorpd\t%xmm1, %xmm1, %xmm1\n",
"\tvcmpltsd\t16(%rsp), %xmm1, %k1\n",
"\tvmovsd\t%xmm0, %xmm2, %xmm2 {%k1}\n",
"\tvmovapd\t%xmm2, 16(%rsp)\n",
"\tvmovsd\t(%rsp), %xmm0\n",
"\tvmulsd\t208(%rsp), %xmm0, %xmm0\n",
"\tcallq\t*%r14\n",
"\tvmovapd\t144(%rsp), %xmm4\n",
"\tvmulsd\t248(%rsp), %xmm4, %xmm1\n",
"\tvmulsd\t256(%rsp), %xmm0, %xmm2\n",
"\tvmovapd\t16(%rsp), %xmm5\n",
"\tvmulsd\t%xmm5, %xmm2, %xmm2\n",
"\tvsubsd\t%xmm2, %xmm1, %xmm1\n",
"\tmovq\t224(%rsp), %rax\n",
"\tvmovsd\t%xmm1, (%rax,%rbx,8)\n",
"\tvmulsd\t(%r12,%rbx,8), %xmm0, %xmm0\n",
"\tvmovsd\t8(%rsp), %xmm2\n",
"\tvsubsd\t%xmm5, %xmm2, %xmm1\n",
"\tvmulsd\t%xmm0, %xmm1, %xmm0\n",
"\tvsubsd\t%xmm4, %xmm2, %xmm1\n",
"\tvmulsd\t(%r13,%rbx,8), %xmm1, %xmm1\n",
"\tvsubsd\t%xmm1, %xmm0, %xmm0\n",
"\tmovq\t216(%rsp), %rax\n",
"\tvmovsd\t%xmm0, (%rax,%rbx,8)\n",
"\tmovq\t%rbp, %rbx\n",
"\tcmpq\t$16384, %rbp\n",
"\tjne\t.LBB0_24\n",
"\tmovabsq\t$NRT_decref, %rbx\n",
"\tmovq\t168(%rsp), %rdi\n",
"\tcallq\t*%rbx\n",
"\tmovq\t176(%rsp), %rdi\n",
"\tcallq\t*%rbx\n",
"\tmovq\t184(%rsp), %rdi\n",
"\tcallq\t*%rbx\n",
"\tmovq\t64(%rsp), %rdi\n",
"\tcallq\t*%rbx\n",
"\tmovq\t192(%rsp), %rdi\n",
"\tcallq\t*%rbx\n",
"\tmovq\t200(%rsp), %rax\n",
"\tmovq\t$0, (%rax)\n",
"\txorl\t%eax, %eax\n",
"\tjmp\t.LBB0_35\n",
".LBB0_30:\n",
"\tmovabsq\t$.const.picklebuf.139903555000832, %rax\n",
"\tmovq\t56(%rsp), %rcx\n",
"\tmovq\t%rax, (%rcx)\n",
"\tjmp\t.LBB0_34\n",
".LBB0_32:\n",
"\tmovabsq\t$.const.picklebuf.139903552230016, %rbx\n",
".LBB0_33:\n",
"\tmovq\t56(%rsp), %rax\n",
"\tmovq\t%rbx, (%rax)\n",
".LBB0_34:\n",
"\tmovl\t$1, %eax\n",
".LBB0_35:\n",
"\taddq\t$264, %rsp\n",
"\t.cfi_def_cfa_offset 56\n",
"\tpopq\t%rbx\n",
"\t.cfi_def_cfa_offset 48\n",
"\tpopq\t%r12\n",
"\t.cfi_def_cfa_offset 40\n",
"\tpopq\t%r13\n",
"\t.cfi_def_cfa_offset 32\n",
"\tpopq\t%r14\n",
"\t.cfi_def_cfa_offset 24\n",
"\tpopq\t%r15\n",
"\t.cfi_def_cfa_offset 16\n",
"\tpopq\t%rbp\n",
"\t.cfi_def_cfa_offset 8\n",
"\tretq\n",
".LBB0_36:\n",
"\t.cfi_def_cfa_offset 320\n",
"\tmovabsq\t$.const.picklebuf.139903554669456, %rbx\n",
"\tjmp\t.LBB0_33\n",
".Lfunc_end0:\n",
"\t.size\t_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx, .Lfunc_end0-_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\n",
"\t.cfi_endproc\n",
"\n",
"\t.globl\t_ZN7cpython18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\n",
"\t.p2align\t4, 0x90\n",
"\t.type\t_ZN7cpython18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx,@function\n",
"_ZN7cpython18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx:\n",
"\t.cfi_startproc\n",
"\tpushq\t%r14\n",
"\t.cfi_def_cfa_offset 16\n",
"\tpushq\t%rbx\n",
"\t.cfi_def_cfa_offset 24\n",
"\tsubq\t$24, %rsp\n",
"\t.cfi_def_cfa_offset 48\n",
"\t.cfi_offset %rbx, -24\n",
"\t.cfi_offset %r14, -16\n",
"\tmovq\t%rsi, %rdi\n",
"\tmovabsq\t$.const.blackscholes, %rsi\n",
"\tmovabsq\t$PyArg_UnpackTuple, %rbx\n",
"\tleaq\t16(%rsp), %r8\n",
"\tmovl\t$1, %edx\n",
"\tmovl\t$1, %ecx\n",
"\txorl\t%eax, %eax\n",
"\tcallq\t*%rbx\n",
"\tmovq\t$0, 8(%rsp)\n",
"\tmovq\t$0, (%rsp)\n",
"\ttestl\t%eax, %eax\n",
"\tje\t.LBB1_1\n",
"\tmovabsq\t$_ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx, %rax\n",
"\tcmpq\t$0, (%rax)\n",
"\tje\t.LBB1_4\n",
"\tmovq\t16(%rsp), %rdi\n",
"\tmovabsq\t$PyNumber_Long, %rax\n",
"\tcallq\t*%rax\n",
"\ttestq\t%rax, %rax\n",
"\tje\t.LBB1_7\n",
"\tmovq\t%rax, %rbx\n",
"\tmovabsq\t$PyLong_AsLongLong, %rax\n",
"\tmovq\t%rbx, %rdi\n",
"\tcallq\t*%rax\n",
"\tmovq\t%rax, %r14\n",
"\tmovabsq\t$Py_DecRef, %rax\n",
"\tmovq\t%rbx, %rdi\n",
"\tcallq\t*%rax\n",
"\tmovabsq\t$PyErr_Occurred, %rax\n",
"\tcallq\t*%rax\n",
"\ttestq\t%rax, %rax\n",
"\tjne\t.LBB1_1\n",
".LBB1_10:\n",
"\tmovq\t$0, 8(%rsp)\n",
"\tmovabsq\t$_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx, %rax\n",
"\tleaq\t8(%rsp), %rdi\n",
"\tmovq\t%rsp, %rsi\n",
"\tmovq\t%r14, %rdx\n",
"\tcallq\t*%rax\n",
"\ttestl\t%eax, %eax\n",
"\tje\t.LBB1_12\n",
"\tcmpl\t$-2, %eax\n",
"\tjne\t.LBB1_13\n",
".LBB1_12:\n",
"\tmovabsq\t$_Py_NoneStruct, %rbx\n",
"\tmovabsq\t$Py_IncRef, %rax\n",
"\tmovq\t%rbx, %rdi\n",
"\tcallq\t*%rax\n",
"\tmovq\t%rbx, %rax\n",
"\taddq\t$24, %rsp\n",
"\t.cfi_def_cfa_offset 24\n",
"\tpopq\t%rbx\n",
"\t.cfi_def_cfa_offset 16\n",
"\tpopq\t%r14\n",
"\t.cfi_def_cfa_offset 8\n",
"\tretq\n",
".LBB1_13:\n",
"\t.cfi_def_cfa_offset 48\n",
"\ttestl\t%eax, %eax\n",
"\tjle\t.LBB1_16\n",
"\tmovq\t(%rsp), %rbx\n",
"\tmovabsq\t$PyErr_Clear, %rax\n",
"\tcallq\t*%rax\n",
"\tmovq\t16(%rbx), %rdx\n",
"\tmovl\t8(%rbx), %esi\n",
"\tmovq\t(%rbx), %rdi\n",
"\tmovabsq\t$numba_unpickle, %rax\n",
"\tcallq\t*%rax\n",
"\ttestq\t%rax, %rax\n",
"\tje\t.LBB1_1\n",
"\tmovabsq\t$numba_do_raise, %rcx\n",
"\tmovq\t%rax, %rdi\n",
"\tcallq\t*%rcx\n",
"\tjmp\t.LBB1_1\n",
".LBB1_16:\n",
"\tmovabsq\t$PyExc_SystemError, %rdi\n",
"\tmovabsq\t$\".const.unknown error when calling native function\", %rsi\n",
".LBB1_5:\n",
"\tmovabsq\t$PyErr_SetString, %rax\n",
"\tcallq\t*%rax\n",
".LBB1_1:\n",
"\txorl\t%eax, %eax\n",
"\taddq\t$24, %rsp\n",
"\t.cfi_def_cfa_offset 24\n",
"\tpopq\t%rbx\n",
"\t.cfi_def_cfa_offset 16\n",
"\tpopq\t%r14\n",
"\t.cfi_def_cfa_offset 8\n",
"\tretq\n",
".LBB1_4:\n",
"\t.cfi_def_cfa_offset 48\n",
"\tmovabsq\t$PyExc_RuntimeError, %rdi\n",
"\tmovabsq\t$\".const.missing Environment: _ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\", %rsi\n",
"\tjmp\t.LBB1_5\n",
".LBB1_7:\n",
"\txorl\t%r14d, %r14d\n",
"\tmovabsq\t$PyErr_Occurred, %rax\n",
"\tcallq\t*%rax\n",
"\ttestq\t%rax, %rax\n",
"\tje\t.LBB1_10\n",
"\tjmp\t.LBB1_1\n",
".Lfunc_end1:\n",
"\t.size\t_ZN7cpython18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx, .Lfunc_end1-_ZN7cpython18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\n",
"\t.cfi_endproc\n",
"\n",
"\t.globl\tcfunc._ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\n",
"\t.p2align\t4, 0x90\n",
"\t.type\tcfunc._ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx,@function\n",
"cfunc._ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx:\n",
"\t.cfi_startproc\n",
"\tpushq\t%rbp\n",
"\t.cfi_def_cfa_offset 16\n",
"\tpushq\t%r14\n",
"\t.cfi_def_cfa_offset 24\n",
"\tpushq\t%rbx\n",
"\t.cfi_def_cfa_offset 32\n",
"\tsubq\t$32, %rsp\n",
"\t.cfi_def_cfa_offset 64\n",
"\t.cfi_offset %rbx, -32\n",
"\t.cfi_offset %r14, -24\n",
"\t.cfi_offset %rbp, -16\n",
"\tmovq\t%rdi, %rdx\n",
"\tmovq\t$0, 24(%rsp)\n",
"\tmovq\t$0, 16(%rsp)\n",
"\tmovabsq\t$_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx, %rax\n",
"\tleaq\t24(%rsp), %rdi\n",
"\tleaq\t16(%rsp), %rsi\n",
"\tcallq\t*%rax\n",
"\tmovq\t16(%rsp), %rbx\n",
"\tmovq\t24(%rsp), %r14\n",
"\tmovl\t$0, 12(%rsp)\n",
"\ttestl\t%eax, %eax\n",
"\tjne\t.LBB2_1\n",
".LBB2_4:\n",
"\tmovq\t%r14, %rax\n",
"\taddq\t$32, %rsp\n",
"\t.cfi_def_cfa_offset 32\n",
"\tpopq\t%rbx\n",
"\t.cfi_def_cfa_offset 24\n",
"\tpopq\t%r14\n",
"\t.cfi_def_cfa_offset 16\n",
"\tpopq\t%rbp\n",
"\t.cfi_def_cfa_offset 8\n",
"\tretq\n",
".LBB2_1:\n",
"\t.cfi_def_cfa_offset 64\n",
"\tmovl\t%eax, %ebp\n",
"\tmovabsq\t$numba_gil_ensure, %rax\n",
"\tleaq\t12(%rsp), %rdi\n",
"\tcallq\t*%rax\n",
"\ttestl\t%ebp, %ebp\n",
"\tjle\t.LBB2_6\n",
"\tmovabsq\t$PyErr_Clear, %rax\n",
"\tcallq\t*%rax\n",
"\tmovq\t16(%rbx), %rdx\n",
"\tmovl\t8(%rbx), %esi\n",
"\tmovq\t(%rbx), %rdi\n",
"\tmovabsq\t$numba_unpickle, %rax\n",
"\tcallq\t*%rax\n",
"\ttestq\t%rax, %rax\n",
"\tje\t.LBB2_3\n",
"\tmovabsq\t$numba_do_raise, %rcx\n",
"\tmovq\t%rax, %rdi\n",
"\tcallq\t*%rcx\n",
"\tjmp\t.LBB2_3\n",
".LBB2_6:\n",
"\tmovabsq\t$PyExc_SystemError, %rdi\n",
"\tmovabsq\t$\".const.unknown error when calling native function.1\", %rsi\n",
"\tmovabsq\t$PyErr_SetString, %rax\n",
"\tcallq\t*%rax\n",
".LBB2_3:\n",
"\tmovabsq\t$\".const.<numba.core.cpu.CPUContext object at 0x7f3dd58009d0>\", %rdi\n",
"\tmovabsq\t$PyUnicode_FromString, %rax\n",
"\tcallq\t*%rax\n",
"\tmovq\t%rax, %rbp\n",
"\tmovabsq\t$PyErr_WriteUnraisable, %rax\n",
"\tmovq\t%rbp, %rdi\n",
"\tcallq\t*%rax\n",
"\tmovabsq\t$Py_DecRef, %rax\n",
"\tmovq\t%rbp, %rdi\n",
"\tcallq\t*%rax\n",
"\tmovabsq\t$numba_gil_release, %rax\n",
"\tleaq\t12(%rsp), %rdi\n",
"\tcallq\t*%rax\n",
"\tjmp\t.LBB2_4\n",
".Lfunc_end2:\n",
"\t.size\tcfunc._ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx, .Lfunc_end2-cfunc._ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\n",
"\t.cfi_endproc\n",
"\n",
"\t.weak\tNRT_decref\n",
"\t.p2align\t4, 0x90\n",
"\t.type\tNRT_decref,@function\n",
"NRT_decref:\n",
"\t.cfi_startproc\n",
"\ttestq\t%rdi, %rdi\n",
"\tje\t.LBB3_2\n",
"\t#MEMBARRIER\n",
"\tlock\t\tdecq\t(%rdi)\n",
"\tje\t.LBB3_3\n",
".LBB3_2:\n",
"\tretq\n",
".LBB3_3:\n",
"\t#MEMBARRIER\n",
"\tmovabsq\t$NRT_MemInfo_call_dtor, %rax\n",
"\tjmpq\t*%rax\n",
".Lfunc_end3:\n",
"\t.size\tNRT_decref, .Lfunc_end3-NRT_decref\n",
"\t.cfi_endproc\n",
"\n",
"\t.type\t_ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx,@object\n",
"\t.comm\t_ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx,8,8\n",
"\t.type\t.const.picklebuf.139903555000832,@object\n",
"\t.section\t.rodata,\"a\",@progbits\n",
"\t.p2align\t4\n",
".const.picklebuf.139903555000832:\n",
"\t.quad\t.const.pickledata.139903555000832\n",
"\t.long\t69\n",
"\t.zero\t4\n",
"\t.quad\t.const.pickledata.139903555000832.sha1\n",
"\t.size\t.const.picklebuf.139903555000832, 24\n",
"\n",
"\t.type\t.const.pickledata.139903555000832,@object\n",
"\t.p2align\t4\n",
".const.pickledata.139903555000832:\n",
"\t.ascii\t\"\\200\\004\\225:\\000\\000\\000\\000\\000\\000\\000\\214\\bbuiltins\\224\\214\\021ZeroDivisionError\\224\\223\\224\\214\\020division by zero\\224\\205\\224N\\207\\224.\"\n",
"\t.size\t.const.pickledata.139903555000832, 69\n",
"\n",
"\t.type\t.const.pickledata.139903555000832.sha1,@object\n",
"\t.p2align\t4\n",
".const.pickledata.139903555000832.sha1:\n",
"\t.ascii\t\"\\262\\200\\b\\240\\370\\213\\255_\\360\\360$>\\204\\332\\271\\f\\253\\031\\263f\"\n",
"\t.size\t.const.pickledata.139903555000832.sha1, 20\n",
"\n",
"\t.type\t.const.blackscholes,@object\n",
".const.blackscholes:\n",
"\t.asciz\t\"blackscholes\"\n",
"\t.size\t.const.blackscholes, 13\n",
"\n",
"\t.type\t\".const.missing Environment: _ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\",@object\n",
"\t.p2align\t4\n",
"\".const.missing Environment: _ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\":\n",
"\t.asciz\t\"missing Environment: _ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\"\n",
"\t.size\t\".const.missing Environment: _ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\", 116\n",
"\n",
"\t.type\t\".const.unknown error when calling native function\",@object\n",
"\t.p2align\t4\n",
"\".const.unknown error when calling native function\":\n",
"\t.asciz\t\"unknown error when calling native function\"\n",
"\t.size\t\".const.unknown error when calling native function\", 43\n",
"\n",
"\t.type\t\".const.<numba.core.cpu.CPUContext object at 0x7f3dd58009d0>\",@object\n",
"\t.p2align\t4\n",
"\".const.<numba.core.cpu.CPUContext object at 0x7f3dd58009d0>\":\n",
"\t.asciz\t\"<numba.core.cpu.CPUContext object at 0x7f3dd58009d0>\"\n",
"\t.size\t\".const.<numba.core.cpu.CPUContext object at 0x7f3dd58009d0>\", 53\n",
"\n",
"\t.type\t\".const.unknown error when calling native function.1\",@object\n",
"\t.p2align\t4\n",
"\".const.unknown error when calling native function.1\":\n",
"\t.asciz\t\"unknown error when calling native function\"\n",
"\t.size\t\".const.unknown error when calling native function.1\", 43\n",
"\n",
"\t.type\t_ZN08NumbaEnv13_3cdynamic_3e94jit_wrapper__built_in_method_seed_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v2B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEx,@object\n",
"\t.comm\t_ZN08NumbaEnv13_3cdynamic_3e94jit_wrapper__built_in_method_seed_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v2B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEx,8,8\n",
"\t.type\t_ZN08NumbaEnv13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx,@object\n",
"\t.comm\t_ZN08NumbaEnv13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx,8,8\n",
"\t.type\t_ZN08NumbaEnv5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj,@object\n",
"\t.comm\t_ZN08NumbaEnv5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj,8,8\n",
"\t.type\t_ZN08NumbaEnv5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj,@object\n",
"\t.comm\t_ZN08NumbaEnv5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj,8,8\n",
"\t.type\t_ZN08NumbaEnv13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd,@object\n",
"\t.comm\t_ZN08NumbaEnv13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd,8,8\n",
"\t.type\t.const.picklebuf.139903554669456,@object\n",
"\t.p2align\t4\n",
".const.picklebuf.139903554669456:\n",
"\t.quad\t.const.pickledata.139903554669456\n",
"\t.long\t86\n",
"\t.zero\t4\n",
"\t.quad\t.const.pickledata.139903554669456.sha1\n",
"\t.size\t.const.picklebuf.139903554669456, 24\n",
"\n",
"\t.type\t.const.pickledata.139903554669456,@object\n",
"\t.p2align\t4\n",
".const.pickledata.139903554669456:\n",
"\t.ascii\t\"\\200\\004\\225K\\000\\000\\000\\000\\000\\000\\000\\214\\bbuiltins\\224\\214\\013MemoryError\\224\\223\\224\\214'Allocation failed (probably too large).\\224\\205\\224N\\207\\224.\"\n",
"\t.size\t.const.pickledata.139903554669456, 86\n",
"\n",
"\t.type\t.const.pickledata.139903554669456.sha1,@object\n",
"\t.p2align\t4\n",
".const.pickledata.139903554669456.sha1:\n",
"\t.ascii\t\"\\272(\\235\\201\\360\\\\p \\363G|\\025sH\\004\\337e\\253\\342\\t\"\n",
"\t.size\t.const.pickledata.139903554669456.sha1, 20\n",
"\n",
"\t.type\t_ZN08NumbaEnv5numba2np8arrayobj11ol_np_zeros12_3clocals_3e4implB2v7B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx48omitted_28default_3d_3cclass_20_27float_27_3e_29,@object\n",
"\t.comm\t_ZN08NumbaEnv5numba2np8arrayobj11ol_np_zeros12_3clocals_3e4implB2v7B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx48omitted_28default_3d_3cclass_20_27float_27_3e_29,8,8\n",
"\t.type\t_ZN08NumbaEnv5numba2np8arrayobj11ol_np_empty12_3clocals_3e4implB2v8B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx39Function_28_3cclass_20_27float_27_3e_29,@object\n",
"\t.comm\t_ZN08NumbaEnv5numba2np8arrayobj11ol_np_empty12_3clocals_3e4implB2v8B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx39Function_28_3cclass_20_27float_27_3e_29,8,8\n",
"\t.type\t_ZN08NumbaEnv5numba2np8arrayobj18ol_array_zero_fill12_3clocals_3e4implB2v9B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dE5ArrayIdLi1E1C7mutable7alignedE,@object\n",
"\t.comm\t_ZN08NumbaEnv5numba2np8arrayobj18ol_array_zero_fill12_3clocals_3e4implB2v9B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dE5ArrayIdLi1E1C7mutable7alignedE,8,8\n",
"\t.type\t.const.picklebuf.139903554669456.8,@object\n",
"\t.p2align\t4\n",
".const.picklebuf.139903554669456.8:\n",
"\t.quad\t.const.pickledata.139903554669456.9\n",
"\t.long\t86\n",
"\t.zero\t4\n",
"\t.quad\t.const.pickledata.139903554669456.sha1.10\n",
"\t.size\t.const.picklebuf.139903554669456.8, 24\n",
"\n",
"\t.type\t.const.pickledata.139903554669456.9,@object\n",
"\t.p2align\t4\n",
".const.pickledata.139903554669456.9:\n",
"\t.ascii\t\"\\200\\004\\225K\\000\\000\\000\\000\\000\\000\\000\\214\\bbuiltins\\224\\214\\013MemoryError\\224\\223\\224\\214'Allocation failed (probably too large).\\224\\205\\224N\\207\\224.\"\n",
"\t.size\t.const.pickledata.139903554669456.9, 86\n",
"\n",
"\t.type\t.const.pickledata.139903554669456.sha1.10,@object\n",
"\t.p2align\t4\n",
".const.pickledata.139903554669456.sha1.10:\n",
"\t.ascii\t\"\\272(\\235\\201\\360\\\\p \\363G|\\025sH\\004\\337e\\253\\342\\t\"\n",
"\t.size\t.const.pickledata.139903554669456.sha1.10, 20\n",
"\n",
"\t.type\t_ZN08NumbaEnv18blackscholes_numba3cndB3v10B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEd,@object\n",
"\t.comm\t_ZN08NumbaEnv18blackscholes_numba3cndB3v10B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEd,8,8\n",
"\t.type\t.const.picklebuf.139903552230016,@object\n",
"\t.p2align\t4\n",
".const.picklebuf.139903552230016:\n",
"\t.quad\t.const.pickledata.139903552230016\n",
"\t.long\t69\n",
"\t.zero\t4\n",
"\t.quad\t.const.pickledata.139903552230016.sha1\n",
"\t.size\t.const.picklebuf.139903552230016, 24\n",
"\n",
"\t.type\t.const.pickledata.139903552230016,@object\n",
"\t.p2align\t4\n",
".const.pickledata.139903552230016:\n",
"\t.ascii\t\"\\200\\004\\225:\\000\\000\\000\\000\\000\\000\\000\\214\\bbuiltins\\224\\214\\021ZeroDivisionError\\224\\223\\224\\214\\020division by zero\\224\\205\\224N\\207\\224.\"\n",
"\t.size\t.const.pickledata.139903552230016, 69\n",
"\n",
"\t.type\t.const.pickledata.139903552230016.sha1,@object\n",
"\t.p2align\t4\n",
".const.pickledata.139903552230016.sha1:\n",
"\t.ascii\t\"\\262\\200\\b\\240\\370\\213\\255_\\360\\360$>\\204\\332\\271\\f\\253\\031\\263f\"\n",
"\t.size\t.const.pickledata.139903552230016.sha1, 20\n",
"\n",
"\t.section\t\".note.GNU-stack\",\"\",@progbits\n",
"\n"
]
}
],
"source": [
"import numpy as np\n",
"print(list(blackscholes_numba.inspect_asm().values())[0])"
]
},
{
"cell_type": "code",
"execution_count": 22,
"id": "db35a283-1cc9-493f-9ab7-f098d2e097f6",
"metadata": {
"collapsed": true,
"execution": {
"iopub.execute_input": "2023-08-19T16:15:37.338835Z",
"iopub.status.busy": "2023-08-19T16:15:37.338557Z",
"iopub.status.idle": "2023-08-19T16:15:37.355787Z",
"shell.execute_reply": "2023-08-19T16:15:37.354674Z",
"shell.execute_reply.started": "2023-08-19T16:15:37.338812Z"
},
"jupyter": {
"outputs_hidden": true
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"; ModuleID = 'blackscholes'\n",
"source_filename = \"<string>\"\n",
"target datalayout = \"e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-f80:128-n8:16:32:64-S128\"\n",
"target triple = \"x86_64-unknown-linux-gnu\"\n",
"\n",
"@_ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx = common local_unnamed_addr global i8* null\n",
"@.const.picklebuf.139903555000832 = internal constant { i8*, i32, i8* } { i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.const.pickledata.139903555000832, i32 0, i32 0), i32 69, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.const.pickledata.139903555000832.sha1, i32 0, i32 0) }\n",
"@.const.pickledata.139903555000832 = internal constant [69 x i8] c\"\\80\\04\\95:\\00\\00\\00\\00\\00\\00\\00\\8C\\08builtins\\94\\8C\\11ZeroDivisionError\\94\\93\\94\\8C\\10division by zero\\94\\85\\94N\\87\\94.\"\n",
"@.const.pickledata.139903555000832.sha1 = internal constant [20 x i8] c\"\\B2\\80\\08\\A0\\F8\\8B\\AD_\\F0\\F0$>\\84\\DA\\B9\\0C\\AB\\19\\B3f\"\n",
"@.const.blackscholes = internal constant [13 x i8] c\"blackscholes\\00\"\n",
"@PyExc_RuntimeError = external global i8\n",
"@\".const.missing Environment: _ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\" = internal constant [116 x i8] c\"missing Environment: _ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\\00\"\n",
"@_Py_NoneStruct = external global i8\n",
"@PyExc_SystemError = external global i8\n",
"@\".const.unknown error when calling native function\" = internal constant [43 x i8] c\"unknown error when calling native function\\00\"\n",
"@\".const.<numba.core.cpu.CPUContext object at 0x7f3dd58009d0>\" = internal constant [53 x i8] c\"<numba.core.cpu.CPUContext object at 0x7f3dd58009d0>\\00\"\n",
"@\".const.unknown error when calling native function.1\" = internal constant [43 x i8] c\"unknown error when calling native function\\00\"\n",
"@_ZN08NumbaEnv13_3cdynamic_3e94jit_wrapper__built_in_method_seed_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v2B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEx = common local_unnamed_addr global i8* null\n",
"@_ZN08NumbaEnv13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx = common local_unnamed_addr global i8* null\n",
"@_ZN08NumbaEnv5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj = common local_unnamed_addr global i8* null\n",
"@_ZN08NumbaEnv5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj = common local_unnamed_addr global i8* null\n",
"@_ZN08NumbaEnv13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd = common local_unnamed_addr global i8* null\n",
"@.const.picklebuf.139903554669456 = internal constant { i8*, i32, i8* } { i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.const.pickledata.139903554669456, i32 0, i32 0), i32 86, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.const.pickledata.139903554669456.sha1, i32 0, i32 0) }\n",
"@.const.pickledata.139903554669456 = internal constant [86 x i8] c\"\\80\\04\\95K\\00\\00\\00\\00\\00\\00\\00\\8C\\08builtins\\94\\8C\\0BMemoryError\\94\\93\\94\\8C'Allocation failed (probably too large).\\94\\85\\94N\\87\\94.\"\n",
"@.const.pickledata.139903554669456.sha1 = internal constant [20 x i8] c\"\\BA(\\9D\\81\\F0\\\\p \\F3G|\\15sH\\04\\DFe\\AB\\E2\\09\"\n",
"@_ZN08NumbaEnv5numba2np8arrayobj11ol_np_zeros12_3clocals_3e4implB2v7B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx48omitted_28default_3d_3cclass_20_27float_27_3e_29 = common local_unnamed_addr global i8* null\n",
"@_ZN08NumbaEnv5numba2np8arrayobj11ol_np_empty12_3clocals_3e4implB2v8B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx39Function_28_3cclass_20_27float_27_3e_29 = common local_unnamed_addr global i8* null\n",
"@_ZN08NumbaEnv5numba2np8arrayobj18ol_array_zero_fill12_3clocals_3e4implB2v9B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dE5ArrayIdLi1E1C7mutable7alignedE = common local_unnamed_addr global i8* null\n",
"@.const.picklebuf.139903554669456.8 = internal constant { i8*, i32, i8* } { i8* getelementptr inbounds ([86 x i8], [86 x i8]* @.const.pickledata.139903554669456.9, i32 0, i32 0), i32 86, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.const.pickledata.139903554669456.sha1.10, i32 0, i32 0) }\n",
"@.const.pickledata.139903554669456.9 = internal constant [86 x i8] c\"\\80\\04\\95K\\00\\00\\00\\00\\00\\00\\00\\8C\\08builtins\\94\\8C\\0BMemoryError\\94\\93\\94\\8C'Allocation failed (probably too large).\\94\\85\\94N\\87\\94.\"\n",
"@.const.pickledata.139903554669456.sha1.10 = internal constant [20 x i8] c\"\\BA(\\9D\\81\\F0\\\\p \\F3G|\\15sH\\04\\DFe\\AB\\E2\\09\"\n",
"@_ZN08NumbaEnv18blackscholes_numba3cndB3v10B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEd = common local_unnamed_addr global i8* null\n",
"@.const.picklebuf.139903552230016 = internal constant { i8*, i32, i8* } { i8* getelementptr inbounds ([69 x i8], [69 x i8]* @.const.pickledata.139903552230016, i32 0, i32 0), i32 69, i8* getelementptr inbounds ([20 x i8], [20 x i8]* @.const.pickledata.139903552230016.sha1, i32 0, i32 0) }\n",
"@.const.pickledata.139903552230016 = internal constant [69 x i8] c\"\\80\\04\\95:\\00\\00\\00\\00\\00\\00\\00\\8C\\08builtins\\94\\8C\\11ZeroDivisionError\\94\\93\\94\\8C\\10division by zero\\94\\85\\94N\\87\\94.\"\n",
"@.const.pickledata.139903552230016.sha1 = internal constant [20 x i8] c\"\\B2\\80\\08\\A0\\F8\\8B\\AD_\\F0\\F0$>\\84\\DA\\B9\\0C\\AB\\19\\B3f\"\n",
"\n",
"define i32 @_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx(i8** noalias nocapture %retptr, { i8*, i32, i8* }** noalias nocapture %excinfo, i64 %arg.seed) local_unnamed_addr {\n",
"entry:\n",
" %.5.i = trunc i64 %arg.seed to i32\n",
" %.6.i = tail call { i32, [624 x i32], i32, double, i32 }* @numba_get_np_random_state()\n",
" tail call void @numba_rnd_init({ i32, [624 x i32], i32, double, i32 }* %.6.i, i32 %.5.i), !noalias !0\n",
" %.7.i.i.i = tail call i8* @NRT_MemInfo_alloc_safe_aligned(i64 131072, i32 32), !noalias !3\n",
" %.8.i.i.i = icmp eq i8* %.7.i.i.i, null\n",
" br i1 %.8.i.i.i, label %B0.if.if, label %B0.endif.endif.endif.endif.i, !prof !13\n",
"\n",
"B106: ; preds = %B106.endif.endif.endif.endif, %B0.endif.endif.endif.endif.endif.endif\n",
" %.276.0243 = phi i64 [ 0, %B0.endif.endif.endif.endif.endif.endif ], [ %.345, %B106.endif.endif.endif.endif ]\n",
" %.345 = add nuw nsw i64 %.276.0243, 1\n",
" %scevgep358 = getelementptr double, double* %.6.i8.i66, i64 %.276.0243\n",
" %.399 = load double, double* %scevgep358, align 8\n",
" %scevgep361 = getelementptr double, double* %.6.i8.i6, i64 %.276.0243\n",
" %.460 = load double, double* %scevgep361, align 8\n",
" %.461 = fcmp oeq double %.460, 0.000000e+00\n",
" br i1 %.461, label %B106.if, label %B106.endif, !prof !13\n",
"\n",
"B300: ; preds = %B106.endif.endif.endif.endif\n",
" tail call void @NRT_decref(i8* nonnull %.7.i.i.i.i124)\n",
" tail call void @NRT_decref(i8* nonnull %.7.i.i.i.i)\n",
" tail call void @NRT_decref(i8* nonnull %.7.i.i.i2)\n",
" tail call void @NRT_decref(i8* nonnull %.7.i.i.i62)\n",
" tail call void @NRT_decref(i8* nonnull %.7.i.i.i)\n",
" store i8* null, i8** %retptr, align 8\n",
" ret i32 0\n",
"\n",
"B0.endif.endif.endif.endif.i: ; preds = %entry\n",
" %.5.i.i = getelementptr i8, i8* %.7.i.i.i, i64 24\n",
" %0 = bitcast i8* %.5.i.i to double**\n",
" %.6.i8.i = load double*, double** %0, align 8, !noalias !14\n",
" br label %for.body.i\n",
"\n",
"for.body.i: ; preds = %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i, %B0.endif.endif.endif.endif.i\n",
" %loop.index6.i = phi i64 [ 0, %B0.endif.endif.endif.endif.i ], [ %.117.i, %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i ]\n",
" %1 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" %.9.i.i = load i32, i32* %1, align 4, !noalias !15\n",
" %.10.i.i = icmp ugt i32 %.9.i.i, 623\n",
" br i1 %.10.i.i, label %B0.if.i3.i, label %B0.endif.i4.i, !prof !13\n",
"\n",
"B0.if.i3.i: ; preds = %for.body.i\n",
" %2 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" tail call void @numba_rnd_shuffle({ i32, [624 x i32], i32, double, i32 }* nonnull %.6.i), !noalias !15\n",
" store i32 0, i32* %2, align 4, !noalias !15\n",
" br label %B0.endif.i4.i\n",
"\n",
"B0.endif.i4.i: ; preds = %B0.if.i3.i, %for.body.i\n",
" %.15.i.i = phi i32 [ 0, %B0.if.i3.i ], [ %.9.i.i, %for.body.i ]\n",
" %3 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" %4 = zext i32 %.15.i.i to i64\n",
" %.17.i.i = getelementptr inbounds { i32, [624 x i32], i32, double, i32 }, { i32, [624 x i32], i32, double, i32 }* %.6.i, i64 0, i32 1, i64 %4\n",
" %.18.i.i = load i32, i32* %.17.i.i, align 4, !noalias !15\n",
" %.19.i.i = add nuw nsw i32 %.15.i.i, 1\n",
" store i32 %.19.i.i, i32* %3, align 4, !noalias !15\n",
" %.21.i.i = lshr i32 %.18.i.i, 11\n",
" %.22.i.i = xor i32 %.21.i.i, %.18.i.i\n",
" %.23.i.i = shl i32 %.22.i.i, 7\n",
" %.24.i.i = and i32 %.23.i.i, -1658038656\n",
" %.25.i.i = xor i32 %.24.i.i, %.22.i.i\n",
" %.26.i.i = shl i32 %.25.i.i, 15\n",
" %.27.i.i = and i32 %.26.i.i, -272236544\n",
" %.28.i.i = xor i32 %.27.i.i, %.25.i.i\n",
" %.34.i.i = icmp ugt i32 %.15.i.i, 622\n",
" br i1 %.34.i.i, label %B0.endif.if.i.i, label %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i, !prof !13\n",
"\n",
"B0.endif.if.i.i: ; preds = %B0.endif.i4.i\n",
" %5 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" tail call void @numba_rnd_shuffle({ i32, [624 x i32], i32, double, i32 }* nonnull %.6.i), !noalias !15\n",
" store i32 0, i32* %5, align 4, !noalias !15\n",
" br label %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i\n",
"\n",
"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i: ; preds = %B0.endif.if.i.i, %B0.endif.i4.i\n",
" %.39.i.i = phi i32 [ 0, %B0.endif.if.i.i ], [ %.19.i.i, %B0.endif.i4.i ]\n",
" %6 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" %7 = lshr i32 %.28.i.i, 23\n",
" %8 = lshr i32 %.28.i.i, 5\n",
" %.31.i.i = xor i32 %7, %8\n",
" %9 = zext i32 %.39.i.i to i64\n",
" %.41.i.i = getelementptr inbounds { i32, [624 x i32], i32, double, i32 }, { i32, [624 x i32], i32, double, i32 }* %.6.i, i64 0, i32 1, i64 %9\n",
" %.42.i.i = load i32, i32* %.41.i.i, align 4, !noalias !15\n",
" %.43.i.i = add nuw nsw i32 %.39.i.i, 1\n",
" store i32 %.43.i.i, i32* %6, align 4, !noalias !15\n",
" %.45.i.i = lshr i32 %.42.i.i, 11\n",
" %.46.i.i = xor i32 %.45.i.i, %.42.i.i\n",
" %.47.i.i = shl i32 %.46.i.i, 7\n",
" %.48.i.i = and i32 %.47.i.i, -1658038656\n",
" %.49.i.i = xor i32 %.48.i.i, %.46.i.i\n",
" %.50.i.i = shl i32 %.49.i.i, 15\n",
" %.51.i.i = and i32 %.50.i.i, -272236544\n",
" %.52.i.i = xor i32 %.51.i.i, %.49.i.i\n",
" %10 = lshr i32 %.52.i.i, 24\n",
" %11 = lshr i32 %.52.i.i, 6\n",
" %.55.i.i = xor i32 %10, %11\n",
" %.56.i.i = uitofp i32 %.31.i.i to double\n",
" %.57.i.i = uitofp i32 %.55.i.i to double\n",
" %.58.i.i = fmul double %.56.i.i, 0x4190000000000000\n",
" %.59.i.i = fadd double %.58.i.i, %.57.i.i\n",
" %.60.i.i = fmul double %.59.i.i, 0x3CA0000000000000\n",
" %.61.i.i = fmul double %.60.i.i, 2.500000e+01\n",
" %.62.i.i = fadd double %.61.i.i, 5.000000e+00\n",
" %scevgep366 = getelementptr double, double* %.6.i8.i, i64 %loop.index6.i\n",
" store double %.62.i.i, double* %scevgep366, align 8, !noalias !14\n",
" %.117.i = add nuw nsw i64 %loop.index6.i, 1\n",
" %exitcond.not.i = icmp eq i64 %.117.i, 16384\n",
" br i1 %exitcond.not.i, label %B0.endif.endif, label %for.body.i\n",
"\n",
"B0.if.if: ; preds = %B106.endif.endif, %B106.endif.endif.endif, %B0.endif.endif.endif.endif.endif, %B0.endif.endif.endif.endif, %B0.endif.endif.endif, %B0.endif.endif, %entry\n",
" %.const.picklebuf.139903554669456.sink = phi { i8*, i32, i8* }* [ @.const.picklebuf.139903554669456, %entry ], [ @.const.picklebuf.139903554669456, %B0.endif.endif ], [ @.const.picklebuf.139903554669456, %B0.endif.endif.endif ], [ @.const.picklebuf.139903554669456.8, %B0.endif.endif.endif.endif ], [ @.const.picklebuf.139903554669456.8, %B0.endif.endif.endif.endif.endif ], [ @.const.picklebuf.139903552230016, %B106.endif.endif.endif ], [ @.const.picklebuf.139903552230016, %B106.endif.endif ]\n",
" store { i8*, i32, i8* }* %.const.picklebuf.139903554669456.sink, { i8*, i32, i8* }** %excinfo, align 8\n",
" ret i32 1, !ret_is_raise !18\n",
"\n",
"B0.endif.endif: ; preds = %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i\n",
" %.7.i.i.i2 = tail call i8* @NRT_MemInfo_alloc_safe_aligned(i64 131072, i32 32), !noalias !19\n",
" %.8.i.i.i3 = icmp eq i8* %.7.i.i.i2, null\n",
" br i1 %.8.i.i.i3, label %B0.if.if, label %B0.endif.endif.endif.endif.i7, !prof !13\n",
"\n",
"B0.endif.endif.endif.endif.i7: ; preds = %B0.endif.endif\n",
" %.5.i.i5 = getelementptr i8, i8* %.7.i.i.i2, i64 24\n",
" %12 = bitcast i8* %.5.i.i5 to double**\n",
" %.6.i8.i6 = load double*, double** %12, align 8, !noalias !29\n",
" br label %for.body.i12\n",
"\n",
"for.body.i12: ; preds = %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i53, %B0.endif.endif.endif.endif.i7\n",
" %loop.index6.i9 = phi i64 [ 0, %B0.endif.endif.endif.endif.i7 ], [ %.117.i51, %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i53 ]\n",
" %13 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" %.9.i.i10 = load i32, i32* %13, align 4, !noalias !30\n",
" %.10.i.i11 = icmp ugt i32 %.9.i.i10, 623\n",
" br i1 %.10.i.i11, label %B0.if.i3.i13, label %B0.endif.i4.i27, !prof !13\n",
"\n",
"B0.if.i3.i13: ; preds = %for.body.i12\n",
" %14 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" tail call void @numba_rnd_shuffle({ i32, [624 x i32], i32, double, i32 }* nonnull %.6.i), !noalias !30\n",
" store i32 0, i32* %14, align 4, !noalias !30\n",
" br label %B0.endif.i4.i27\n",
"\n",
"B0.endif.i4.i27: ; preds = %B0.if.i3.i13, %for.body.i12\n",
" %.15.i.i14 = phi i32 [ 0, %B0.if.i3.i13 ], [ %.9.i.i10, %for.body.i12 ]\n",
" %15 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" %16 = zext i32 %.15.i.i14 to i64\n",
" %.17.i.i15 = getelementptr inbounds { i32, [624 x i32], i32, double, i32 }, { i32, [624 x i32], i32, double, i32 }* %.6.i, i64 0, i32 1, i64 %16\n",
" %.18.i.i16 = load i32, i32* %.17.i.i15, align 4, !noalias !30\n",
" %.19.i.i17 = add nuw nsw i32 %.15.i.i14, 1\n",
" store i32 %.19.i.i17, i32* %15, align 4, !noalias !30\n",
" %.21.i.i18 = lshr i32 %.18.i.i16, 11\n",
" %.22.i.i19 = xor i32 %.21.i.i18, %.18.i.i16\n",
" %.23.i.i20 = shl i32 %.22.i.i19, 7\n",
" %.24.i.i21 = and i32 %.23.i.i20, -1658038656\n",
" %.25.i.i22 = xor i32 %.24.i.i21, %.22.i.i19\n",
" %.26.i.i23 = shl i32 %.25.i.i22, 15\n",
" %.27.i.i24 = and i32 %.26.i.i23, -272236544\n",
" %.28.i.i25 = xor i32 %.27.i.i24, %.25.i.i22\n",
" %.34.i.i26 = icmp ugt i32 %.15.i.i14, 622\n",
" br i1 %.34.i.i26, label %B0.endif.if.i.i28, label %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i53, !prof !13\n",
"\n",
"B0.endif.if.i.i28: ; preds = %B0.endif.i4.i27\n",
" %17 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" tail call void @numba_rnd_shuffle({ i32, [624 x i32], i32, double, i32 }* nonnull %.6.i), !noalias !30\n",
" store i32 0, i32* %17, align 4, !noalias !30\n",
" br label %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i53\n",
"\n",
"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i53: ; preds = %B0.endif.if.i.i28, %B0.endif.i4.i27\n",
" %.39.i.i29 = phi i32 [ 0, %B0.endif.if.i.i28 ], [ %.19.i.i17, %B0.endif.i4.i27 ]\n",
" %18 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" %19 = lshr i32 %.28.i.i25, 23\n",
" %20 = lshr i32 %.28.i.i25, 5\n",
" %.31.i.i30 = xor i32 %19, %20\n",
" %21 = zext i32 %.39.i.i29 to i64\n",
" %.41.i.i31 = getelementptr inbounds { i32, [624 x i32], i32, double, i32 }, { i32, [624 x i32], i32, double, i32 }* %.6.i, i64 0, i32 1, i64 %21\n",
" %.42.i.i32 = load i32, i32* %.41.i.i31, align 4, !noalias !30\n",
" %.43.i.i33 = add nuw nsw i32 %.39.i.i29, 1\n",
" store i32 %.43.i.i33, i32* %18, align 4, !noalias !30\n",
" %.45.i.i34 = lshr i32 %.42.i.i32, 11\n",
" %.46.i.i35 = xor i32 %.45.i.i34, %.42.i.i32\n",
" %.47.i.i36 = shl i32 %.46.i.i35, 7\n",
" %.48.i.i37 = and i32 %.47.i.i36, -1658038656\n",
" %.49.i.i38 = xor i32 %.48.i.i37, %.46.i.i35\n",
" %.50.i.i39 = shl i32 %.49.i.i38, 15\n",
" %.51.i.i40 = and i32 %.50.i.i39, -272236544\n",
" %.52.i.i41 = xor i32 %.51.i.i40, %.49.i.i38\n",
" %22 = lshr i32 %.52.i.i41, 24\n",
" %23 = lshr i32 %.52.i.i41, 6\n",
" %.55.i.i42 = xor i32 %22, %23\n",
" %.56.i.i43 = uitofp i32 %.31.i.i30 to double\n",
" %.57.i.i44 = uitofp i32 %.55.i.i42 to double\n",
" %.58.i.i45 = fmul double %.56.i.i43, 0x4190000000000000\n",
" %.59.i.i46 = fadd double %.58.i.i45, %.57.i.i44\n",
" %.60.i.i47 = fmul double %.59.i.i46, 0x3CA0000000000000\n",
" %.61.i.i48 = fmul double %.60.i.i47, 9.900000e+01\n",
" %.62.i.i49 = fadd double %.61.i.i48, 1.000000e+00\n",
" %scevgep = getelementptr double, double* %.6.i8.i6, i64 %loop.index6.i9\n",
" store double %.62.i.i49, double* %scevgep, align 8, !noalias !29\n",
" %.117.i51 = add nuw nsw i64 %loop.index6.i9, 1\n",
" %exitcond.not.i52 = icmp eq i64 %.117.i51, 16384\n",
" br i1 %exitcond.not.i52, label %B0.endif.endif.endif, label %for.body.i12\n",
"\n",
"B0.endif.endif.endif: ; preds = %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i53\n",
" %.7.i.i.i62 = tail call i8* @NRT_MemInfo_alloc_safe_aligned(i64 131072, i32 32), !noalias !33\n",
" %.8.i.i.i63 = icmp eq i8* %.7.i.i.i62, null\n",
" br i1 %.8.i.i.i63, label %B0.if.if, label %B0.endif.endif.endif.endif.i67, !prof !13\n",
"\n",
"B0.endif.endif.endif.endif.i67: ; preds = %B0.endif.endif.endif\n",
" %.5.i.i65 = getelementptr i8, i8* %.7.i.i.i62, i64 24\n",
" %24 = bitcast i8* %.5.i.i65 to double**\n",
" %.6.i8.i66 = load double*, double** %24, align 8, !noalias !43\n",
" br label %for.body.i72\n",
"\n",
"for.body.i72: ; preds = %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i113, %B0.endif.endif.endif.endif.i67\n",
" %loop.index6.i69 = phi i64 [ 0, %B0.endif.endif.endif.endif.i67 ], [ %.117.i111, %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i113 ]\n",
" %25 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" %.9.i.i70 = load i32, i32* %25, align 4, !noalias !44\n",
" %.10.i.i71 = icmp ugt i32 %.9.i.i70, 623\n",
" br i1 %.10.i.i71, label %B0.if.i3.i73, label %B0.endif.i4.i87, !prof !13\n",
"\n",
"B0.if.i3.i73: ; preds = %for.body.i72\n",
" %26 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" tail call void @numba_rnd_shuffle({ i32, [624 x i32], i32, double, i32 }* nonnull %.6.i), !noalias !44\n",
" store i32 0, i32* %26, align 4, !noalias !44\n",
" br label %B0.endif.i4.i87\n",
"\n",
"B0.endif.i4.i87: ; preds = %B0.if.i3.i73, %for.body.i72\n",
" %.15.i.i74 = phi i32 [ 0, %B0.if.i3.i73 ], [ %.9.i.i70, %for.body.i72 ]\n",
" %27 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" %28 = zext i32 %.15.i.i74 to i64\n",
" %.17.i.i75 = getelementptr inbounds { i32, [624 x i32], i32, double, i32 }, { i32, [624 x i32], i32, double, i32 }* %.6.i, i64 0, i32 1, i64 %28\n",
" %.18.i.i76 = load i32, i32* %.17.i.i75, align 4, !noalias !44\n",
" %.19.i.i77 = add nuw nsw i32 %.15.i.i74, 1\n",
" store i32 %.19.i.i77, i32* %27, align 4, !noalias !44\n",
" %.21.i.i78 = lshr i32 %.18.i.i76, 11\n",
" %.22.i.i79 = xor i32 %.21.i.i78, %.18.i.i76\n",
" %.23.i.i80 = shl i32 %.22.i.i79, 7\n",
" %.24.i.i81 = and i32 %.23.i.i80, -1658038656\n",
" %.25.i.i82 = xor i32 %.24.i.i81, %.22.i.i79\n",
" %.26.i.i83 = shl i32 %.25.i.i82, 15\n",
" %.27.i.i84 = and i32 %.26.i.i83, -272236544\n",
" %.28.i.i85 = xor i32 %.27.i.i84, %.25.i.i82\n",
" %.34.i.i86 = icmp ugt i32 %.15.i.i74, 622\n",
" br i1 %.34.i.i86, label %B0.endif.if.i.i88, label %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i113, !prof !13\n",
"\n",
"B0.endif.if.i.i88: ; preds = %B0.endif.i4.i87\n",
" %29 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" tail call void @numba_rnd_shuffle({ i32, [624 x i32], i32, double, i32 }* nonnull %.6.i), !noalias !44\n",
" store i32 0, i32* %29, align 4, !noalias !44\n",
" br label %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i113\n",
"\n",
"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i113: ; preds = %B0.endif.if.i.i88, %B0.endif.i4.i87\n",
" %.39.i.i89 = phi i32 [ 0, %B0.endif.if.i.i88 ], [ %.19.i.i77, %B0.endif.i4.i87 ]\n",
" %30 = bitcast { i32, [624 x i32], i32, double, i32 }* %.6.i to i32*\n",
" %31 = lshr i32 %.28.i.i85, 23\n",
" %32 = lshr i32 %.28.i.i85, 5\n",
" %.31.i.i90 = xor i32 %31, %32\n",
" %33 = zext i32 %.39.i.i89 to i64\n",
" %.41.i.i91 = getelementptr inbounds { i32, [624 x i32], i32, double, i32 }, { i32, [624 x i32], i32, double, i32 }* %.6.i, i64 0, i32 1, i64 %33\n",
" %.42.i.i92 = load i32, i32* %.41.i.i91, align 4, !noalias !44\n",
" %.43.i.i93 = add nuw nsw i32 %.39.i.i89, 1\n",
" store i32 %.43.i.i93, i32* %30, align 4, !noalias !44\n",
" %.45.i.i94 = lshr i32 %.42.i.i92, 11\n",
" %.46.i.i95 = xor i32 %.45.i.i94, %.42.i.i92\n",
" %.47.i.i96 = shl i32 %.46.i.i95, 7\n",
" %.48.i.i97 = and i32 %.47.i.i96, -1658038656\n",
" %.49.i.i98 = xor i32 %.48.i.i97, %.46.i.i95\n",
" %.50.i.i99 = shl i32 %.49.i.i98, 15\n",
" %.51.i.i100 = and i32 %.50.i.i99, -272236544\n",
" %.52.i.i101 = xor i32 %.51.i.i100, %.49.i.i98\n",
" %34 = lshr i32 %.52.i.i101, 24\n",
" %35 = lshr i32 %.52.i.i101, 6\n",
" %.55.i.i102 = xor i32 %34, %35\n",
" %.56.i.i103 = uitofp i32 %.31.i.i90 to double\n",
" %.57.i.i104 = uitofp i32 %.55.i.i102 to double\n",
" %.58.i.i105 = fmul double %.56.i.i103, 0x4190000000000000\n",
" %.59.i.i106 = fadd double %.58.i.i105, %.57.i.i104\n",
" %.60.i.i107 = fmul double %.59.i.i106, 0x3CA0000000000000\n",
" %.61.i.i108 = fmul double %.60.i.i107, 9.750000e+00\n",
" %.62.i.i109 = fadd double %.61.i.i108, 2.500000e-01\n",
" %scevgep365 = getelementptr double, double* %.6.i8.i66, i64 %loop.index6.i69\n",
" store double %.62.i.i109, double* %scevgep365, align 8, !noalias !43\n",
" %.117.i111 = add nuw nsw i64 %loop.index6.i69, 1\n",
" %exitcond.not.i112 = icmp eq i64 %.117.i111, 16384\n",
" br i1 %exitcond.not.i112, label %B0.endif.endif.endif.endif, label %for.body.i72\n",
"\n",
"B0.endif.endif.endif.endif: ; preds = %_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd.exit.i113\n",
" %.7.i.i.i.i = tail call i8* @NRT_MemInfo_alloc_safe_aligned(i64 131072, i32 32), !noalias !47\n",
" %.8.i.i.i.i = icmp eq i8* %.7.i.i.i.i, null\n",
" br i1 %.8.i.i.i.i, label %B0.if.if, label %B0.endif.endif.endif.endif.endif, !prof !13\n",
"\n",
"B0.endif.endif.endif.endif.endif: ; preds = %B0.endif.endif.endif.endif\n",
" %.5.i.i.i = getelementptr i8, i8* %.7.i.i.i.i, i64 24\n",
" %36 = bitcast i8* %.5.i.i.i to double**\n",
" %.6.i215.i26.i = load double*, double** %36, align 8, !noalias !60\n",
" %.27.i.i122 = bitcast double* %.6.i215.i26.i to i8*\n",
" tail call void @llvm.memset.p0i8.i64(i8* nonnull align 1 dereferenceable(131072) %.27.i.i122, i8 0, i64 131072, i1 false) #5, !noalias !61\n",
" %.7.i.i.i.i124 = tail call i8* @NRT_MemInfo_alloc_safe_aligned(i64 131072, i32 32), !noalias !64\n",
" %.8.i.i.i.i125 = icmp eq i8* %.7.i.i.i.i124, null\n",
" br i1 %.8.i.i.i.i125, label %B0.if.if, label %B0.endif.endif.endif.endif.endif.endif, !prof !13\n",
"\n",
"B0.endif.endif.endif.endif.endif.endif: ; preds = %B0.endif.endif.endif.endif.endif\n",
" %.5.i.i.i127 = getelementptr i8, i8* %.7.i.i.i.i124, i64 24\n",
" %37 = bitcast i8* %.5.i.i.i127 to double**\n",
" %.6.i215.i26.i128 = load double*, double** %37, align 8, !noalias !77\n",
" %.27.i.i129 = bitcast double* %.6.i215.i26.i128 to i8*\n",
" tail call void @llvm.memset.p0i8.i64(i8* nonnull align 1 dereferenceable(131072) %.27.i.i129, i8 0, i64 131072, i1 false) #5, !noalias !78\n",
" br label %B106\n",
"\n",
"B106.if: ; preds = %B106\n",
" store { i8*, i32, i8* }* @.const.picklebuf.139903555000832, { i8*, i32, i8* }** %excinfo, align 8\n",
" ret i32 1, !ret_is_raise !18\n",
"\n",
"B106.endif: ; preds = %B106\n",
" %.400 = tail call double @sqrt(double %.399)\n",
" %.509 = fmul double %.400, 3.000000e-01\n",
" %.510 = fcmp oeq double %.509, 0.000000e+00\n",
" br i1 %.510, label %B106.endif.if, label %B106.endif.endif, !prof !13\n",
"\n",
"B106.endif.if: ; preds = %B106.endif\n",
" store { i8*, i32, i8* }* @.const.picklebuf.139903555000832, { i8*, i32, i8* }** %excinfo, align 8\n",
" ret i32 1, !ret_is_raise !18\n",
"\n",
"B106.endif.endif: ; preds = %B106.endif\n",
" %scevgep363 = getelementptr double, double* %.6.i8.i, i64 %.276.0243\n",
" %.430 = load double, double* %scevgep363, align 8\n",
" %.468 = fdiv double %.430, %.460\n",
" %.469 = tail call double @llvm.log.f64(double %.468)\n",
" %.506 = fmul double %.399, 6.500000e-02\n",
" %.507 = fadd double %.506, %.469\n",
" %.517 = fdiv double %.507, %.509\n",
" %.520 = fsub double %.517, %.509\n",
" %.5.i138 = tail call double @llvm.fabs.f64(double %.517) #5\n",
" %.6.i139 = fmul double %.5.i138, 0x3FCDA6711871100E\n",
" %.7.i = fadd double %.6.i139, 1.000000e+00\n",
" %.8.i = fcmp oeq double %.7.i, 0.000000e+00\n",
" br i1 %.8.i, label %B0.if.if, label %B106.endif.endif.endif, !prof !13\n",
"\n",
"B106.endif.endif.endif: ; preds = %B106.endif.endif\n",
" %.17.i = fdiv double 1.000000e+00, %.7.i\n",
" %.18.i = fmul double %.517, -5.000000e-01\n",
" %.19.i = fmul double %.517, %.18.i\n",
" %.20.i = tail call double @llvm.exp.f64(double %.19.i) #5\n",
" %.21.i = fmul double %.20.i, 0x3FD9884533D43651\n",
" %.22.i = fmul double %.17.i, 0x3FF548CDD6F42943\n",
" %.23.i = fadd double %.22.i, 0xBFFD23DD4EF278D0\n",
" %.24.i = fmul double %.17.i, %.23.i\n",
" %.25.i = fadd double %.24.i, 0x3FFC80EF025F5E68\n",
" %.26.i = fmul double %.17.i, %.25.i\n",
" %.27.i = fadd double %.26.i, 0xBFD6D1F0E5A8325B\n",
" %.28.i = fmul double %.17.i, %.27.i\n",
" %.29.i = fadd double %.28.i, 0x3FD470BF3A92F8EC\n",
" %.30.i = fmul double %.17.i, %.29.i\n",
" %.31.i = fmul double %.21.i, %.30.i\n",
" %.40.i = fcmp ogt double %.517, 0.000000e+00\n",
" %.43.i = fsub double 1.000000e+00, %.31.i\n",
" %ret_val.2.0.i = select i1 %.40.i, double %.43.i, double %.31.i\n",
" %.5.i143 = tail call double @llvm.fabs.f64(double %.520) #5\n",
" %.6.i144 = fmul double %.5.i143, 0x3FCDA6711871100E\n",
" %.7.i145 = fadd double %.6.i144, 1.000000e+00\n",
" %.8.i146 = fcmp oeq double %.7.i145, 0.000000e+00\n",
" br i1 %.8.i146, label %B0.if.if, label %B106.endif.endif.endif.endif, !prof !13\n",
"\n",
"B106.endif.endif.endif.endif: ; preds = %B106.endif.endif.endif\n",
" %.17.i148 = fdiv double 1.000000e+00, %.7.i145\n",
" %.18.i149 = fmul double %.520, -5.000000e-01\n",
" %.19.i150 = fmul double %.520, %.18.i149\n",
" %.20.i151 = tail call double @llvm.exp.f64(double %.19.i150) #5\n",
" %.21.i152 = fmul double %.20.i151, 0x3FD9884533D43651\n",
" %.22.i153 = fmul double %.17.i148, 0x3FF548CDD6F42943\n",
" %.23.i154 = fadd double %.22.i153, 0xBFFD23DD4EF278D0\n",
" %.24.i155 = fmul double %.17.i148, %.23.i154\n",
" %.25.i156 = fadd double %.24.i155, 0x3FFC80EF025F5E68\n",
" %.26.i157 = fmul double %.17.i148, %.25.i156\n",
" %.27.i158 = fadd double %.26.i157, 0xBFD6D1F0E5A8325B\n",
" %.28.i159 = fmul double %.17.i148, %.27.i158\n",
" %.29.i160 = fadd double %.28.i159, 0x3FD470BF3A92F8EC\n",
" %.30.i161 = fmul double %.17.i148, %.29.i160\n",
" %.31.i162 = fmul double %.21.i152, %.30.i161\n",
" %.40.i163 = fcmp ogt double %.520, 0.000000e+00\n",
" %.43.i164 = fsub double 1.000000e+00, %.31.i162\n",
" %ret_val.2.0.i165 = select i1 %.40.i163, double %.43.i164, double %.31.i162\n",
" %.603 = fmul double %.399, -2.000000e-02\n",
" %.604 = tail call double @llvm.exp.f64(double %.603)\n",
" %.635 = fmul double %.430, %ret_val.2.0.i\n",
" %.666 = fmul double %.460, %.604\n",
" %.667 = fmul double %.666, %ret_val.2.0.i165\n",
" %.668 = fsub double %.635, %.667\n",
" %scevgep359 = getelementptr double, double* %.6.i215.i26.i, i64 %.276.0243\n",
" store double %.668, double* %scevgep359, align 8\n",
" %scevgep362 = getelementptr double, double* %.6.i8.i6, i64 %.276.0243\n",
" %.728 = load double, double* %scevgep362, align 8\n",
" %.729 = fmul double %.604, %.728\n",
" %.730 = fsub double 1.000000e+00, %ret_val.2.0.i165\n",
" %.731 = fmul double %.730, %.729\n",
" %scevgep364 = getelementptr double, double* %.6.i8.i, i64 %.276.0243\n",
" %.761 = load double, double* %scevgep364, align 8\n",
" %.762 = fsub double 1.000000e+00, %ret_val.2.0.i\n",
" %.763 = fmul double %.762, %.761\n",
" %.764 = fsub double %.731, %.763\n",
" %scevgep360 = getelementptr double, double* %.6.i215.i26.i128, i64 %.276.0243\n",
" store double %.764, double* %scevgep360, align 8\n",
" %exitcond.not = icmp eq i64 %.345, 16384\n",
" br i1 %exitcond.not, label %B300, label %B106\n",
"}\n",
"\n",
"; Function Attrs: nofree nounwind readonly\n",
"declare double @sqrt(double) local_unnamed_addr #0\n",
"\n",
"; Function Attrs: nounwind readnone speculatable willreturn\n",
"declare double @llvm.log.f64(double) #1\n",
"\n",
"; Function Attrs: nounwind readnone speculatable willreturn\n",
"declare double @llvm.exp.f64(double) #1\n",
"\n",
"define i8* @_ZN7cpython18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx(i8* nocapture readnone %py_closure, i8* %py_args, i8* nocapture readnone %py_kws) local_unnamed_addr {\n",
"entry:\n",
" %.5 = alloca i8*, align 8\n",
" %.6 = call i32 (i8*, i8*, i64, i64, ...) @PyArg_UnpackTuple(i8* %py_args, i8* getelementptr inbounds ([13 x i8], [13 x i8]* @.const.blackscholes, i64 0, i64 0), i64 1, i64 1, i8** nonnull %.5)\n",
" %.7 = icmp eq i32 %.6, 0\n",
" %.36 = alloca i8*, align 8\n",
" store i8* null, i8** %.36, align 8\n",
" %excinfo = alloca { i8*, i32, i8* }*, align 8\n",
" store { i8*, i32, i8* }* null, { i8*, i32, i8* }** %excinfo, align 8\n",
" br i1 %.7, label %entry.if, label %entry.endif, !prof !13\n",
"\n",
"entry.if: ; preds = %entry.endif.endif.endif.endif.endif.if, %entry.endif.endif.endif, %entry.endif.endif.endif.endif.endif.if.if, %entry.endif.endif.endif.endif.endif.endif.endif.endif, %entry\n",
" ret i8* null\n",
"\n",
"entry.endif: ; preds = %entry\n",
" %.11 = load i8*, i8** @_ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx, align 8\n",
" %.16 = icmp eq i8* %.11, null\n",
" br i1 %.16, label %entry.endif.if, label %entry.endif.endif, !prof !13\n",
"\n",
"entry.endif.if: ; preds = %entry.endif\n",
" call void @PyErr_SetString(i8* nonnull @PyExc_RuntimeError, i8* getelementptr inbounds ([116 x i8], [116 x i8]* @\".const.missing Environment: _ZN08NumbaEnv18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx\", i64 0, i64 0))\n",
" ret i8* null\n",
"\n",
"entry.endif.endif: ; preds = %entry.endif\n",
" %.20 = load i8*, i8** %.5, align 8\n",
" %.23 = call i8* @PyNumber_Long(i8* %.20)\n",
" %.24.not = icmp eq i8* %.23, null\n",
" br i1 %.24.not, label %entry.endif.endif.endif, label %entry.endif.endif.if, !prof !13\n",
"\n",
"entry.endif.endif.if: ; preds = %entry.endif.endif\n",
" %.26 = call i64 @PyLong_AsLongLong(i8* nonnull %.23)\n",
" call void @Py_DecRef(i8* nonnull %.23)\n",
" br label %entry.endif.endif.endif\n",
"\n",
"entry.endif.endif.endif: ; preds = %entry.endif.endif, %entry.endif.endif.if\n",
" %.21.0 = phi i64 [ %.26, %entry.endif.endif.if ], [ 0, %entry.endif.endif ]\n",
" %.31 = call i8* @PyErr_Occurred()\n",
" %.32.not = icmp eq i8* %.31, null\n",
" br i1 %.32.not, label %entry.endif.endif.endif.endif, label %entry.if, !prof !81\n",
"\n",
"entry.endif.endif.endif.endif: ; preds = %entry.endif.endif.endif\n",
" store i8* null, i8** %.36, align 8\n",
" %.40 = call i32 @_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx(i8** nonnull %.36, { i8*, i32, i8* }** nonnull %excinfo, i64 %.21.0) #4\n",
" %.41 = load { i8*, i32, i8* }*, { i8*, i32, i8* }** %excinfo, align 8\n",
" switch i32 %.40, label %entry.endif.endif.endif.endif.endif [\n",
" i32 -2, label %entry.endif.endif.endif.endif.if\n",
" i32 0, label %entry.endif.endif.endif.endif.if\n",
" ]\n",
"\n",
"entry.endif.endif.endif.endif.if: ; preds = %entry.endif.endif.endif.endif, %entry.endif.endif.endif.endif\n",
" call void @Py_IncRef(i8* nonnull @_Py_NoneStruct)\n",
" ret i8* @_Py_NoneStruct\n",
"\n",
"entry.endif.endif.endif.endif.endif: ; preds = %entry.endif.endif.endif.endif\n",
" %.48 = icmp sgt i32 %.40, 0\n",
" br i1 %.48, label %entry.endif.endif.endif.endif.endif.if, label %entry.endif.endif.endif.endif.endif.endif.endif.endif\n",
"\n",
"entry.endif.endif.endif.endif.endif.if: ; preds = %entry.endif.endif.endif.endif.endif\n",
" call void @PyErr_Clear()\n",
" %.60 = load { i8*, i32, i8* }, { i8*, i32, i8* }* %.41, align 8\n",
" %.61 = extractvalue { i8*, i32, i8* } %.60, 0\n",
" %.63 = extractvalue { i8*, i32, i8* } %.60, 1\n",
" %.65 = extractvalue { i8*, i32, i8* } %.60, 2\n",
" %.66 = call i8* @numba_unpickle(i8* %.61, i32 %.63, i8* %.65)\n",
" %.67.not = icmp eq i8* %.66, null\n",
" br i1 %.67.not, label %entry.if, label %entry.endif.endif.endif.endif.endif.if.if, !prof !13\n",
"\n",
"entry.endif.endif.endif.endif.endif.if.if: ; preds = %entry.endif.endif.endif.endif.endif.if\n",
" call void @numba_do_raise(i8* nonnull %.66)\n",
" br label %entry.if\n",
"\n",
"entry.endif.endif.endif.endif.endif.endif.endif.endif: ; preds = %entry.endif.endif.endif.endif.endif\n",
" call void @PyErr_SetString(i8* nonnull @PyExc_SystemError, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @\".const.unknown error when calling native function\", i64 0, i64 0))\n",
" br label %entry.if\n",
"}\n",
"\n",
"declare i32 @PyArg_UnpackTuple(i8*, i8*, i64, i64, ...) local_unnamed_addr\n",
"\n",
"declare void @PyErr_SetString(i8*, i8*) local_unnamed_addr\n",
"\n",
"declare i8* @PyNumber_Long(i8*) local_unnamed_addr\n",
"\n",
"declare i64 @PyLong_AsLongLong(i8*) local_unnamed_addr\n",
"\n",
"declare void @Py_DecRef(i8*) local_unnamed_addr\n",
"\n",
"declare i8* @PyErr_Occurred() local_unnamed_addr\n",
"\n",
"declare void @Py_IncRef(i8*) local_unnamed_addr\n",
"\n",
"declare void @PyErr_Clear() local_unnamed_addr\n",
"\n",
"declare i8* @numba_unpickle(i8*, i32, i8*) local_unnamed_addr\n",
"\n",
"declare void @numba_do_raise(i8*) local_unnamed_addr\n",
"\n",
"define i8* @cfunc._ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx(i64 %.1) local_unnamed_addr {\n",
"entry:\n",
" %.3 = alloca i8*, align 8\n",
" store i8* null, i8** %.3, align 8\n",
" %excinfo = alloca { i8*, i32, i8* }*, align 8\n",
" store { i8*, i32, i8* }* null, { i8*, i32, i8* }** %excinfo, align 8\n",
" %.7 = call i32 @_ZN18blackscholes_numba12blackscholesB2v1B38c8tJTIcFHzwl2ILiXkcBV0KBSgP9CGZpAgA_3dEx(i8** nonnull %.3, { i8*, i32, i8* }** nonnull %excinfo, i64 %.1) #4\n",
" %.8 = load { i8*, i32, i8* }*, { i8*, i32, i8* }** %excinfo, align 8\n",
" %.9.not = icmp eq i32 %.7, 0\n",
" %.17 = load i8*, i8** %.3, align 8\n",
" %.19 = alloca i32, align 4\n",
" store i32 0, i32* %.19, align 4\n",
" br i1 %.9.not, label %entry.endif, label %entry.if, !prof !81\n",
"\n",
"entry.if: ; preds = %entry\n",
" %.15 = icmp sgt i32 %.7, 0\n",
" call void @numba_gil_ensure(i32* nonnull %.19)\n",
" br i1 %.15, label %entry.if.if, label %entry.if.endif.endif.endif\n",
"\n",
"entry.endif: ; preds = %entry, %.22\n",
" ret i8* %.17\n",
"\n",
".22: ; preds = %entry.if.if, %entry.if.if.if, %entry.if.endif.endif.endif\n",
" %.44 = call i8* @PyUnicode_FromString(i8* getelementptr inbounds ([53 x i8], [53 x i8]* @\".const.<numba.core.cpu.CPUContext object at 0x7f3dd58009d0>\", i64 0, i64 0))\n",
" call void @PyErr_WriteUnraisable(i8* %.44)\n",
" call void @Py_DecRef(i8* %.44)\n",
" call void @numba_gil_release(i32* nonnull %.19)\n",
" br label %entry.endif\n",
"\n",
"entry.if.if: ; preds = %entry.if\n",
" call void @PyErr_Clear()\n",
" %.25 = load { i8*, i32, i8* }, { i8*, i32, i8* }* %.8, align 8\n",
" %.26 = extractvalue { i8*, i32, i8* } %.25, 0\n",
" %.28 = extractvalue { i8*, i32, i8* } %.25, 1\n",
" %.30 = extractvalue { i8*, i32, i8* } %.25, 2\n",
" %.31 = call i8* @numba_unpickle(i8* %.26, i32 %.28, i8* %.30)\n",
" %.32.not = icmp eq i8* %.31, null\n",
" br i1 %.32.not, label %.22, label %entry.if.if.if, !prof !13\n",
"\n",
"entry.if.if.if: ; preds = %entry.if.if\n",
" call void @numba_do_raise(i8* nonnull %.31)\n",
" br label %.22\n",
"\n",
"entry.if.endif.endif.endif: ; preds = %entry.if\n",
" call void @PyErr_SetString(i8* nonnull @PyExc_SystemError, i8* getelementptr inbounds ([43 x i8], [43 x i8]* @\".const.unknown error when calling native function.1\", i64 0, i64 0))\n",
" br label %.22\n",
"}\n",
"\n",
"declare void @numba_gil_ensure(i32*) local_unnamed_addr\n",
"\n",
"declare i8* @PyUnicode_FromString(i8*) local_unnamed_addr\n",
"\n",
"declare void @PyErr_WriteUnraisable(i8*) local_unnamed_addr\n",
"\n",
"declare void @numba_gil_release(i32*) local_unnamed_addr\n",
"\n",
"; Function Attrs: nounwind readnone\n",
"declare { i32, [624 x i32], i32, double, i32 }* @numba_get_np_random_state() local_unnamed_addr #2\n",
"\n",
"declare void @numba_rnd_init({ i32, [624 x i32], i32, double, i32 }*, i32) local_unnamed_addr\n",
"\n",
"declare noalias i8* @NRT_MemInfo_alloc_safe_aligned(i64, i32) local_unnamed_addr\n",
"\n",
"declare void @numba_rnd_shuffle({ i32, [624 x i32], i32, double, i32 }* nocapture) local_unnamed_addr\n",
"\n",
"; Function Attrs: argmemonly nounwind willreturn writeonly\n",
"declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) #3\n",
"\n",
"; Function Attrs: noinline\n",
"define linkonce_odr void @NRT_decref(i8* %.1) local_unnamed_addr #4 {\n",
".3:\n",
" %.4 = icmp eq i8* %.1, null\n",
" br i1 %.4, label %.3.if, label %.3.endif, !prof !13\n",
"\n",
".3.if: ; preds = %.3.endif, %.3\n",
" ret void\n",
"\n",
".3.endif: ; preds = %.3\n",
" fence release\n",
" %.8 = bitcast i8* %.1 to i64*\n",
" %.4.i = atomicrmw sub i64* %.8, i64 1 monotonic\n",
" %.10 = icmp eq i64 %.4.i, 1\n",
" br i1 %.10, label %.3.endif.if, label %.3.if, !prof !13\n",
"\n",
".3.endif.if: ; preds = %.3.endif\n",
" fence acquire\n",
" tail call void @NRT_MemInfo_call_dtor(i8* nonnull %.1)\n",
" ret void\n",
"}\n",
"\n",
"declare void @NRT_MemInfo_call_dtor(i8*) local_unnamed_addr\n",
"\n",
"; Function Attrs: nounwind readnone speculatable willreturn\n",
"declare double @llvm.fabs.f64(double) #1\n",
"\n",
"; Function Attrs: nounwind\n",
"declare void @llvm.stackprotector(i8*, i8**) #5\n",
"\n",
"attributes #0 = { nofree nounwind readonly }\n",
"attributes #1 = { nounwind readnone speculatable willreturn }\n",
"attributes #2 = { nounwind readnone }\n",
"attributes #3 = { argmemonly nounwind willreturn writeonly }\n",
"attributes #4 = { noinline }\n",
"attributes #5 = { nounwind }\n",
"\n",
"!0 = !{!1}\n",
"!1 = distinct !{!1, !2, !\"_ZN13_3cdynamic_3e94jit_wrapper__built_in_method_seed_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v2B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEx: %retptr\"}\n",
"!2 = distinct !{!2, !\"_ZN13_3cdynamic_3e94jit_wrapper__built_in_method_seed_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v2B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEx\"}\n",
"!3 = !{!4, !6, !7, !9, !10, !12}\n",
"!4 = distinct !{!4, !5, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!5 = distinct !{!5, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!6 = distinct !{!6, !5, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!7 = distinct !{!7, !8, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!8 = distinct !{!8, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!9 = distinct !{!9, !8, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!10 = distinct !{!10, !11, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx: %retptr\"}\n",
"!11 = distinct !{!11, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx\"}\n",
"!12 = distinct !{!12, !11, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx: %excinfo\"}\n",
"!13 = !{!\"branch_weights\", i32 1, i32 99}\n",
"!14 = !{!10, !12}\n",
"!15 = !{!16, !10, !12}\n",
"!16 = distinct !{!16, !17, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd: %retptr\"}\n",
"!17 = distinct !{!17, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd\"}\n",
"!18 = !{i1 true}\n",
"!19 = !{!20, !22, !23, !25, !26, !28}\n",
"!20 = distinct !{!20, !21, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!21 = distinct !{!21, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!22 = distinct !{!22, !21, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!23 = distinct !{!23, !24, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!24 = distinct !{!24, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!25 = distinct !{!25, !24, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!26 = distinct !{!26, !27, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx: %retptr\"}\n",
"!27 = distinct !{!27, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx\"}\n",
"!28 = distinct !{!28, !27, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx: %excinfo\"}\n",
"!29 = !{!26, !28}\n",
"!30 = !{!31, !26, !28}\n",
"!31 = distinct !{!31, !32, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd: %retptr\"}\n",
"!32 = distinct !{!32, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd\"}\n",
"!33 = !{!34, !36, !37, !39, !40, !42}\n",
"!34 = distinct !{!34, !35, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!35 = distinct !{!35, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!36 = distinct !{!36, !35, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!37 = distinct !{!37, !38, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!38 = distinct !{!38, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!39 = distinct !{!39, !38, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!40 = distinct !{!40, !41, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx: %retptr\"}\n",
"!41 = distinct !{!41, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx\"}\n",
"!42 = distinct !{!42, !41, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v3B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEddx: %excinfo\"}\n",
"!43 = !{!40, !42}\n",
"!44 = !{!45, !40, !42}\n",
"!45 = distinct !{!45, !46, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd: %retptr\"}\n",
"!46 = distinct !{!46, !\"_ZN13_3cdynamic_3e97jit_wrapper__built_in_method_uniform_of_numpy_random_mtrand_RandomState_object_at_0x7f3e101745a0_B2v6B44c8tJTIcFHzwl2ILiXkcBV0KBSiNFJlQEMzphEkUQTZoAEdd\"}\n",
"!47 = !{!48, !50, !51, !53, !54, !56, !57, !59}\n",
"!48 = distinct !{!48, !49, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!49 = distinct !{!49, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!50 = distinct !{!50, !49, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!51 = distinct !{!51, !52, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!52 = distinct !{!52, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!53 = distinct !{!53, !52, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!54 = distinct !{!54, !55, !\"_ZN5numba2np8arrayobj11ol_np_empty12_3clocals_3e4implB2v8B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx39Function_28_3cclass_20_27float_27_3e_29: %retptr\"}\n",
"!55 = distinct !{!55, !\"_ZN5numba2np8arrayobj11ol_np_empty12_3clocals_3e4implB2v8B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx39Function_28_3cclass_20_27float_27_3e_29\"}\n",
"!56 = distinct !{!56, !55, !\"_ZN5numba2np8arrayobj11ol_np_empty12_3clocals_3e4implB2v8B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx39Function_28_3cclass_20_27float_27_3e_29: %excinfo\"}\n",
"!57 = distinct !{!57, !58, !\"_ZN5numba2np8arrayobj11ol_np_zeros12_3clocals_3e4implB2v7B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx48omitted_28default_3d_3cclass_20_27float_27_3e_29: %retptr\"}\n",
"!58 = distinct !{!58, !\"_ZN5numba2np8arrayobj11ol_np_zeros12_3clocals_3e4implB2v7B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx48omitted_28default_3d_3cclass_20_27float_27_3e_29\"}\n",
"!59 = distinct !{!59, !58, !\"_ZN5numba2np8arrayobj11ol_np_zeros12_3clocals_3e4implB2v7B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx48omitted_28default_3d_3cclass_20_27float_27_3e_29: %excinfo\"}\n",
"!60 = !{!54, !56, !57, !59}\n",
"!61 = !{!62, !57, !59}\n",
"!62 = distinct !{!62, !63, !\"_ZN5numba2np8arrayobj18ol_array_zero_fill12_3clocals_3e4implB2v9B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dE5ArrayIdLi1E1C7mutable7alignedE: %retptr\"}\n",
"!63 = distinct !{!63, !\"_ZN5numba2np8arrayobj18ol_array_zero_fill12_3clocals_3e4implB2v9B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dE5ArrayIdLi1E1C7mutable7alignedE\"}\n",
"!64 = !{!65, !67, !68, !70, !71, !73, !74, !76}\n",
"!65 = distinct !{!65, !66, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!66 = distinct !{!66, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!67 = distinct !{!67, !66, !\"_ZN5numba2np8arrayobj18_ol_array_allocate12_3clocals_3e4implB2v5B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!68 = distinct !{!68, !69, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %retptr\"}\n",
"!69 = distinct !{!69, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj\"}\n",
"!70 = distinct !{!70, !69, !\"_ZN5numba2np8arrayobj15_call_allocatorB2v4B44c8tJTC_2fWQA9wW1DkAz0Pj1skAdT4gkkUlYBZmgA_3dEN29typeref_5b_3cclass_20_27numba4core5types8npytypes14Array_27_3e_5dExj: %excinfo\"}\n",
"!71 = distinct !{!71, !72, !\"_ZN5numba2np8arrayobj11ol_np_empty12_3clocals_3e4implB2v8B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx39Function_28_3cclass_20_27float_27_3e_29: %retptr\"}\n",
"!72 = distinct !{!72, !\"_ZN5numba2np8arrayobj11ol_np_empty12_3clocals_3e4implB2v8B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx39Function_28_3cclass_20_27float_27_3e_29\"}\n",
"!73 = distinct !{!73, !72, !\"_ZN5numba2np8arrayobj11ol_np_empty12_3clocals_3e4implB2v8B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx39Function_28_3cclass_20_27float_27_3e_29: %excinfo\"}\n",
"!74 = distinct !{!74, !75, !\"_ZN5numba2np8arrayobj11ol_np_zeros12_3clocals_3e4implB2v7B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx48omitted_28default_3d_3cclass_20_27float_27_3e_29: %retptr\"}\n",
"!75 = distinct !{!75, !\"_ZN5numba2np8arrayobj11ol_np_zeros12_3clocals_3e4implB2v7B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx48omitted_28default_3d_3cclass_20_27float_27_3e_29\"}\n",
"!76 = distinct !{!76, !75, !\"_ZN5numba2np8arrayobj11ol_np_zeros12_3clocals_3e4implB2v7B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dEx48omitted_28default_3d_3cclass_20_27float_27_3e_29: %excinfo\"}\n",
"!77 = !{!71, !73, !74, !76}\n",
"!78 = !{!79, !74, !76}\n",
"!79 = distinct !{!79, !80, !\"_ZN5numba2np8arrayobj18ol_array_zero_fill12_3clocals_3e4implB2v9B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dE5ArrayIdLi1E1C7mutable7alignedE: %retptr\"}\n",
"!80 = distinct !{!80, !\"_ZN5numba2np8arrayobj18ol_array_zero_fill12_3clocals_3e4implB2v9B42c8tJTIcFHzwl2ILiXkcBV0KBSmNGHkyiCKJEEwA_3dE5ArrayIdLi1E1C7mutable7alignedE\"}\n",
"!81 = !{!\"branch_weights\", i32 99, i32 1}\n",
"\n"
]
}
],
"source": [
"import numpy as np\n",
"print(list(blackscholes_numba.inspect_llvm().values())[0])"
]
},
{
"cell_type": "markdown",
"id": "d6bc8188-8e17-4b55-ae94-130220033a15",
"metadata": {},
"source": [
"### Understanding numba's objective\n",
"It is important to understand the core behind the library you are using. \n",
"Because otherwise you will quickly find some odd behavior you are not expecting\n",
"\n",
"`numba` is a helper to extend `numpy` without needing to write everything in C and compile it yourself. \n",
"But still getting numpy-like speeds\n",
"\n",
"numba also supports many other speed imporovements:\n",
" - vectorization for numpy user defined functions\n",
" - parallelism\n",
" - fastmath libraries with MKL\n",
" - nogil option to avoid GIL locking issues when using some types of pre-compiled code\n"
]
},
{
"cell_type": "markdown",
"id": "8e290159-14b0-42be-b9df-7d2353df9775",
"metadata": {},
"source": [
"### Limitations of what numba can understand\n",
"Numba doesn't understand everything that python can understand. It can only compile a subset of what python offers.\n",
"\n",
"It can easily handle numeric operations like `+` `-` `/` `*` `sin()` `cos()` `sqrt()` etc. \n",
"But it does not understand what `import` is"
]
},
{
"cell_type": "code",
"execution_count": 33,
"id": "8c2ca1fa-aaca-4e56-acb0-7931077e6d43",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:20:17.701724Z",
"iopub.status.busy": "2023-08-19T16:20:17.701380Z",
"iopub.status.idle": "2023-08-19T16:20:17.711942Z",
"shell.execute_reply": "2023-08-19T16:20:17.710744Z",
"shell.execute_reply.started": "2023-08-19T16:20:17.701703Z"
},
"tags": []
},
"outputs": [],
"source": [
"import numba\n",
"@numba.jit()\n",
"def myfunc():\n",
" import flask"
]
},
{
"cell_type": "code",
"execution_count": 34,
"id": "559c7742-1be2-44d3-9469-6666c8f41521",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:20:18.238222Z",
"iopub.status.busy": "2023-08-19T16:20:18.237955Z",
"iopub.status.idle": "2023-08-19T16:20:18.271090Z",
"shell.execute_reply": "2023-08-19T16:20:18.268133Z",
"shell.execute_reply.started": "2023-08-19T16:20:18.238201Z"
},
"tags": []
},
"outputs": [
{
"ename": "UnsupportedError",
"evalue": "Failed in object mode pipeline (step: analyzing bytecode)\nUse of unsupported opcode (IMPORT_NAME) found\n\nFile \"../../../../tmp/ipykernel_1833/1648081361.py\", line 4:\n<source missing, REPL/exec in use?>\n",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mUnsupportedError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m/tmp/ipykernel_1833/1200136947.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mmyfunc\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;32m~/notebooks/venv/lib/python3.7/site-packages/numba/core/dispatcher.py\u001b[0m in \u001b[0;36m_compile_for_args\u001b[0;34m(self, *args, **kws)\u001b[0m\n\u001b[1;32m 469\u001b[0m \u001b[0;32mexcept\u001b[0m \u001b[0merrors\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mUnsupportedError\u001b[0m \u001b[0;32mas\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 470\u001b[0m \u001b[0;31m# Something unsupported is present in the user code, add help info\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 471\u001b[0;31m \u001b[0merror_rewrite\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0me\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m'unsupported_error'\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 472\u001b[0m except (errors.NotDefinedError, errors.RedefinedError,\n\u001b[1;32m 473\u001b[0m errors.VerificationError) as e:\n",
"\u001b[0;32m~/notebooks/venv/lib/python3.7/site-packages/numba/core/dispatcher.py\u001b[0m in \u001b[0;36merror_rewrite\u001b[0;34m(e, issue_type)\u001b[0m\n\u001b[1;32m 407\u001b[0m \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 408\u001b[0m \u001b[0;32melse\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m--> 409\u001b[0;31m \u001b[0;32mraise\u001b[0m \u001b[0me\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mwith_traceback\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;32mNone\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m 410\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 411\u001b[0m \u001b[0margtypes\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;34m[\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
"\u001b[0;31mUnsupportedError\u001b[0m: Failed in object mode pipeline (step: analyzing bytecode)\nUse of unsupported opcode (IMPORT_NAME) found\n\nFile \"../../../../tmp/ipykernel_1833/1648081361.py\", line 4:\n<source missing, REPL/exec in use?>\n"
]
}
],
"source": [
"myfunc()"
]
},
{
"cell_type": "markdown",
"id": "cc7034d9-c95a-4c23-b366-412c4e2d8f87",
"metadata": {},
"source": [
"### Careful about corner case behaviors\n",
"Some corner case behaviors mainly when other functions are called can get confusing. \n",
"Because in such cases the way `numba` has compiled the function is not always the exact same as what python does"
]
},
{
"cell_type": "code",
"execution_count": 42,
"id": "8dc21dab-cbc1-4149-b53c-dbabd26a53fb",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:26:56.196749Z",
"iopub.status.busy": "2023-08-19T16:26:56.196482Z",
"iopub.status.idle": "2023-08-19T16:26:56.208062Z",
"shell.execute_reply": "2023-08-19T16:26:56.207104Z",
"shell.execute_reply.started": "2023-08-19T16:26:56.196726Z"
},
"tags": []
},
"outputs": [],
"source": [
"import numba\n",
"@numba.jit(nopython=True)\n",
"def myfunc(i: int):\n",
" return list(range(i))"
]
},
{
"cell_type": "code",
"execution_count": 43,
"id": "4e8de61e-9116-4c30-b77c-61f4dd43d2f9",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:26:56.776738Z",
"iopub.status.busy": "2023-08-19T16:26:56.776427Z",
"iopub.status.idle": "2023-08-19T16:26:57.168632Z",
"shell.execute_reply": "2023-08-19T16:26:57.167764Z",
"shell.execute_reply.started": "2023-08-19T16:26:56.776712Z"
},
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"[0, 1]"
]
},
"execution_count": 43,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"myfunc(2)"
]
},
{
"cell_type": "code",
"execution_count": 44,
"id": "a8afb1de-44d1-42ff-a6ba-48c0ef147b1b",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:27:00.764207Z",
"iopub.status.busy": "2023-08-19T16:27:00.762210Z",
"iopub.status.idle": "2023-08-19T16:27:00.988058Z",
"shell.execute_reply": "2023-08-19T16:27:00.986399Z",
"shell.execute_reply.started": "2023-08-19T16:27:00.764168Z"
},
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"[0, 1]"
]
},
"execution_count": 44,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"myfunc(2.1)"
]
},
{
"cell_type": "code",
"execution_count": 46,
"id": "eeb78a22-ff14-4a58-9153-8239e8cba41d",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:27:09.445450Z",
"iopub.status.busy": "2023-08-19T16:27:09.439897Z",
"iopub.status.idle": "2023-08-19T16:27:09.462870Z",
"shell.execute_reply": "2023-08-19T16:27:09.460782Z",
"shell.execute_reply.started": "2023-08-19T16:27:09.445379Z"
},
"tags": []
},
"outputs": [
{
"ename": "TypeError",
"evalue": "'float' object cannot be interpreted as an integer",
"output_type": "error",
"traceback": [
"\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m Traceback (most recent call last)",
"\u001b[0;32m/tmp/ipykernel_1833/1132305046.py\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2.1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
"\u001b[0;31mTypeError\u001b[0m: 'float' object cannot be interpreted as an integer"
]
}
],
"source": [
"list(range(2.1))"
]
},
{
"cell_type": "code",
"execution_count": 47,
"id": "9f49b70d-2b70-453c-9e64-ada72e077377",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:32:06.455814Z",
"iopub.status.busy": "2023-08-19T16:32:06.454866Z",
"iopub.status.idle": "2023-08-19T16:32:06.536598Z",
"shell.execute_reply": "2023-08-19T16:32:06.535354Z",
"shell.execute_reply.started": "2023-08-19T16:32:06.455789Z"
},
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"dict_keys([(int64,), (float64,)])"
]
},
"execution_count": 47,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"# Even though numba has actually compiled this function for both int and float\n",
"myfunc.inspect_asm().keys()"
]
},
{
"cell_type": "code",
"execution_count": 48,
"id": "17016020-5d34-431c-9ceb-b06413d5d956",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:32:26.734737Z",
"iopub.status.busy": "2023-08-19T16:32:26.734484Z",
"iopub.status.idle": "2023-08-19T16:32:26.806195Z",
"shell.execute_reply": "2023-08-19T16:32:26.805002Z",
"shell.execute_reply.started": "2023-08-19T16:32:26.734718Z"
},
"tags": []
},
"outputs": [
{
"data": {
"text/plain": [
"False"
]
},
"execution_count": 48,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"vals = list(myfunc.inspect_asm().values())\n",
"vals[0] == vals[1]"
]
},
{
"cell_type": "markdown",
"id": "13c8377b-07f0-442f-840a-9a2ae661668d",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T16:16:58.698391Z",
"iopub.status.busy": "2023-08-19T16:16:58.698136Z",
"iopub.status.idle": "2023-08-19T16:16:58.709540Z",
"shell.execute_reply": "2023-08-19T16:16:58.708717Z",
"shell.execute_reply.started": "2023-08-19T16:16:58.698371Z"
},
"tags": []
},
"source": [
"### Use numba for all functions ?\n",
"\n",
"1. Obviously if you call the function only once - it will slow down your code\n",
"2. `numba` doesn't understand all python operations - for example imports !\n",
"3. Be careful about corner cases where it may not behave as you expect"
]
},
{
"cell_type": "markdown",
"id": "4c431c3b-ae24-445c-afe7-6677515a5dc2",
"metadata": {
"tags": []
},
"source": [
"# Trying pyston-lite"
]
},
{
"cell_type": "code",
"execution_count": 13,
"id": "a087df8f-b2cf-4415-9f55-238944be5560",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:10:54.044617Z",
"iopub.status.busy": "2023-08-19T17:10:54.044287Z",
"iopub.status.idle": "2023-08-19T17:10:54.220363Z",
"shell.execute_reply": "2023-08-19T17:10:54.217611Z",
"shell.execute_reply.started": "2023-08-19T17:10:54.044597Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\u001b[0;31m*** blackscholes.py\t2023-08-19 21:39:06.344570844 +0530\u001b[0;0m\n",
"\u001b[0;32m--- blackscholes_pyston_lite.py\t2023-08-19 22:32:48.224569788 +0530\u001b[0;0m\n",
"\u001b[0;33m***************\u001b[0;0m\n",
"\u001b[0;33m*** 4,9 ****\u001b[0;0m\n",
"\u001b[0;33m--- 4,11 ----\u001b[0;0m\n",
"\u001b[0;30m \u001b[0;0m\n",
"\u001b[0;30m import math\u001b[0;0m\n",
"\u001b[0;30m import numpy as np\u001b[0;0m\n",
"\u001b[0;32m+ import pyston_lite\u001b[0;0m\n",
"\u001b[0;32m+ pyston_lite.enable()\u001b[0;0m\n",
"\u001b[0;30m \u001b[0;0m\n",
"\u001b[0;30m # Taken from numba.tests.test_blackscholes\u001b[0;0m\n",
"\u001b[0;30m N = 16384\u001b[0;0m\n"
]
}
],
"source": [
"!colordiff -c blackscholes.py blackscholes_pyston_lite.py"
]
},
{
"cell_type": "code",
"execution_count": 4,
"id": "cfa7fa34-edd6-410b-bbd2-6913282421d5",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:03:40.877144Z",
"iopub.status.busy": "2023-08-19T17:03:40.876803Z",
"iopub.status.idle": "2023-08-19T17:03:40.891755Z",
"shell.execute_reply": "2023-08-19T17:03:40.889939Z",
"shell.execute_reply.started": "2023-08-19T17:03:40.877123Z"
},
"tags": []
},
"outputs": [],
"source": [
"from blackscholes_pyston_lite import blackscholes as blackscholes_pyston_lite"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "a9b7a746-365b-44b4-99b8-da06855dcb73",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:03:41.237054Z",
"iopub.status.busy": "2023-08-19T17:03:41.236569Z",
"iopub.status.idle": "2023-08-19T17:03:41.310762Z",
"shell.execute_reply": "2023-08-19T17:03:41.306607Z",
"shell.execute_reply.started": "2023-08-19T17:03:41.237019Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 54.5 ms, sys: 8.92 ms, total: 63.4 ms\n",
"Wall time: 61 ms\n"
]
}
],
"source": [
"# First run\n",
"%time blackscholes_pyston_lite(1)"
]
},
{
"cell_type": "code",
"execution_count": 10,
"id": "268d512e-6e1d-451d-ae95-2af2d3a4b5c2",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:03:52.610470Z",
"iopub.status.busy": "2023-08-19T17:03:52.610148Z",
"iopub.status.idle": "2023-08-19T17:03:52.679481Z",
"shell.execute_reply": "2023-08-19T17:03:52.678251Z",
"shell.execute_reply.started": "2023-08-19T17:03:52.610450Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"CPU times: user 56.3 ms, sys: 3.67 ms, total: 59.9 ms\n",
"Wall time: 58.4 ms\n"
]
}
],
"source": [
"# Second run\n",
"%time blackscholes_pyston_lite(2)"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "2b2760b8-06e4-43f4-aa2d-f2e92be81328",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:04:04.580861Z",
"iopub.status.busy": "2023-08-19T17:04:04.580514Z",
"iopub.status.idle": "2023-08-19T17:04:07.723416Z",
"shell.execute_reply": "2023-08-19T17:04:07.721676Z",
"shell.execute_reply.started": "2023-08-19T17:04:04.580842Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"38.3 ms ± 1.2 ms per loop (mean ± std. dev. of 7 runs, 10 loops each)\n"
]
}
],
"source": [
"%timeit blackscholes_pyston_lite(3)"
]
},
{
"cell_type": "markdown",
"id": "3607a5a8-dac6-4ef7-9892-f2ff4d5d9953",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:09:46.175956Z",
"iopub.status.busy": "2023-08-19T17:09:46.175584Z",
"iopub.status.idle": "2023-08-19T17:09:46.189470Z",
"shell.execute_reply": "2023-08-19T17:09:46.186957Z",
"shell.execute_reply.started": "2023-08-19T17:09:46.175937Z"
},
"tags": []
},
"source": [
"### Understanding pyston-lite's objective\n",
"\n",
"Originally created by dropdbox to improve their Python API speeds.\n",
"\n",
"pyston also supports many other speed imporovements:\n",
" - Faster cached attribute access\n",
" - Bytecode Quickening\n",
"\n",
"While it `lite` package offers a basic JIT - the biggest speed improvement it gets is from cached attribute access\n",
"\n",
"Even the full Pyston project is more focused on other types of performance optimization and does not work on JIT as much."
]
},
{
"cell_type": "markdown",
"id": "b8e3616a-47ad-4307-8b73-08325f603325",
"metadata": {
"tags": []
},
"source": [
"# Let's try the trusty ol' cython\n",
"Let's try compiling it instead of using a JIT\n"
]
},
{
"cell_type": "code",
"execution_count": 1,
"id": "97f7f92e-329b-4c5c-8a55-55cd5e242c00",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T18:16:09.468309Z",
"iopub.status.busy": "2023-08-19T18:16:09.468035Z",
"iopub.status.idle": "2023-08-19T18:16:09.862260Z",
"shell.execute_reply": "2023-08-19T18:16:09.860937Z",
"shell.execute_reply.started": "2023-08-19T18:16:09.468285Z"
},
"tags": []
},
"outputs": [],
"source": [
"%load_ext Cython"
]
},
{
"cell_type": "code",
"execution_count": 26,
"id": "19a90300-f539-4ac8-a871-cf174cdc6cd7",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T17:57:09.533898Z",
"iopub.status.busy": "2023-08-19T17:57:09.532751Z",
"iopub.status.idle": "2023-08-19T17:57:11.404435Z",
"shell.execute_reply": "2023-08-19T17:57:11.399528Z",
"shell.execute_reply.started": "2023-08-19T17:57:09.533830Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First run: 43.66328400647035 ms\n",
"Second run: 44.73434000101406 ms\n"
]
},
{
"data": {
"text/html": [
"<!DOCTYPE html>\n",
"<!-- Generated by Cython 3.0.0 -->\n",
"<html>\n",
"<head>\n",
" <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n",
" <title>Cython: _cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031.pyx</title>\n",
" <style type=\"text/css\">\n",
" \n",
"body.cython { font-family: courier; font-size: 12; }\n",
"\n",
".cython.tag { }\n",
".cython.line { color: #000000; margin: 0em }\n",
".cython.code { font-size: 9; color: #444444; display: none; margin: 0px 0px 0px 8px; border-left: 8px none; }\n",
"\n",
".cython.line .run { background-color: #B0FFB0; }\n",
".cython.line .mis { background-color: #FFB0B0; }\n",
".cython.code.run { border-left: 8px solid #B0FFB0; }\n",
".cython.code.mis { border-left: 8px solid #FFB0B0; }\n",
"\n",
".cython.code .py_c_api { color: red; }\n",
".cython.code .py_macro_api { color: #FF7000; }\n",
".cython.code .pyx_c_api { color: #FF3000; }\n",
".cython.code .pyx_macro_api { color: #FF7000; }\n",
".cython.code .refnanny { color: #FFA000; }\n",
".cython.code .trace { color: #FFA000; }\n",
".cython.code .error_goto { color: #FFA000; }\n",
"\n",
".cython.code .coerce { color: #008000; border: 1px dotted #008000 }\n",
".cython.code .py_attr { color: #FF0000; font-weight: bold; }\n",
".cython.code .c_attr { color: #0000FF; }\n",
".cython.code .py_call { color: #FF0000; font-weight: bold; }\n",
".cython.code .c_call { color: #0000FF; }\n",
"\n",
".cython.score-0 {background-color: #FFFFff;}\n",
".cython.score-1 {background-color: #FFFFe7;}\n",
".cython.score-2 {background-color: #FFFFd4;}\n",
".cython.score-3 {background-color: #FFFFc4;}\n",
".cython.score-4 {background-color: #FFFFb6;}\n",
".cython.score-5 {background-color: #FFFFaa;}\n",
".cython.score-6 {background-color: #FFFF9f;}\n",
".cython.score-7 {background-color: #FFFF96;}\n",
".cython.score-8 {background-color: #FFFF8d;}\n",
".cython.score-9 {background-color: #FFFF86;}\n",
".cython.score-10 {background-color: #FFFF7f;}\n",
".cython.score-11 {background-color: #FFFF79;}\n",
".cython.score-12 {background-color: #FFFF73;}\n",
".cython.score-13 {background-color: #FFFF6e;}\n",
".cython.score-14 {background-color: #FFFF6a;}\n",
".cython.score-15 {background-color: #FFFF66;}\n",
".cython.score-16 {background-color: #FFFF62;}\n",
".cython.score-17 {background-color: #FFFF5e;}\n",
".cython.score-18 {background-color: #FFFF5b;}\n",
".cython.score-19 {background-color: #FFFF57;}\n",
".cython.score-20 {background-color: #FFFF55;}\n",
".cython.score-21 {background-color: #FFFF52;}\n",
".cython.score-22 {background-color: #FFFF4f;}\n",
".cython.score-23 {background-color: #FFFF4d;}\n",
".cython.score-24 {background-color: #FFFF4b;}\n",
".cython.score-25 {background-color: #FFFF48;}\n",
".cython.score-26 {background-color: #FFFF46;}\n",
".cython.score-27 {background-color: #FFFF44;}\n",
".cython.score-28 {background-color: #FFFF43;}\n",
".cython.score-29 {background-color: #FFFF41;}\n",
".cython.score-30 {background-color: #FFFF3f;}\n",
".cython.score-31 {background-color: #FFFF3e;}\n",
".cython.score-32 {background-color: #FFFF3c;}\n",
".cython.score-33 {background-color: #FFFF3b;}\n",
".cython.score-34 {background-color: #FFFF39;}\n",
".cython.score-35 {background-color: #FFFF38;}\n",
".cython.score-36 {background-color: #FFFF37;}\n",
".cython.score-37 {background-color: #FFFF36;}\n",
".cython.score-38 {background-color: #FFFF35;}\n",
".cython.score-39 {background-color: #FFFF34;}\n",
".cython.score-40 {background-color: #FFFF33;}\n",
".cython.score-41 {background-color: #FFFF32;}\n",
".cython.score-42 {background-color: #FFFF31;}\n",
".cython.score-43 {background-color: #FFFF30;}\n",
".cython.score-44 {background-color: #FFFF2f;}\n",
".cython.score-45 {background-color: #FFFF2e;}\n",
".cython.score-46 {background-color: #FFFF2d;}\n",
".cython.score-47 {background-color: #FFFF2c;}\n",
".cython.score-48 {background-color: #FFFF2b;}\n",
".cython.score-49 {background-color: #FFFF2b;}\n",
".cython.score-50 {background-color: #FFFF2a;}\n",
".cython.score-51 {background-color: #FFFF29;}\n",
".cython.score-52 {background-color: #FFFF29;}\n",
".cython.score-53 {background-color: #FFFF28;}\n",
".cython.score-54 {background-color: #FFFF27;}\n",
".cython.score-55 {background-color: #FFFF27;}\n",
".cython.score-56 {background-color: #FFFF26;}\n",
".cython.score-57 {background-color: #FFFF26;}\n",
".cython.score-58 {background-color: #FFFF25;}\n",
".cython.score-59 {background-color: #FFFF24;}\n",
".cython.score-60 {background-color: #FFFF24;}\n",
".cython.score-61 {background-color: #FFFF23;}\n",
".cython.score-62 {background-color: #FFFF23;}\n",
".cython.score-63 {background-color: #FFFF22;}\n",
".cython.score-64 {background-color: #FFFF22;}\n",
".cython.score-65 {background-color: #FFFF22;}\n",
".cython.score-66 {background-color: #FFFF21;}\n",
".cython.score-67 {background-color: #FFFF21;}\n",
".cython.score-68 {background-color: #FFFF20;}\n",
".cython.score-69 {background-color: #FFFF20;}\n",
".cython.score-70 {background-color: #FFFF1f;}\n",
".cython.score-71 {background-color: #FFFF1f;}\n",
".cython.score-72 {background-color: #FFFF1f;}\n",
".cython.score-73 {background-color: #FFFF1e;}\n",
".cython.score-74 {background-color: #FFFF1e;}\n",
".cython.score-75 {background-color: #FFFF1e;}\n",
".cython.score-76 {background-color: #FFFF1d;}\n",
".cython.score-77 {background-color: #FFFF1d;}\n",
".cython.score-78 {background-color: #FFFF1c;}\n",
".cython.score-79 {background-color: #FFFF1c;}\n",
".cython.score-80 {background-color: #FFFF1c;}\n",
".cython.score-81 {background-color: #FFFF1c;}\n",
".cython.score-82 {background-color: #FFFF1b;}\n",
".cython.score-83 {background-color: #FFFF1b;}\n",
".cython.score-84 {background-color: #FFFF1b;}\n",
".cython.score-85 {background-color: #FFFF1a;}\n",
".cython.score-86 {background-color: #FFFF1a;}\n",
".cython.score-87 {background-color: #FFFF1a;}\n",
".cython.score-88 {background-color: #FFFF1a;}\n",
".cython.score-89 {background-color: #FFFF19;}\n",
".cython.score-90 {background-color: #FFFF19;}\n",
".cython.score-91 {background-color: #FFFF19;}\n",
".cython.score-92 {background-color: #FFFF19;}\n",
".cython.score-93 {background-color: #FFFF18;}\n",
".cython.score-94 {background-color: #FFFF18;}\n",
".cython.score-95 {background-color: #FFFF18;}\n",
".cython.score-96 {background-color: #FFFF18;}\n",
".cython.score-97 {background-color: #FFFF17;}\n",
".cython.score-98 {background-color: #FFFF17;}\n",
".cython.score-99 {background-color: #FFFF17;}\n",
".cython.score-100 {background-color: #FFFF17;}\n",
".cython.score-101 {background-color: #FFFF16;}\n",
".cython.score-102 {background-color: #FFFF16;}\n",
".cython.score-103 {background-color: #FFFF16;}\n",
".cython.score-104 {background-color: #FFFF16;}\n",
".cython.score-105 {background-color: #FFFF16;}\n",
".cython.score-106 {background-color: #FFFF15;}\n",
".cython.score-107 {background-color: #FFFF15;}\n",
".cython.score-108 {background-color: #FFFF15;}\n",
".cython.score-109 {background-color: #FFFF15;}\n",
".cython.score-110 {background-color: #FFFF15;}\n",
".cython.score-111 {background-color: #FFFF15;}\n",
".cython.score-112 {background-color: #FFFF14;}\n",
".cython.score-113 {background-color: #FFFF14;}\n",
".cython.score-114 {background-color: #FFFF14;}\n",
".cython.score-115 {background-color: #FFFF14;}\n",
".cython.score-116 {background-color: #FFFF14;}\n",
".cython.score-117 {background-color: #FFFF14;}\n",
".cython.score-118 {background-color: #FFFF13;}\n",
".cython.score-119 {background-color: #FFFF13;}\n",
".cython.score-120 {background-color: #FFFF13;}\n",
".cython.score-121 {background-color: #FFFF13;}\n",
".cython.score-122 {background-color: #FFFF13;}\n",
".cython.score-123 {background-color: #FFFF13;}\n",
".cython.score-124 {background-color: #FFFF13;}\n",
".cython.score-125 {background-color: #FFFF12;}\n",
".cython.score-126 {background-color: #FFFF12;}\n",
".cython.score-127 {background-color: #FFFF12;}\n",
".cython.score-128 {background-color: #FFFF12;}\n",
".cython.score-129 {background-color: #FFFF12;}\n",
".cython.score-130 {background-color: #FFFF12;}\n",
".cython.score-131 {background-color: #FFFF12;}\n",
".cython.score-132 {background-color: #FFFF11;}\n",
".cython.score-133 {background-color: #FFFF11;}\n",
".cython.score-134 {background-color: #FFFF11;}\n",
".cython.score-135 {background-color: #FFFF11;}\n",
".cython.score-136 {background-color: #FFFF11;}\n",
".cython.score-137 {background-color: #FFFF11;}\n",
".cython.score-138 {background-color: #FFFF11;}\n",
".cython.score-139 {background-color: #FFFF11;}\n",
".cython.score-140 {background-color: #FFFF11;}\n",
".cython.score-141 {background-color: #FFFF10;}\n",
".cython.score-142 {background-color: #FFFF10;}\n",
".cython.score-143 {background-color: #FFFF10;}\n",
".cython.score-144 {background-color: #FFFF10;}\n",
".cython.score-145 {background-color: #FFFF10;}\n",
".cython.score-146 {background-color: #FFFF10;}\n",
".cython.score-147 {background-color: #FFFF10;}\n",
".cython.score-148 {background-color: #FFFF10;}\n",
".cython.score-149 {background-color: #FFFF10;}\n",
".cython.score-150 {background-color: #FFFF0f;}\n",
".cython.score-151 {background-color: #FFFF0f;}\n",
".cython.score-152 {background-color: #FFFF0f;}\n",
".cython.score-153 {background-color: #FFFF0f;}\n",
".cython.score-154 {background-color: #FFFF0f;}\n",
".cython.score-155 {background-color: #FFFF0f;}\n",
".cython.score-156 {background-color: #FFFF0f;}\n",
".cython.score-157 {background-color: #FFFF0f;}\n",
".cython.score-158 {background-color: #FFFF0f;}\n",
".cython.score-159 {background-color: #FFFF0f;}\n",
".cython.score-160 {background-color: #FFFF0f;}\n",
".cython.score-161 {background-color: #FFFF0e;}\n",
".cython.score-162 {background-color: #FFFF0e;}\n",
".cython.score-163 {background-color: #FFFF0e;}\n",
".cython.score-164 {background-color: #FFFF0e;}\n",
".cython.score-165 {background-color: #FFFF0e;}\n",
".cython.score-166 {background-color: #FFFF0e;}\n",
".cython.score-167 {background-color: #FFFF0e;}\n",
".cython.score-168 {background-color: #FFFF0e;}\n",
".cython.score-169 {background-color: #FFFF0e;}\n",
".cython.score-170 {background-color: #FFFF0e;}\n",
".cython.score-171 {background-color: #FFFF0e;}\n",
".cython.score-172 {background-color: #FFFF0e;}\n",
".cython.score-173 {background-color: #FFFF0d;}\n",
".cython.score-174 {background-color: #FFFF0d;}\n",
".cython.score-175 {background-color: #FFFF0d;}\n",
".cython.score-176 {background-color: #FFFF0d;}\n",
".cython.score-177 {background-color: #FFFF0d;}\n",
".cython.score-178 {background-color: #FFFF0d;}\n",
".cython.score-179 {background-color: #FFFF0d;}\n",
".cython.score-180 {background-color: #FFFF0d;}\n",
".cython.score-181 {background-color: #FFFF0d;}\n",
".cython.score-182 {background-color: #FFFF0d;}\n",
".cython.score-183 {background-color: #FFFF0d;}\n",
".cython.score-184 {background-color: #FFFF0d;}\n",
".cython.score-185 {background-color: #FFFF0d;}\n",
".cython.score-186 {background-color: #FFFF0d;}\n",
".cython.score-187 {background-color: #FFFF0c;}\n",
".cython.score-188 {background-color: #FFFF0c;}\n",
".cython.score-189 {background-color: #FFFF0c;}\n",
".cython.score-190 {background-color: #FFFF0c;}\n",
".cython.score-191 {background-color: #FFFF0c;}\n",
".cython.score-192 {background-color: #FFFF0c;}\n",
".cython.score-193 {background-color: #FFFF0c;}\n",
".cython.score-194 {background-color: #FFFF0c;}\n",
".cython.score-195 {background-color: #FFFF0c;}\n",
".cython.score-196 {background-color: #FFFF0c;}\n",
".cython.score-197 {background-color: #FFFF0c;}\n",
".cython.score-198 {background-color: #FFFF0c;}\n",
".cython.score-199 {background-color: #FFFF0c;}\n",
".cython.score-200 {background-color: #FFFF0c;}\n",
".cython.score-201 {background-color: #FFFF0c;}\n",
".cython.score-202 {background-color: #FFFF0c;}\n",
".cython.score-203 {background-color: #FFFF0b;}\n",
".cython.score-204 {background-color: #FFFF0b;}\n",
".cython.score-205 {background-color: #FFFF0b;}\n",
".cython.score-206 {background-color: #FFFF0b;}\n",
".cython.score-207 {background-color: #FFFF0b;}\n",
".cython.score-208 {background-color: #FFFF0b;}\n",
".cython.score-209 {background-color: #FFFF0b;}\n",
".cython.score-210 {background-color: #FFFF0b;}\n",
".cython.score-211 {background-color: #FFFF0b;}\n",
".cython.score-212 {background-color: #FFFF0b;}\n",
".cython.score-213 {background-color: #FFFF0b;}\n",
".cython.score-214 {background-color: #FFFF0b;}\n",
".cython.score-215 {background-color: #FFFF0b;}\n",
".cython.score-216 {background-color: #FFFF0b;}\n",
".cython.score-217 {background-color: #FFFF0b;}\n",
".cython.score-218 {background-color: #FFFF0b;}\n",
".cython.score-219 {background-color: #FFFF0b;}\n",
".cython.score-220 {background-color: #FFFF0b;}\n",
".cython.score-221 {background-color: #FFFF0b;}\n",
".cython.score-222 {background-color: #FFFF0a;}\n",
".cython.score-223 {background-color: #FFFF0a;}\n",
".cython.score-224 {background-color: #FFFF0a;}\n",
".cython.score-225 {background-color: #FFFF0a;}\n",
".cython.score-226 {background-color: #FFFF0a;}\n",
".cython.score-227 {background-color: #FFFF0a;}\n",
".cython.score-228 {background-color: #FFFF0a;}\n",
".cython.score-229 {background-color: #FFFF0a;}\n",
".cython.score-230 {background-color: #FFFF0a;}\n",
".cython.score-231 {background-color: #FFFF0a;}\n",
".cython.score-232 {background-color: #FFFF0a;}\n",
".cython.score-233 {background-color: #FFFF0a;}\n",
".cython.score-234 {background-color: #FFFF0a;}\n",
".cython.score-235 {background-color: #FFFF0a;}\n",
".cython.score-236 {background-color: #FFFF0a;}\n",
".cython.score-237 {background-color: #FFFF0a;}\n",
".cython.score-238 {background-color: #FFFF0a;}\n",
".cython.score-239 {background-color: #FFFF0a;}\n",
".cython.score-240 {background-color: #FFFF0a;}\n",
".cython.score-241 {background-color: #FFFF0a;}\n",
".cython.score-242 {background-color: #FFFF0a;}\n",
".cython.score-243 {background-color: #FFFF0a;}\n",
".cython.score-244 {background-color: #FFFF0a;}\n",
".cython.score-245 {background-color: #FFFF0a;}\n",
".cython.score-246 {background-color: #FFFF09;}\n",
".cython.score-247 {background-color: #FFFF09;}\n",
".cython.score-248 {background-color: #FFFF09;}\n",
".cython.score-249 {background-color: #FFFF09;}\n",
".cython.score-250 {background-color: #FFFF09;}\n",
".cython.score-251 {background-color: #FFFF09;}\n",
".cython.score-252 {background-color: #FFFF09;}\n",
".cython.score-253 {background-color: #FFFF09;}\n",
".cython.score-254 {background-color: #FFFF09;}\n",
"pre { line-height: 125%; }\n",
"td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
"span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
"td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
"span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
".cython .hll { background-color: #ffffcc }\n",
".cython { background: #f8f8f8; }\n",
".cython .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
".cython .err { border: 1px solid #FF0000 } /* Error */\n",
".cython .k { color: #008000; font-weight: bold } /* Keyword */\n",
".cython .o { color: #666666 } /* Operator */\n",
".cython .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
".cython .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
".cython .cp { color: #9C6500 } /* Comment.Preproc */\n",
".cython .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
".cython .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
".cython .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
".cython .gd { color: #A00000 } /* Generic.Deleted */\n",
".cython .ge { font-style: italic } /* Generic.Emph */\n",
".cython .gr { color: #E40000 } /* Generic.Error */\n",
".cython .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
".cython .gi { color: #008400 } /* Generic.Inserted */\n",
".cython .go { color: #717171 } /* Generic.Output */\n",
".cython .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
".cython .gs { font-weight: bold } /* Generic.Strong */\n",
".cython .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
".cython .gt { color: #0044DD } /* Generic.Traceback */\n",
".cython .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
".cython .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
".cython .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
".cython .kp { color: #008000 } /* Keyword.Pseudo */\n",
".cython .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
".cython .kt { color: #B00040 } /* Keyword.Type */\n",
".cython .m { color: #666666 } /* Literal.Number */\n",
".cython .s { color: #BA2121 } /* Literal.String */\n",
".cython .na { color: #687822 } /* Name.Attribute */\n",
".cython .nb { color: #008000 } /* Name.Builtin */\n",
".cython .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
".cython .no { color: #880000 } /* Name.Constant */\n",
".cython .nd { color: #AA22FF } /* Name.Decorator */\n",
".cython .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
".cython .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
".cython .nf { color: #0000FF } /* Name.Function */\n",
".cython .nl { color: #767600 } /* Name.Label */\n",
".cython .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
".cython .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
".cython .nv { color: #19177C } /* Name.Variable */\n",
".cython .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
".cython .w { color: #bbbbbb } /* Text.Whitespace */\n",
".cython .mb { color: #666666 } /* Literal.Number.Bin */\n",
".cython .mf { color: #666666 } /* Literal.Number.Float */\n",
".cython .mh { color: #666666 } /* Literal.Number.Hex */\n",
".cython .mi { color: #666666 } /* Literal.Number.Integer */\n",
".cython .mo { color: #666666 } /* Literal.Number.Oct */\n",
".cython .sa { color: #BA2121 } /* Literal.String.Affix */\n",
".cython .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
".cython .sc { color: #BA2121 } /* Literal.String.Char */\n",
".cython .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
".cython .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
".cython .s2 { color: #BA2121 } /* Literal.String.Double */\n",
".cython .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
".cython .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
".cython .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
".cython .sx { color: #008000 } /* Literal.String.Other */\n",
".cython .sr { color: #A45A77 } /* Literal.String.Regex */\n",
".cython .s1 { color: #BA2121 } /* Literal.String.Single */\n",
".cython .ss { color: #19177C } /* Literal.String.Symbol */\n",
".cython .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
".cython .fm { color: #0000FF } /* Name.Function.Magic */\n",
".cython .vc { color: #19177C } /* Name.Variable.Class */\n",
".cython .vg { color: #19177C } /* Name.Variable.Global */\n",
".cython .vi { color: #19177C } /* Name.Variable.Instance */\n",
".cython .vm { color: #19177C } /* Name.Variable.Magic */\n",
".cython .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
" </style>\n",
"</head>\n",
"<body class=\"cython\">\n",
"<p><span style=\"border-bottom: solid 1px grey;\">Generated by Cython 3.0.0</span></p>\n",
"<p>\n",
" <span style=\"background-color: #FFFF00\">Yellow lines</span> hint at Python interaction.<br />\n",
" Click on a line that starts with a \"<code>+</code>\" to see the C code that Cython generated for it.\n",
"</p>\n",
"<div class=\"cython\"><pre class=\"cython line score-8\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">01</span>: <span class=\"sd\">&quot;&quot;&quot;</span></pre>\n",
"<pre class='cython code score-8 '> __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyDict_NewPresized</span>(0);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_test, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 1, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">02</span>: <span class=\"sd\">Benchmark an implementation of the Black–Scholes model.</span></pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">03</span>: <span class=\"sd\">&quot;&quot;&quot;</span></pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">04</span>: </pre>\n",
"<pre class=\"cython line score-8\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">05</span>: <span class=\"k\">import</span> <span class=\"nn\">math</span></pre>\n",
"<pre class='cython code score-8 '> __pyx_t_2 = <span class='pyx_c_api'>__Pyx_ImportDottedModule</span>(__pyx_n_s_math, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 5, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_math, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 5, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-8\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">06</span>: <span class=\"k\">import</span> <span class=\"nn\">numpy</span> <span class=\"k\">as</span> <span class=\"nn\">np</span></pre>\n",
"<pre class='cython code score-8 '> __pyx_t_2 = <span class='pyx_c_api'>__Pyx_ImportDottedModule</span>(__pyx_n_s_numpy, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_np, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 6, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">07</span>: </pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">08</span>: <span class=\"c\"># Taken from numba.tests.test_blackscholes</span></pre>\n",
"<pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">09</span>: <span class=\"n\">N</span> <span class=\"o\">=</span> <span class=\"mf\">16384</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_N, __pyx_int_16384) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 9, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">10</span>: </pre>\n",
"<pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">11</span>: <span class=\"n\">RISKFREE</span> <span class=\"o\">=</span> <span class=\"mf\">0.02</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_RISKFREE, __pyx_float_0_02) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 11, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">12</span>: <span class=\"n\">VOLATILITY</span> <span class=\"o\">=</span> <span class=\"mf\">0.30</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_VOLATILITY, __pyx_float_0_30) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 12, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">13</span>: </pre>\n",
"<pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">14</span>: <span class=\"n\">A1</span> <span class=\"o\">=</span> <span class=\"mf\">0.31938153</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A1, __pyx_float_0_31938153) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 14, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">15</span>: <span class=\"n\">A2</span> <span class=\"o\">=</span> <span class=\"o\">-</span><span class=\"mf\">0.356563782</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A2, __pyx_float_neg_0_356563782) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 15, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">16</span>: <span class=\"n\">A3</span> <span class=\"o\">=</span> <span class=\"mf\">1.781477937</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A3, __pyx_float_1_781477937) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 16, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">17</span>: <span class=\"n\">A4</span> <span class=\"o\">=</span> <span class=\"o\">-</span><span class=\"mf\">1.821255978</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A4, __pyx_float_neg_1_821255978) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 17, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">18</span>: <span class=\"n\">A5</span> <span class=\"o\">=</span> <span class=\"mf\">1.330274429</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A5, __pyx_float_1_330274429) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 18, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">19</span>: <span class=\"n\">RSQRT2PI</span> <span class=\"o\">=</span> <span class=\"mf\">0.39894228040143267793994605993438</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_RSQRT2PI, __pyx_float_0_39894228040143267793994605993438) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 19, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">20</span>: </pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">21</span>: </pre>\n",
"<pre class=\"cython line score-68\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">22</span>: <span class=\"k\">def</span> <span class=\"nf\">cnd</span><span class=\"p\">(</span><span class=\"n\">d</span><span class=\"p\">:</span> <span class=\"nb\">float</span><span class=\"p\">):</span></pre>\n",
"<pre class='cython code score-68 '>\n",
"/* \"_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031.pyx\":22\n",
" * \n",
" * \n",
" * def cnd(d: float): # &lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;\n",
" * K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" * ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" */\n",
"\n",
"/* Python wrapper */\n",
"static PyObject *__pyx_pw_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_1cnd(PyObject *__pyx_self, \n",
"#if CYTHON_METH_FASTCALL\n",
"PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
"#else\n",
"PyObject *__pyx_args, PyObject *__pyx_kwds\n",
"#endif\n",
"); /*proto*/\n",
"static PyMethodDef __pyx_mdef_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_1cnd = {\"cnd\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_1cnd, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
"static PyObject *__pyx_pw_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_1cnd(PyObject *__pyx_self, \n",
"#if CYTHON_METH_FASTCALL\n",
"PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
"#else\n",
"PyObject *__pyx_args, PyObject *__pyx_kwds\n",
"#endif\n",
") {\n",
" double __pyx_v_d;\n",
" #if !CYTHON_METH_FASTCALL\n",
" CYTHON_UNUSED const Py_ssize_t __pyx_nargs = <span class='py_macro_api'>PyTuple_GET_SIZE</span>(__pyx_args);\n",
" #endif\n",
" CYTHON_UNUSED PyObject *const *__pyx_kwvalues = <span class='pyx_c_api'>__Pyx_KwValues_FASTCALL</span>(__pyx_args, __pyx_nargs);\n",
" PyObject *__pyx_r = 0;\n",
" <span class='refnanny'>__Pyx_RefNannyDeclarations</span>\n",
" <span class='refnanny'>__Pyx_RefNannySetupContext</span>(\"cnd (wrapper)\", 0);\n",
" {\n",
" PyObject **__pyx_pyargnames[] = {&amp;__pyx_n_s_d,0};\n",
" PyObject* values[1] = {0};\n",
" if (__pyx_kwds) {\n",
" Py_ssize_t kw_args;\n",
" switch (__pyx_nargs) {\n",
" case 1: values[0] = <span class='pyx_c_api'>__Pyx_Arg_FASTCALL</span>(__pyx_args, 0);\n",
" CYTHON_FALLTHROUGH;\n",
" case 0: break;\n",
" default: goto __pyx_L5_argtuple_error;\n",
" }\n",
" kw_args = <span class='pyx_c_api'>__Pyx_NumKwargs_FASTCALL</span>(__pyx_kwds);\n",
" switch (__pyx_nargs) {\n",
" case 0:\n",
" if (likely((values[0] = <span class='pyx_c_api'>__Pyx_GetKwValue_FASTCALL</span>(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_d)) != 0)) kw_args--;\n",
" else if (unlikely(<span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 22, __pyx_L3_error)</span>\n",
" else goto __pyx_L5_argtuple_error;\n",
" }\n",
" if (unlikely(kw_args &gt; 0)) {\n",
" const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
" if (unlikely(<span class='pyx_c_api'>__Pyx_ParseOptionalKeywords</span>(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"cnd\") &lt; 0)) <span class='error_goto'>__PYX_ERR(0, 22, __pyx_L3_error)</span>\n",
" }\n",
" } else if (unlikely(__pyx_nargs != 1)) {\n",
" goto __pyx_L5_argtuple_error;\n",
" } else {\n",
" values[0] = <span class='pyx_c_api'>__Pyx_Arg_FASTCALL</span>(__pyx_args, 0);\n",
" }\n",
" __pyx_v_d = __pyx_<span class='py_c_api'>PyFloat_AsDouble</span>(values[0]); if (unlikely((__pyx_v_d == (double)-1) &amp;&amp; <span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 22, __pyx_L3_error)</span>\n",
" }\n",
" goto __pyx_L4_argument_unpacking_done;\n",
" __pyx_L5_argtuple_error:;\n",
" <span class='pyx_c_api'>__Pyx_RaiseArgtupleInvalid</span>(\"cnd\", 1, 1, 1, __pyx_nargs); <span class='error_goto'>__PYX_ERR(0, 22, __pyx_L3_error)</span>\n",
" __pyx_L3_error:;\n",
" <span class='pyx_c_api'>__Pyx_AddTraceback</span>(\"_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031.cnd\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return NULL;\n",
" __pyx_L4_argument_unpacking_done:;\n",
" __pyx_r = __pyx_pf_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_cnd(__pyx_self, __pyx_v_d);\n",
" int __pyx_lineno = 0;\n",
" const char *__pyx_filename = NULL;\n",
" int __pyx_clineno = 0;\n",
"\n",
" /* function exit code */\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return __pyx_r;\n",
"}\n",
"\n",
"static PyObject *__pyx_pf_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_cnd(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_d) {\n",
" PyObject *__pyx_v_K = NULL;\n",
" PyObject *__pyx_v_ret_val = NULL;\n",
" PyObject *__pyx_r = NULL;\n",
" <span class='refnanny'>__Pyx_RefNannyDeclarations</span>\n",
" <span class='refnanny'>__Pyx_RefNannySetupContext</span>(\"cnd\", 0);\n",
"\n",
" /* \"_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031.pyx\":22\n",
" * \n",
" * \n",
" * def cnd(d: float): # &lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;\n",
" * K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" * ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" */\n",
"\n",
" /* function exit code */\n",
" __pyx_L1_error:;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_6);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_7);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_8);\n",
" <span class='pyx_c_api'>__Pyx_AddTraceback</span>(\"_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031.cnd\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
" __pyx_r = NULL;\n",
" __pyx_L0:;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_K);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_ret_val);\n",
" <span class='refnanny'>__Pyx_XGIVEREF</span>(__pyx_r);\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return __pyx_r;\n",
"}\n",
"\n",
" /* \"_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031.pyx\":22\n",
" * \n",
" * \n",
" * def cnd(d: float): # &lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;\n",
" * K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" * ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" */\n",
" __pyx_tuple__2 = <span class='py_c_api'>PyTuple_Pack</span>(3, __pyx_n_s_d, __pyx_n_s_K, __pyx_n_s_ret_val);<span class='error_goto'> if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 22, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_tuple__2);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_tuple__2);\n",
"\n",
" /* \"_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031.pyx\":22\n",
" * \n",
" * \n",
" * def cnd(d: float): # &lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;\n",
" * K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" * ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" */\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyDict_NewPresized</span>(1);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 22, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_t_2, __pyx_n_s_d, __pyx_n_s_float) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 22, __pyx_L1_error)</span>\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_CyFunction_New</span>(&amp;__pyx_mdef_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_1cnd, 0, __pyx_n_s_cnd, NULL, __pyx_n_s_cython_magic_b1044d883c126ef973, __pyx_d, ((PyObject *)__pyx_codeobj__3));<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 22, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_c_api'>__Pyx_CyFunction_SetAnnotationsDict</span>(__pyx_t_3, __pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_cnd, __pyx_t_3) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 22, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_codeobj__3 = (PyObject*)<span class='pyx_c_api'>__Pyx_PyCode_New</span>(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_abdealiloko_cache_ipython, __pyx_n_s_cnd, 22, __pyx_empty_bytes);<span class='error_goto'> if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 22, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-37\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">23</span>: <span class=\"n\">K</span> <span class=\"o\">=</span> <span class=\"mf\">1.0</span> <span class=\"o\">/</span> <span class=\"p\">(</span><span class=\"mf\">1.0</span> <span class=\"o\">+</span> <span class=\"mf\">0.2316419</span> <span class=\"o\">*</span> <span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">fabs</span><span class=\"p\">(</span><span class=\"n\">d</span><span class=\"p\">))</span></pre>\n",
"<pre class='cython code score-37 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_math);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_fabs);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_d);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_3))) {\n",
" __pyx_t_4 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_3);\n",
" if (likely(__pyx_t_4)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_3, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_2};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" }\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_float_0_2316419, __pyx_t_1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyFloat_AddCObj</span>(__pyx_float_1_0, __pyx_t_3, 1.0, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyFloat_TrueDivideCObj</span>(__pyx_float_1_0, __pyx_t_1, 1.0, 0, 1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" __pyx_v_K = __pyx_t_3;\n",
" __pyx_t_3 = 0;\n",
"</pre><pre class=\"cython line score-41\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">24</span>: <span class=\"n\">ret_val</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">RSQRT2PI</span> <span class=\"o\">*</span> <span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">exp</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"mf\">0.5</span> <span class=\"o\">*</span> <span class=\"n\">d</span> <span class=\"o\">*</span> <span class=\"n\">d</span><span class=\"p\">)</span> <span class=\"o\">*</span></pre>\n",
"<pre class='cython code score-41 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_RSQRT2PI);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 24, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_math);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_exp);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 24, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='py_c_api'>PyFloat_FromDouble</span>(((-0.5 * __pyx_v_d) * __pyx_v_d));<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 24, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_6 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_4))) {\n",
" __pyx_t_6 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_4);\n",
" if (likely(__pyx_t_6)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_6);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_4, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_6, __pyx_t_2};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_4, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_6); __pyx_t_6 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 24, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" }\n",
" __pyx_t_4 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_3, __pyx_t_1);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 24, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
"/* … */\n",
" __pyx_t_7 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_4, __pyx_t_8);<span class='error_goto'> if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 24, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_7);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_8); __pyx_t_8 = 0;\n",
" __pyx_v_ret_val = __pyx_t_7;\n",
" __pyx_t_7 = 0;\n",
"</pre><pre class=\"cython line score-68\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">25</span>: <span class=\"p\">(</span><span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"n\">A1</span> <span class=\"o\">+</span> <span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"n\">A2</span> <span class=\"o\">+</span> <span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"n\">A3</span> <span class=\"o\">+</span> <span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"n\">A4</span> <span class=\"o\">+</span> <span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"n\">A5</span><span class=\"p\">))))))</span></pre>\n",
"<pre class='cython code score-68 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_1, __pyx_n_s_A1);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_A2);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_A3);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_6, __pyx_n_s_A4);<span class='error_goto'> if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_6);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_7, __pyx_n_s_A5);<span class='error_goto'> if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_7);\n",
" __pyx_t_8 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_v_K, __pyx_t_7);<span class='error_goto'> if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_8);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_7); __pyx_t_7 = 0;\n",
" __pyx_t_7 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_6, __pyx_t_8);<span class='error_goto'> if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_7);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_6); __pyx_t_6 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_8); __pyx_t_8 = 0;\n",
" __pyx_t_8 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_v_K, __pyx_t_7);<span class='error_goto'> if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_8);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_7); __pyx_t_7 = 0;\n",
" __pyx_t_7 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_2, __pyx_t_8);<span class='error_goto'> if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_7);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_8); __pyx_t_8 = 0;\n",
" __pyx_t_8 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_v_K, __pyx_t_7);<span class='error_goto'> if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_8);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_7); __pyx_t_7 = 0;\n",
" __pyx_t_7 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_3, __pyx_t_8);<span class='error_goto'> if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_7);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_8); __pyx_t_8 = 0;\n",
" __pyx_t_8 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_v_K, __pyx_t_7);<span class='error_goto'> if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_8);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_7); __pyx_t_7 = 0;\n",
" __pyx_t_7 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_1, __pyx_t_8);<span class='error_goto'> if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_7);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_8); __pyx_t_8 = 0;\n",
" __pyx_t_8 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_v_K, __pyx_t_7);<span class='error_goto'> if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_8);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_7); __pyx_t_7 = 0;\n",
"</pre><pre class=\"cython line score-0\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">26</span>: <span class=\"k\">if</span> <span class=\"n\">d</span> <span class=\"o\">&gt;</span> <span class=\"mf\">0</span><span class=\"p\">:</span></pre>\n",
"<pre class='cython code score-0 '> __pyx_t_9 = (__pyx_v_d &gt; 0.0);\n",
" if (__pyx_t_9) {\n",
"/* … */\n",
" }\n",
"</pre><pre class=\"cython line score-3\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">27</span>: <span class=\"n\">ret_val</span> <span class=\"o\">=</span> <span class=\"mf\">1.0</span> <span class=\"o\">-</span> <span class=\"n\">ret_val</span></pre>\n",
"<pre class='cython code score-3 '> __pyx_t_7 = <span class='pyx_c_api'>__Pyx_PyFloat_SubtractCObj</span>(__pyx_float_1_0, __pyx_v_ret_val, 1.0, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 27, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_7);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_v_ret_val, __pyx_t_7);\n",
" __pyx_t_7 = 0;\n",
"</pre><pre class=\"cython line score-2\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">28</span>: <span class=\"k\">return</span> <span class=\"n\">ret_val</span></pre>\n",
"<pre class='cython code score-2 '> <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_r);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_v_ret_val);\n",
" __pyx_r = __pyx_v_ret_val;\n",
" goto __pyx_L0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">29</span>: </pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">30</span>: </pre>\n",
"<pre class=\"cython line score-70\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">31</span>: <span class=\"k\">def</span> <span class=\"nf\">blackscholes</span><span class=\"p\">(</span><span class=\"n\">seed</span><span class=\"p\">:</span> <span class=\"nb\">int</span><span class=\"p\">):</span></pre>\n",
"<pre class='cython code score-70 '>/* Python wrapper */\n",
"static PyObject *__pyx_pw_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_3blackscholes(PyObject *__pyx_self, \n",
"#if CYTHON_METH_FASTCALL\n",
"PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
"#else\n",
"PyObject *__pyx_args, PyObject *__pyx_kwds\n",
"#endif\n",
"); /*proto*/\n",
"static PyMethodDef __pyx_mdef_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_3blackscholes = {\"blackscholes\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_3blackscholes, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
"static PyObject *__pyx_pw_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_3blackscholes(PyObject *__pyx_self, \n",
"#if CYTHON_METH_FASTCALL\n",
"PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
"#else\n",
"PyObject *__pyx_args, PyObject *__pyx_kwds\n",
"#endif\n",
") {\n",
" PyObject *__pyx_v_seed = 0;\n",
" #if !CYTHON_METH_FASTCALL\n",
" CYTHON_UNUSED const Py_ssize_t __pyx_nargs = <span class='py_macro_api'>PyTuple_GET_SIZE</span>(__pyx_args);\n",
" #endif\n",
" CYTHON_UNUSED PyObject *const *__pyx_kwvalues = <span class='pyx_c_api'>__Pyx_KwValues_FASTCALL</span>(__pyx_args, __pyx_nargs);\n",
" PyObject *__pyx_r = 0;\n",
" <span class='refnanny'>__Pyx_RefNannyDeclarations</span>\n",
" <span class='refnanny'>__Pyx_RefNannySetupContext</span>(\"blackscholes (wrapper)\", 0);\n",
" {\n",
" PyObject **__pyx_pyargnames[] = {&amp;__pyx_n_s_seed,0};\n",
" PyObject* values[1] = {0};\n",
" if (__pyx_kwds) {\n",
" Py_ssize_t kw_args;\n",
" switch (__pyx_nargs) {\n",
" case 1: values[0] = <span class='pyx_c_api'>__Pyx_Arg_FASTCALL</span>(__pyx_args, 0);\n",
" CYTHON_FALLTHROUGH;\n",
" case 0: break;\n",
" default: goto __pyx_L5_argtuple_error;\n",
" }\n",
" kw_args = <span class='pyx_c_api'>__Pyx_NumKwargs_FASTCALL</span>(__pyx_kwds);\n",
" switch (__pyx_nargs) {\n",
" case 0:\n",
" if (likely((values[0] = <span class='pyx_c_api'>__Pyx_GetKwValue_FASTCALL</span>(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_seed)) != 0)) kw_args--;\n",
" else if (unlikely(<span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 31, __pyx_L3_error)</span>\n",
" else goto __pyx_L5_argtuple_error;\n",
" }\n",
" if (unlikely(kw_args &gt; 0)) {\n",
" const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
" if (unlikely(<span class='pyx_c_api'>__Pyx_ParseOptionalKeywords</span>(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"blackscholes\") &lt; 0)) <span class='error_goto'>__PYX_ERR(0, 31, __pyx_L3_error)</span>\n",
" }\n",
" } else if (unlikely(__pyx_nargs != 1)) {\n",
" goto __pyx_L5_argtuple_error;\n",
" } else {\n",
" values[0] = <span class='pyx_c_api'>__Pyx_Arg_FASTCALL</span>(__pyx_args, 0);\n",
" }\n",
" __pyx_v_seed = ((PyObject*)values[0]);\n",
" }\n",
" goto __pyx_L4_argument_unpacking_done;\n",
" __pyx_L5_argtuple_error:;\n",
" <span class='pyx_c_api'>__Pyx_RaiseArgtupleInvalid</span>(\"blackscholes\", 1, 1, 1, __pyx_nargs); <span class='error_goto'>__PYX_ERR(0, 31, __pyx_L3_error)</span>\n",
" __pyx_L3_error:;\n",
" <span class='pyx_c_api'>__Pyx_AddTraceback</span>(\"_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031.blackscholes\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return NULL;\n",
" __pyx_L4_argument_unpacking_done:;\n",
" if (unlikely(!<span class='pyx_c_api'>__Pyx_ArgTypeTest</span>(((PyObject *)__pyx_v_seed), (&amp;PyInt_Type), 0, \"seed\", 1))) <span class='error_goto'>__PYX_ERR(0, 31, __pyx_L1_error)</span>\n",
" __pyx_r = __pyx_pf_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_2blackscholes(__pyx_self, __pyx_v_seed);\n",
" int __pyx_lineno = 0;\n",
" const char *__pyx_filename = NULL;\n",
" int __pyx_clineno = 0;\n",
"\n",
" /* function exit code */\n",
" goto __pyx_L0;\n",
" __pyx_L1_error:;\n",
" __pyx_r = NULL;\n",
" __pyx_L0:;\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return __pyx_r;\n",
"}\n",
"\n",
"static PyObject *__pyx_pf_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_2blackscholes(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_seed) {\n",
" PyObject *__pyx_v_R = NULL;\n",
" PyObject *__pyx_v_V = NULL;\n",
" PyObject *__pyx_v_S = NULL;\n",
" PyObject *__pyx_v_X = NULL;\n",
" PyObject *__pyx_v_T = NULL;\n",
" PyObject *__pyx_v_callResult = NULL;\n",
" PyObject *__pyx_v_putResult = NULL;\n",
" Py_ssize_t __pyx_v_i;\n",
" PyObject *__pyx_v_sqrtT = NULL;\n",
" PyObject *__pyx_v_d1 = NULL;\n",
" PyObject *__pyx_v_d2 = NULL;\n",
" PyObject *__pyx_v_cndd1 = NULL;\n",
" PyObject *__pyx_v_cndd2 = NULL;\n",
" PyObject *__pyx_v_expRT = NULL;\n",
" PyObject *__pyx_r = NULL;\n",
" <span class='refnanny'>__Pyx_RefNannyDeclarations</span>\n",
" <span class='refnanny'>__Pyx_RefNannySetupContext</span>(\"blackscholes\", 0);\n",
"/* … */\n",
" /* function exit code */\n",
" __pyx_r = Py_None; <span class='pyx_macro_api'>__Pyx_INCREF</span>(Py_None);\n",
" goto __pyx_L0;\n",
" __pyx_L1_error:;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_9);\n",
" <span class='pyx_c_api'>__Pyx_AddTraceback</span>(\"_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031.blackscholes\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
" __pyx_r = NULL;\n",
" __pyx_L0:;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_R);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_V);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_S);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_X);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_T);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_callResult);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_putResult);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_sqrtT);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_d1);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_d2);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_cndd1);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_cndd2);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_expRT);\n",
" <span class='refnanny'>__Pyx_XGIVEREF</span>(__pyx_r);\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return __pyx_r;\n",
"}\n",
"/* … */\n",
" __pyx_tuple__4 = <span class='py_c_api'>PyTuple_Pack</span>(15, __pyx_n_s_seed, __pyx_n_s_R, __pyx_n_s_V, __pyx_n_s_S, __pyx_n_s_X, __pyx_n_s_T, __pyx_n_s_callResult, __pyx_n_s_putResult, __pyx_n_s_i, __pyx_n_s_sqrtT, __pyx_n_s_d1, __pyx_n_s_d2, __pyx_n_s_cndd1, __pyx_n_s_cndd2, __pyx_n_s_expRT);<span class='error_goto'> if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 31, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_tuple__4);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_tuple__4);\n",
"/* … */\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyDict_NewPresized</span>(1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 31, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_t_3, __pyx_n_s_seed, __pyx_n_s_int) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 31, __pyx_L1_error)</span>\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_CyFunction_New</span>(&amp;__pyx_mdef_54_cython_magic_b1044d883c126ef973d5d8335d5af90d85a60031_3blackscholes, 0, __pyx_n_s_blackscholes, NULL, __pyx_n_s_cython_magic_b1044d883c126ef973, __pyx_d, ((PyObject *)__pyx_codeobj__5));<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 31, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_c_api'>__Pyx_CyFunction_SetAnnotationsDict</span>(__pyx_t_2, __pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_blackscholes, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 31, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_codeobj__5 = (PyObject*)<span class='pyx_c_api'>__Pyx_PyCode_New</span>(1, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_abdealiloko_cache_ipython, __pyx_n_s_blackscholes, 31, __pyx_empty_bytes);<span class='error_goto'> if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 31, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-2\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">32</span>: <span class=\"n\">R</span> <span class=\"o\">=</span> <span class=\"n\">RISKFREE</span></pre>\n",
"<pre class='cython code score-2 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_1, __pyx_n_s_RISKFREE);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 32, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_v_R = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-2\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">33</span>: <span class=\"n\">V</span> <span class=\"o\">=</span> <span class=\"n\">VOLATILITY</span></pre>\n",
"<pre class='cython code score-2 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_1, __pyx_n_s_VOLATILITY);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_v_V = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-23\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">34</span>: <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">seed</span><span class=\"p\">(</span><span class=\"n\">seed</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-23 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_random);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 34, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_seed);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 34, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; likely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_3 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_3)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_3, __pyx_v_seed};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 34, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-25\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">35</span>: <span class=\"n\">S</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">uniform</span><span class=\"p\">(</span><span class=\"mf\">5.0</span><span class=\"p\">,</span> <span class=\"mf\">30.0</span><span class=\"p\">,</span> <span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-25 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_random);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_uniform);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_5 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; likely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_5 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_5)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_float_5_0, __pyx_float_30_0, __pyx_t_3};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 3+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" __pyx_v_S = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-25\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">36</span>: <span class=\"n\">X</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">uniform</span><span class=\"p\">(</span><span class=\"mf\">1.0</span><span class=\"p\">,</span> <span class=\"mf\">100.0</span><span class=\"p\">,</span> <span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-25 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_random);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_uniform);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_5 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; likely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_5 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_5)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_float_1_0, __pyx_float_100_0, __pyx_t_3};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 3+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" __pyx_v_X = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-25\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">37</span>: <span class=\"n\">T</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">uniform</span><span class=\"p\">(</span><span class=\"mf\">0.25</span><span class=\"p\">,</span> <span class=\"mf\">10.0</span><span class=\"p\">,</span> <span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-25 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_random);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_uniform);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_5 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; likely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_5 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_5)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[4] = {__pyx_t_5, __pyx_float_0_25, __pyx_float_10_0, __pyx_t_3};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 3+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" __pyx_v_T = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">38</span>: </pre>\n",
"<pre class=\"cython line score-22\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">39</span>: <span class=\"n\">callResult</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">zeros</span><span class=\"p\">(</span><span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-22 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_zeros);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 39, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 39, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_5 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_3))) {\n",
" __pyx_t_5 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_3);\n",
" if (likely(__pyx_t_5)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_3, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_2};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 39, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" }\n",
" __pyx_v_callResult = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-22\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">40</span>: <span class=\"n\">putResult</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">zeros</span><span class=\"p\">(</span><span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-22 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 40, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_zeros);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 40, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_5 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_5 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_5)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_3};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 40, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" __pyx_v_putResult = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">41</span>: </pre>\n",
"<pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">42</span>: <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">)):</span></pre>\n",
"<pre class='cython code score-5 '> __pyx_t_6 = <span class='py_c_api'>PyObject_Length</span>(__pyx_v_S);<span class='error_goto'> if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 42, __pyx_L1_error)</span>\n",
" __pyx_t_7 = __pyx_t_6;\n",
" for (__pyx_t_8 = 0; __pyx_t_8 &lt; __pyx_t_7; __pyx_t_8+=1) {\n",
" __pyx_v_i = __pyx_t_8;\n",
"</pre><pre class=\"cython line score-23\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">43</span>: <span class=\"n\">sqrtT</span> <span class=\"o\">=</span> <span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">sqrt</span><span class=\"p\">(</span><span class=\"n\">T</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">])</span></pre>\n",
"<pre class='cython code score-23 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_math);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_sqrt);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 43, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_T, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 43, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_5 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_3))) {\n",
" __pyx_t_5 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_3);\n",
" if (likely(__pyx_t_5)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_3, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_2};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_3, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 43, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" }\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_sqrtT, __pyx_t_1);\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-71\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">44</span>: <span class=\"n\">d1</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">log</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">/</span> <span class=\"n\">X</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">])</span> <span class=\"o\">+</span> <span class=\"p\">(</span><span class=\"n\">R</span> <span class=\"o\">+</span> <span class=\"mf\">0.5</span> <span class=\"o\">*</span> <span class=\"n\">V</span> <span class=\"o\">*</span> <span class=\"n\">V</span><span class=\"p\">)</span> <span class=\"o\">*</span> <span class=\"n\">T</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">])</span> <span class=\"o\">/</span> <span class=\"p\">(</span><span class=\"n\">V</span> <span class=\"o\">*</span> <span class=\"n\">sqrtT</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-71 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_math);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_log);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_S, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_5 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_X, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" __pyx_t_9 = <span class='pyx_c_api'>__Pyx_PyNumber_Divide</span>(__pyx_t_3, __pyx_t_5);<span class='error_goto'> if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" __pyx_t_5 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_5 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_5)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_5, __pyx_t_9};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" __pyx_t_2 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_float_0_5, __pyx_v_V);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_9 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_2, __pyx_v_V);<span class='error_goto'> if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_v_R, __pyx_t_9);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" __pyx_t_9 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_T, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_9);\n",
" __pyx_t_5 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_2, __pyx_t_9);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" __pyx_t_9 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_1, __pyx_t_5);<span class='error_goto'> if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" __pyx_t_5 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_v_V, __pyx_v_sqrtT);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyNumber_Divide</span>(__pyx_t_9, __pyx_t_5);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_d1, __pyx_t_1);\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-12\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">45</span>: <span class=\"n\">d2</span> <span class=\"o\">=</span> <span class=\"n\">d1</span> <span class=\"o\">-</span> <span class=\"n\">V</span> <span class=\"o\">*</span> <span class=\"n\">sqrtT</span></pre>\n",
"<pre class='cython code score-12 '> __pyx_t_1 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_v_V, __pyx_v_sqrtT);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_5 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_v_d1, __pyx_t_1);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_d2, __pyx_t_5);\n",
" __pyx_t_5 = 0;\n",
"</pre><pre class=\"cython line score-17\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">46</span>: <span class=\"n\">cndd1</span> <span class=\"o\">=</span> <span class=\"n\">cnd</span><span class=\"p\">(</span><span class=\"n\">d1</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-17 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_1, __pyx_n_s_cnd);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 46, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_9 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_1))) {\n",
" __pyx_t_9 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_1);\n",
" if (likely(__pyx_t_9)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_1, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_d1};\n",
" __pyx_t_5 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" if (unlikely(!__pyx_t_5)) <span class='error_goto'>__PYX_ERR(0, 46, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" }\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_cndd1, __pyx_t_5);\n",
" __pyx_t_5 = 0;\n",
"</pre><pre class=\"cython line score-17\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">47</span>: <span class=\"n\">cndd2</span> <span class=\"o\">=</span> <span class=\"n\">cnd</span><span class=\"p\">(</span><span class=\"n\">d2</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-17 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_1, __pyx_n_s_cnd);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 47, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_9 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_1))) {\n",
" __pyx_t_9 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_1);\n",
" if (likely(__pyx_t_9)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_1, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_9, __pyx_v_d2};\n",
" __pyx_t_5 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_1, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" if (unlikely(!__pyx_t_5)) <span class='error_goto'>__PYX_ERR(0, 47, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" }\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_cndd2, __pyx_t_5);\n",
" __pyx_t_5 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">48</span>: </pre>\n",
"<pre class=\"cython line score-35\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">49</span>: <span class=\"n\">expRT</span> <span class=\"o\">=</span> <span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">exp</span><span class=\"p\">((</span><span class=\"o\">-</span><span class=\"mf\">1.</span> <span class=\"o\">*</span> <span class=\"n\">R</span><span class=\"p\">)</span> <span class=\"o\">*</span> <span class=\"n\">T</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">])</span></pre>\n",
"<pre class='cython code score-35 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_1, __pyx_n_s_math);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_9 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_1, __pyx_n_s_exp);<span class='error_goto'> if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 49, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" __pyx_t_1 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_float_neg_1_, __pyx_v_R);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 49, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_T, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 49, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_1, __pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 49, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = NULL;\n",
" __pyx_t_4 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_9))) {\n",
" __pyx_t_2 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_9);\n",
" if (likely(__pyx_t_2)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_9, function);\n",
" __pyx_t_4 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_2, __pyx_t_3};\n",
" __pyx_t_5 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_9, __pyx_callargs+1-__pyx_t_4, 1+__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_5)) <span class='error_goto'>__PYX_ERR(0, 49, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" }\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_expRT, __pyx_t_5);\n",
" __pyx_t_5 = 0;\n",
"</pre><pre class=\"cython line score-32\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">50</span>: <span class=\"n\">callResult</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"n\">cndd1</span> <span class=\"o\">-</span> <span class=\"n\">X</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"n\">expRT</span> <span class=\"o\">*</span> <span class=\"n\">cndd2</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-32 '> __pyx_t_5 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_S, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" __pyx_t_9 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_5, __pyx_v_cndd1);<span class='error_goto'> if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" __pyx_t_5 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_X, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_5, __pyx_v_expRT);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" __pyx_t_5 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_3, __pyx_v_cndd2);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_t_9, __pyx_t_5);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" if (unlikely((<span class='pyx_c_api'>__Pyx_SetItemInt</span>(__pyx_v_callResult, __pyx_v_i, __pyx_t_3, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) &lt; 0))) <span class='error_goto'>__PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
"</pre><pre class=\"cython line score-38\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">51</span>: <span class=\"n\">putResult</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">X</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"n\">expRT</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"mf\">1.0</span> <span class=\"o\">-</span> <span class=\"n\">cndd2</span><span class=\"p\">)</span> <span class=\"o\">-</span> <span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"mf\">1.0</span> <span class=\"o\">-</span> <span class=\"n\">cndd1</span><span class=\"p\">))</span></pre>\n",
"<pre class='cython code score-38 '> __pyx_t_3 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_X, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_5 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_3, __pyx_v_expRT);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyFloat_SubtractCObj</span>(__pyx_float_1_0, __pyx_v_cndd2, 1.0, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_9 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_5, __pyx_t_3);<span class='error_goto'> if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_S, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_5 = <span class='pyx_c_api'>__Pyx_PyFloat_SubtractCObj</span>(__pyx_float_1_0, __pyx_v_cndd1, 1.0, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" __pyx_t_2 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_3, __pyx_t_5);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" __pyx_t_5 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_t_9, __pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (unlikely((<span class='pyx_c_api'>__Pyx_SetItemInt</span>(__pyx_v_putResult, __pyx_v_i, __pyx_t_5, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) &lt; 0))) <span class='error_goto'>__PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" }\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">52</span>: </pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">53</span>: <span class=\"c\">#######################</span></pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">54</span>: <span class=\"c\"># Benchmark</span></pre>\n",
"<pre class=\"cython line score-8\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">55</span>: <span class=\"k\">import</span> <span class=\"nn\">time</span></pre>\n",
"<pre class='cython code score-8 '> __pyx_t_2 = <span class='pyx_c_api'>__Pyx_ImportDottedModule</span>(__pyx_n_s_time, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 55, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_time, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 55, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">56</span>: </pre>\n",
"<pre class=\"cython line score-14\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">57</span>: <span class=\"n\">start</span> <span class=\"o\">=</span> <span class=\"n\">time</span><span class=\"o\">.</span><span class=\"n\">perf_counter</span><span class=\"p\">()</span></pre>\n",
"<pre class='cython code score-14 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_time);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_perf_counter);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 57, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_CallNoArg</span>(__pyx_t_3);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 57, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_start, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 57, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-11\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">58</span>: <span class=\"n\">blackscholes</span><span class=\"p\">(</span><span class=\"mf\">1</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-11 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_blackscholes);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_t_2, __pyx_tuple__6, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
"/* … */\n",
" __pyx_tuple__6 = <span class='py_c_api'>PyTuple_Pack</span>(1, __pyx_int_1);<span class='error_goto'> if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 58, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_tuple__6);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_tuple__6);\n",
"</pre><pre class=\"cython line score-23\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">59</span>: <span class=\"n\">duration</span> <span class=\"o\">=</span> <span class=\"n\">time</span><span class=\"o\">.</span><span class=\"n\">perf_counter</span><span class=\"p\">()</span> <span class=\"o\">-</span> <span class=\"n\">start</span></pre>\n",
"<pre class='cython code score-23 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_time);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 59, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_perf_counter);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_CallNoArg</span>(__pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 59, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_start);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_t_3, __pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 59, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_duration, __pyx_t_4) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 59, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
"</pre><pre class=\"cython line score-19\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">60</span>: <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s\">&#39;First run:&#39;</span><span class=\"p\">,</span> <span class=\"n\">duration</span> <span class=\"o\">*</span> <span class=\"mf\">1000</span><span class=\"p\">,</span> <span class=\"s\">&#39;ms&#39;</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-19 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_4, __pyx_n_s_duration);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyInt_MultiplyObjC</span>(__pyx_t_4, __pyx_int_1000, 0x3E8, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='py_c_api'>PyTuple_New</span>(3);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_kp_u_First_run);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_kp_u_First_run);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_4, 0, __pyx_kp_u_First_run);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_t_2);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_4, 1, __pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_n_u_ms);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_n_u_ms);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_4, 2, __pyx_n_u_ms);\n",
" __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_builtin_print, __pyx_t_4, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">61</span>: </pre>\n",
"<pre class=\"cython line score-14\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">62</span>: <span class=\"n\">start</span> <span class=\"o\">=</span> <span class=\"n\">time</span><span class=\"o\">.</span><span class=\"n\">perf_counter</span><span class=\"p\">()</span></pre>\n",
"<pre class='cython code score-14 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_time);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_perf_counter);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 62, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_CallNoArg</span>(__pyx_t_4);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 62, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_start, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 62, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-6\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">63</span>: <span class=\"n\">blackscholes</span><span class=\"p\">(</span><span class=\"mf\">2</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-6 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_blackscholes);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_t_2, __pyx_tuple__7, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
"</pre><pre class=\"cython line score-23\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">64</span>: <span class=\"n\">duration</span> <span class=\"o\">=</span> <span class=\"n\">time</span><span class=\"o\">.</span><span class=\"n\">perf_counter</span><span class=\"p\">()</span> <span class=\"o\">-</span> <span class=\"n\">start</span></pre>\n",
"<pre class='cython code score-23 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_4, __pyx_n_s_time);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_4, __pyx_n_s_perf_counter);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyObject_CallNoArg</span>(__pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_start);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_t_4, __pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 64, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_duration, __pyx_t_3) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 64, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
"</pre><pre class=\"cython line score-19\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">65</span>: <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s\">&#39;Second run:&#39;</span><span class=\"p\">,</span> <span class=\"n\">duration</span> <span class=\"o\">*</span> <span class=\"mf\">1000</span><span class=\"p\">,</span> <span class=\"s\">&#39;ms&#39;</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-19 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_duration);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyInt_MultiplyObjC</span>(__pyx_t_3, __pyx_int_1000, 0x3E8, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='py_c_api'>PyTuple_New</span>(3);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_kp_u_Second_run);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_kp_u_Second_run);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_3, 0, __pyx_kp_u_Second_run);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_t_2);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_3, 1, __pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_n_u_ms);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_n_u_ms);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_3, 2, __pyx_n_u_ms);\n",
" __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_builtin_print, __pyx_t_3, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre></div></body></html>"
],
"text/plain": [
"<IPython.core.display.HTML object>"
]
},
"execution_count": 26,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"%%cython --annotate\n",
"\"\"\"\n",
"Benchmark an implementation of the Black–Scholes model.\n",
"\"\"\"\n",
"\n",
"import math\n",
"import numpy as np\n",
"\n",
"# Taken from numba.tests.test_blackscholes\n",
"N = 16384\n",
"\n",
"RISKFREE = 0.02\n",
"VOLATILITY = 0.30\n",
"\n",
"A1 = 0.31938153\n",
"A2 = -0.356563782\n",
"A3 = 1.781477937\n",
"A4 = -1.821255978\n",
"A5 = 1.330274429\n",
"RSQRT2PI = 0.39894228040143267793994605993438\n",
"\n",
"\n",
"def cnd(d: float):\n",
" K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))\n",
" if d > 0:\n",
" ret_val = 1.0 - ret_val\n",
" return ret_val\n",
"\n",
"\n",
"def blackscholes(seed: int):\n",
" R = RISKFREE\n",
" V = VOLATILITY\n",
" np.random.seed(seed)\n",
" S = np.random.uniform(5.0, 30.0, N)\n",
" X = np.random.uniform(1.0, 100.0, N)\n",
" T = np.random.uniform(0.25, 10.0, N)\n",
"\n",
" callResult = np.zeros(N)\n",
" putResult = np.zeros(N)\n",
"\n",
" for i in range(len(S)):\n",
" sqrtT = math.sqrt(T[i])\n",
" d1 = (math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i]) / (V * sqrtT)\n",
" d2 = d1 - V * sqrtT\n",
" cndd1 = cnd(d1)\n",
" cndd2 = cnd(d2)\n",
"\n",
" expRT = math.exp((-1. * R) * T[i])\n",
" callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)\n",
" putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))\n",
"\n",
"#######################\n",
"# Benchmark\n",
"import time\n",
"\n",
"start = time.perf_counter()\n",
"blackscholes(1)\n",
"duration = time.perf_counter() - start\n",
"print('First run:', duration * 1000, 'ms')\n",
"\n",
"start = time.perf_counter()\n",
"blackscholes(2)\n",
"duration = time.perf_counter() - start\n",
"print('Second run:', duration * 1000, 'ms')\n"
]
},
{
"cell_type": "markdown",
"id": "2a9e7665-388b-484c-a1fc-41c81a93b923",
"metadata": {},
"source": [
"### Understanding Cython's objective\n",
"\n",
"Cython aim is to allow users to combine the power of Python and C easily.\n",
"\n",
"It can take in a python code as-is and how you the C code that would have been generated by CPython internally.\n",
"\n",
"And additionally also supports a variant of python - pyrex to make the C generated code more optimal"
]
},
{
"cell_type": "code",
"execution_count": 2,
"id": "b5b7645c-31f4-43d0-8211-888704c25bd5",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T18:15:44.714286Z",
"iopub.status.busy": "2023-08-19T18:15:44.713070Z",
"iopub.status.idle": "2023-08-19T18:15:44.888248Z",
"shell.execute_reply": "2023-08-19T18:15:44.885806Z",
"shell.execute_reply.started": "2023-08-19T18:15:44.714260Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\u001b[0;33m5c5,6\u001b[0;0m\n",
"\u001b[0;31m< import math\u001b[0;0m\n",
"\u001b[0;30m---\u001b[0;0m\n",
"\u001b[0;32m> import cython\u001b[0;0m\n",
"\u001b[0;32m> from cython.cimports.libc import math\u001b[0;0m\n",
"\u001b[0;33m9c10\u001b[0;0m\n",
"\u001b[0;31m< N = 16384\u001b[0;0m\n",
"\u001b[0;30m---\u001b[0;0m\n",
"\u001b[0;32m> N: cython.int = 16384\u001b[0;0m\n",
"\u001b[0;33m11,12c12,13\u001b[0;0m\n",
"\u001b[0;31m< RISKFREE = 0.02\u001b[0;0m\n",
"\u001b[0;31m< VOLATILITY = 0.30\u001b[0;0m\n",
"\u001b[0;30m---\u001b[0;0m\n",
"\u001b[0;32m> RISKFREE: cython.double = 0.02\u001b[0;0m\n",
"\u001b[0;32m> VOLATILITY: cython.double = 0.30\u001b[0;0m\n",
"\u001b[0;33m14,24c15,25\u001b[0;0m\n",
"\u001b[0;31m< A1 = 0.31938153\u001b[0;0m\n",
"\u001b[0;31m< A2 = -0.356563782\u001b[0;0m\n",
"\u001b[0;31m< A3 = 1.781477937\u001b[0;0m\n",
"\u001b[0;31m< A4 = -1.821255978\u001b[0;0m\n",
"\u001b[0;31m< A5 = 1.330274429\u001b[0;0m\n",
"\u001b[0;31m< RSQRT2PI = 0.39894228040143267793994605993438\u001b[0;0m\n",
"\u001b[0;31m< \u001b[0;0m\n",
"\u001b[0;31m< \u001b[0;0m\n",
"\u001b[0;31m< def cnd(d: float):\u001b[0;0m\n",
"\u001b[0;31m< K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\u001b[0;0m\n",
"\u001b[0;31m< ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *\u001b[0;0m\n",
"\u001b[0;30m---\u001b[0;0m\n",
"\u001b[0;32m> A1: cython.double = 0.31938153\u001b[0;0m\n",
"\u001b[0;32m> A2: cython.double = -0.356563782\u001b[0;0m\n",
"\u001b[0;32m> A3: cython.double = 1.781477937\u001b[0;0m\n",
"\u001b[0;32m> A4: cython.double = -1.821255978\u001b[0;0m\n",
"\u001b[0;32m> A5: cython.double = 1.330274429\u001b[0;0m\n",
"\u001b[0;32m> RSQRT2PI: cython.double = 0.39894228040143267793994605993438\u001b[0;0m\n",
"\u001b[0;32m> \u001b[0;0m\n",
"\u001b[0;32m> \u001b[0;0m\n",
"\u001b[0;32m> def cnd(d: cython.double):\u001b[0;0m\n",
"\u001b[0;32m> K: cython.double = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\u001b[0;0m\n",
"\u001b[0;32m> ret_val: cython.double = (RSQRT2PI * math.exp(-0.5 * d * d) *\u001b[0;0m\n",
"\u001b[0;33m31c32\u001b[0;0m\n",
"\u001b[0;31m< def blackscholes(seed: int):\u001b[0;0m\n",
"\u001b[0;30m---\u001b[0;0m\n",
"\u001b[0;32m> def blackscholes(seed: cython.int):\u001b[0;0m\n",
"\u001b[0;33m51a53,66\u001b[0;0m\n",
"\u001b[0;32m> \u001b[0;0m\n",
"\u001b[0;32m> #######################\u001b[0;0m\n",
"\u001b[0;32m> # Benchmark\u001b[0;0m\n",
"\u001b[0;32m> import time\u001b[0;0m\n",
"\u001b[0;32m> \u001b[0;0m\n",
"\u001b[0;32m> start = time.perf_counter()\u001b[0;0m\n",
"\u001b[0;32m> blackscholes(1)\u001b[0;0m\n",
"\u001b[0;32m> duration = time.perf_counter() - start\u001b[0;0m\n",
"\u001b[0;32m> print('First run:', duration * 1000, 'ms')\u001b[0;0m\n",
"\u001b[0;32m> \u001b[0;0m\n",
"\u001b[0;32m> start = time.perf_counter()\u001b[0;0m\n",
"\u001b[0;32m> blackscholes(2)\u001b[0;0m\n",
"\u001b[0;32m> duration = time.perf_counter() - start\u001b[0;0m\n",
"\u001b[0;32m> print('Second run:', duration * 1000, 'ms')\u001b[0;0m\n"
]
}
],
"source": [
"!colordiff blackscholes.py blackscholes_cython_pyrex.py"
]
},
{
"cell_type": "code",
"execution_count": 3,
"id": "1773fd9b-950e-4407-b5a9-236184545b5e",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T18:16:21.246329Z",
"iopub.status.busy": "2023-08-19T18:16:21.245353Z",
"iopub.status.idle": "2023-08-19T18:16:23.178350Z",
"shell.execute_reply": "2023-08-19T18:16:23.176908Z",
"shell.execute_reply.started": "2023-08-19T18:16:21.246299Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First run: 30.08207300445065 ms\n",
"Second run: 29.081284999847412 ms\n"
]
},
{
"data": {
"text/html": [
"<!DOCTYPE html>\n",
"<!-- Generated by Cython 3.0.0 -->\n",
"<html>\n",
"<head>\n",
" <meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" />\n",
" <title>Cython: _cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0.pyx</title>\n",
" <style type=\"text/css\">\n",
" \n",
"body.cython { font-family: courier; font-size: 12; }\n",
"\n",
".cython.tag { }\n",
".cython.line { color: #000000; margin: 0em }\n",
".cython.code { font-size: 9; color: #444444; display: none; margin: 0px 0px 0px 8px; border-left: 8px none; }\n",
"\n",
".cython.line .run { background-color: #B0FFB0; }\n",
".cython.line .mis { background-color: #FFB0B0; }\n",
".cython.code.run { border-left: 8px solid #B0FFB0; }\n",
".cython.code.mis { border-left: 8px solid #FFB0B0; }\n",
"\n",
".cython.code .py_c_api { color: red; }\n",
".cython.code .py_macro_api { color: #FF7000; }\n",
".cython.code .pyx_c_api { color: #FF3000; }\n",
".cython.code .pyx_macro_api { color: #FF7000; }\n",
".cython.code .refnanny { color: #FFA000; }\n",
".cython.code .trace { color: #FFA000; }\n",
".cython.code .error_goto { color: #FFA000; }\n",
"\n",
".cython.code .coerce { color: #008000; border: 1px dotted #008000 }\n",
".cython.code .py_attr { color: #FF0000; font-weight: bold; }\n",
".cython.code .c_attr { color: #0000FF; }\n",
".cython.code .py_call { color: #FF0000; font-weight: bold; }\n",
".cython.code .c_call { color: #0000FF; }\n",
"\n",
".cython.score-0 {background-color: #FFFFff;}\n",
".cython.score-1 {background-color: #FFFFe7;}\n",
".cython.score-2 {background-color: #FFFFd4;}\n",
".cython.score-3 {background-color: #FFFFc4;}\n",
".cython.score-4 {background-color: #FFFFb6;}\n",
".cython.score-5 {background-color: #FFFFaa;}\n",
".cython.score-6 {background-color: #FFFF9f;}\n",
".cython.score-7 {background-color: #FFFF96;}\n",
".cython.score-8 {background-color: #FFFF8d;}\n",
".cython.score-9 {background-color: #FFFF86;}\n",
".cython.score-10 {background-color: #FFFF7f;}\n",
".cython.score-11 {background-color: #FFFF79;}\n",
".cython.score-12 {background-color: #FFFF73;}\n",
".cython.score-13 {background-color: #FFFF6e;}\n",
".cython.score-14 {background-color: #FFFF6a;}\n",
".cython.score-15 {background-color: #FFFF66;}\n",
".cython.score-16 {background-color: #FFFF62;}\n",
".cython.score-17 {background-color: #FFFF5e;}\n",
".cython.score-18 {background-color: #FFFF5b;}\n",
".cython.score-19 {background-color: #FFFF57;}\n",
".cython.score-20 {background-color: #FFFF55;}\n",
".cython.score-21 {background-color: #FFFF52;}\n",
".cython.score-22 {background-color: #FFFF4f;}\n",
".cython.score-23 {background-color: #FFFF4d;}\n",
".cython.score-24 {background-color: #FFFF4b;}\n",
".cython.score-25 {background-color: #FFFF48;}\n",
".cython.score-26 {background-color: #FFFF46;}\n",
".cython.score-27 {background-color: #FFFF44;}\n",
".cython.score-28 {background-color: #FFFF43;}\n",
".cython.score-29 {background-color: #FFFF41;}\n",
".cython.score-30 {background-color: #FFFF3f;}\n",
".cython.score-31 {background-color: #FFFF3e;}\n",
".cython.score-32 {background-color: #FFFF3c;}\n",
".cython.score-33 {background-color: #FFFF3b;}\n",
".cython.score-34 {background-color: #FFFF39;}\n",
".cython.score-35 {background-color: #FFFF38;}\n",
".cython.score-36 {background-color: #FFFF37;}\n",
".cython.score-37 {background-color: #FFFF36;}\n",
".cython.score-38 {background-color: #FFFF35;}\n",
".cython.score-39 {background-color: #FFFF34;}\n",
".cython.score-40 {background-color: #FFFF33;}\n",
".cython.score-41 {background-color: #FFFF32;}\n",
".cython.score-42 {background-color: #FFFF31;}\n",
".cython.score-43 {background-color: #FFFF30;}\n",
".cython.score-44 {background-color: #FFFF2f;}\n",
".cython.score-45 {background-color: #FFFF2e;}\n",
".cython.score-46 {background-color: #FFFF2d;}\n",
".cython.score-47 {background-color: #FFFF2c;}\n",
".cython.score-48 {background-color: #FFFF2b;}\n",
".cython.score-49 {background-color: #FFFF2b;}\n",
".cython.score-50 {background-color: #FFFF2a;}\n",
".cython.score-51 {background-color: #FFFF29;}\n",
".cython.score-52 {background-color: #FFFF29;}\n",
".cython.score-53 {background-color: #FFFF28;}\n",
".cython.score-54 {background-color: #FFFF27;}\n",
".cython.score-55 {background-color: #FFFF27;}\n",
".cython.score-56 {background-color: #FFFF26;}\n",
".cython.score-57 {background-color: #FFFF26;}\n",
".cython.score-58 {background-color: #FFFF25;}\n",
".cython.score-59 {background-color: #FFFF24;}\n",
".cython.score-60 {background-color: #FFFF24;}\n",
".cython.score-61 {background-color: #FFFF23;}\n",
".cython.score-62 {background-color: #FFFF23;}\n",
".cython.score-63 {background-color: #FFFF22;}\n",
".cython.score-64 {background-color: #FFFF22;}\n",
".cython.score-65 {background-color: #FFFF22;}\n",
".cython.score-66 {background-color: #FFFF21;}\n",
".cython.score-67 {background-color: #FFFF21;}\n",
".cython.score-68 {background-color: #FFFF20;}\n",
".cython.score-69 {background-color: #FFFF20;}\n",
".cython.score-70 {background-color: #FFFF1f;}\n",
".cython.score-71 {background-color: #FFFF1f;}\n",
".cython.score-72 {background-color: #FFFF1f;}\n",
".cython.score-73 {background-color: #FFFF1e;}\n",
".cython.score-74 {background-color: #FFFF1e;}\n",
".cython.score-75 {background-color: #FFFF1e;}\n",
".cython.score-76 {background-color: #FFFF1d;}\n",
".cython.score-77 {background-color: #FFFF1d;}\n",
".cython.score-78 {background-color: #FFFF1c;}\n",
".cython.score-79 {background-color: #FFFF1c;}\n",
".cython.score-80 {background-color: #FFFF1c;}\n",
".cython.score-81 {background-color: #FFFF1c;}\n",
".cython.score-82 {background-color: #FFFF1b;}\n",
".cython.score-83 {background-color: #FFFF1b;}\n",
".cython.score-84 {background-color: #FFFF1b;}\n",
".cython.score-85 {background-color: #FFFF1a;}\n",
".cython.score-86 {background-color: #FFFF1a;}\n",
".cython.score-87 {background-color: #FFFF1a;}\n",
".cython.score-88 {background-color: #FFFF1a;}\n",
".cython.score-89 {background-color: #FFFF19;}\n",
".cython.score-90 {background-color: #FFFF19;}\n",
".cython.score-91 {background-color: #FFFF19;}\n",
".cython.score-92 {background-color: #FFFF19;}\n",
".cython.score-93 {background-color: #FFFF18;}\n",
".cython.score-94 {background-color: #FFFF18;}\n",
".cython.score-95 {background-color: #FFFF18;}\n",
".cython.score-96 {background-color: #FFFF18;}\n",
".cython.score-97 {background-color: #FFFF17;}\n",
".cython.score-98 {background-color: #FFFF17;}\n",
".cython.score-99 {background-color: #FFFF17;}\n",
".cython.score-100 {background-color: #FFFF17;}\n",
".cython.score-101 {background-color: #FFFF16;}\n",
".cython.score-102 {background-color: #FFFF16;}\n",
".cython.score-103 {background-color: #FFFF16;}\n",
".cython.score-104 {background-color: #FFFF16;}\n",
".cython.score-105 {background-color: #FFFF16;}\n",
".cython.score-106 {background-color: #FFFF15;}\n",
".cython.score-107 {background-color: #FFFF15;}\n",
".cython.score-108 {background-color: #FFFF15;}\n",
".cython.score-109 {background-color: #FFFF15;}\n",
".cython.score-110 {background-color: #FFFF15;}\n",
".cython.score-111 {background-color: #FFFF15;}\n",
".cython.score-112 {background-color: #FFFF14;}\n",
".cython.score-113 {background-color: #FFFF14;}\n",
".cython.score-114 {background-color: #FFFF14;}\n",
".cython.score-115 {background-color: #FFFF14;}\n",
".cython.score-116 {background-color: #FFFF14;}\n",
".cython.score-117 {background-color: #FFFF14;}\n",
".cython.score-118 {background-color: #FFFF13;}\n",
".cython.score-119 {background-color: #FFFF13;}\n",
".cython.score-120 {background-color: #FFFF13;}\n",
".cython.score-121 {background-color: #FFFF13;}\n",
".cython.score-122 {background-color: #FFFF13;}\n",
".cython.score-123 {background-color: #FFFF13;}\n",
".cython.score-124 {background-color: #FFFF13;}\n",
".cython.score-125 {background-color: #FFFF12;}\n",
".cython.score-126 {background-color: #FFFF12;}\n",
".cython.score-127 {background-color: #FFFF12;}\n",
".cython.score-128 {background-color: #FFFF12;}\n",
".cython.score-129 {background-color: #FFFF12;}\n",
".cython.score-130 {background-color: #FFFF12;}\n",
".cython.score-131 {background-color: #FFFF12;}\n",
".cython.score-132 {background-color: #FFFF11;}\n",
".cython.score-133 {background-color: #FFFF11;}\n",
".cython.score-134 {background-color: #FFFF11;}\n",
".cython.score-135 {background-color: #FFFF11;}\n",
".cython.score-136 {background-color: #FFFF11;}\n",
".cython.score-137 {background-color: #FFFF11;}\n",
".cython.score-138 {background-color: #FFFF11;}\n",
".cython.score-139 {background-color: #FFFF11;}\n",
".cython.score-140 {background-color: #FFFF11;}\n",
".cython.score-141 {background-color: #FFFF10;}\n",
".cython.score-142 {background-color: #FFFF10;}\n",
".cython.score-143 {background-color: #FFFF10;}\n",
".cython.score-144 {background-color: #FFFF10;}\n",
".cython.score-145 {background-color: #FFFF10;}\n",
".cython.score-146 {background-color: #FFFF10;}\n",
".cython.score-147 {background-color: #FFFF10;}\n",
".cython.score-148 {background-color: #FFFF10;}\n",
".cython.score-149 {background-color: #FFFF10;}\n",
".cython.score-150 {background-color: #FFFF0f;}\n",
".cython.score-151 {background-color: #FFFF0f;}\n",
".cython.score-152 {background-color: #FFFF0f;}\n",
".cython.score-153 {background-color: #FFFF0f;}\n",
".cython.score-154 {background-color: #FFFF0f;}\n",
".cython.score-155 {background-color: #FFFF0f;}\n",
".cython.score-156 {background-color: #FFFF0f;}\n",
".cython.score-157 {background-color: #FFFF0f;}\n",
".cython.score-158 {background-color: #FFFF0f;}\n",
".cython.score-159 {background-color: #FFFF0f;}\n",
".cython.score-160 {background-color: #FFFF0f;}\n",
".cython.score-161 {background-color: #FFFF0e;}\n",
".cython.score-162 {background-color: #FFFF0e;}\n",
".cython.score-163 {background-color: #FFFF0e;}\n",
".cython.score-164 {background-color: #FFFF0e;}\n",
".cython.score-165 {background-color: #FFFF0e;}\n",
".cython.score-166 {background-color: #FFFF0e;}\n",
".cython.score-167 {background-color: #FFFF0e;}\n",
".cython.score-168 {background-color: #FFFF0e;}\n",
".cython.score-169 {background-color: #FFFF0e;}\n",
".cython.score-170 {background-color: #FFFF0e;}\n",
".cython.score-171 {background-color: #FFFF0e;}\n",
".cython.score-172 {background-color: #FFFF0e;}\n",
".cython.score-173 {background-color: #FFFF0d;}\n",
".cython.score-174 {background-color: #FFFF0d;}\n",
".cython.score-175 {background-color: #FFFF0d;}\n",
".cython.score-176 {background-color: #FFFF0d;}\n",
".cython.score-177 {background-color: #FFFF0d;}\n",
".cython.score-178 {background-color: #FFFF0d;}\n",
".cython.score-179 {background-color: #FFFF0d;}\n",
".cython.score-180 {background-color: #FFFF0d;}\n",
".cython.score-181 {background-color: #FFFF0d;}\n",
".cython.score-182 {background-color: #FFFF0d;}\n",
".cython.score-183 {background-color: #FFFF0d;}\n",
".cython.score-184 {background-color: #FFFF0d;}\n",
".cython.score-185 {background-color: #FFFF0d;}\n",
".cython.score-186 {background-color: #FFFF0d;}\n",
".cython.score-187 {background-color: #FFFF0c;}\n",
".cython.score-188 {background-color: #FFFF0c;}\n",
".cython.score-189 {background-color: #FFFF0c;}\n",
".cython.score-190 {background-color: #FFFF0c;}\n",
".cython.score-191 {background-color: #FFFF0c;}\n",
".cython.score-192 {background-color: #FFFF0c;}\n",
".cython.score-193 {background-color: #FFFF0c;}\n",
".cython.score-194 {background-color: #FFFF0c;}\n",
".cython.score-195 {background-color: #FFFF0c;}\n",
".cython.score-196 {background-color: #FFFF0c;}\n",
".cython.score-197 {background-color: #FFFF0c;}\n",
".cython.score-198 {background-color: #FFFF0c;}\n",
".cython.score-199 {background-color: #FFFF0c;}\n",
".cython.score-200 {background-color: #FFFF0c;}\n",
".cython.score-201 {background-color: #FFFF0c;}\n",
".cython.score-202 {background-color: #FFFF0c;}\n",
".cython.score-203 {background-color: #FFFF0b;}\n",
".cython.score-204 {background-color: #FFFF0b;}\n",
".cython.score-205 {background-color: #FFFF0b;}\n",
".cython.score-206 {background-color: #FFFF0b;}\n",
".cython.score-207 {background-color: #FFFF0b;}\n",
".cython.score-208 {background-color: #FFFF0b;}\n",
".cython.score-209 {background-color: #FFFF0b;}\n",
".cython.score-210 {background-color: #FFFF0b;}\n",
".cython.score-211 {background-color: #FFFF0b;}\n",
".cython.score-212 {background-color: #FFFF0b;}\n",
".cython.score-213 {background-color: #FFFF0b;}\n",
".cython.score-214 {background-color: #FFFF0b;}\n",
".cython.score-215 {background-color: #FFFF0b;}\n",
".cython.score-216 {background-color: #FFFF0b;}\n",
".cython.score-217 {background-color: #FFFF0b;}\n",
".cython.score-218 {background-color: #FFFF0b;}\n",
".cython.score-219 {background-color: #FFFF0b;}\n",
".cython.score-220 {background-color: #FFFF0b;}\n",
".cython.score-221 {background-color: #FFFF0b;}\n",
".cython.score-222 {background-color: #FFFF0a;}\n",
".cython.score-223 {background-color: #FFFF0a;}\n",
".cython.score-224 {background-color: #FFFF0a;}\n",
".cython.score-225 {background-color: #FFFF0a;}\n",
".cython.score-226 {background-color: #FFFF0a;}\n",
".cython.score-227 {background-color: #FFFF0a;}\n",
".cython.score-228 {background-color: #FFFF0a;}\n",
".cython.score-229 {background-color: #FFFF0a;}\n",
".cython.score-230 {background-color: #FFFF0a;}\n",
".cython.score-231 {background-color: #FFFF0a;}\n",
".cython.score-232 {background-color: #FFFF0a;}\n",
".cython.score-233 {background-color: #FFFF0a;}\n",
".cython.score-234 {background-color: #FFFF0a;}\n",
".cython.score-235 {background-color: #FFFF0a;}\n",
".cython.score-236 {background-color: #FFFF0a;}\n",
".cython.score-237 {background-color: #FFFF0a;}\n",
".cython.score-238 {background-color: #FFFF0a;}\n",
".cython.score-239 {background-color: #FFFF0a;}\n",
".cython.score-240 {background-color: #FFFF0a;}\n",
".cython.score-241 {background-color: #FFFF0a;}\n",
".cython.score-242 {background-color: #FFFF0a;}\n",
".cython.score-243 {background-color: #FFFF0a;}\n",
".cython.score-244 {background-color: #FFFF0a;}\n",
".cython.score-245 {background-color: #FFFF0a;}\n",
".cython.score-246 {background-color: #FFFF09;}\n",
".cython.score-247 {background-color: #FFFF09;}\n",
".cython.score-248 {background-color: #FFFF09;}\n",
".cython.score-249 {background-color: #FFFF09;}\n",
".cython.score-250 {background-color: #FFFF09;}\n",
".cython.score-251 {background-color: #FFFF09;}\n",
".cython.score-252 {background-color: #FFFF09;}\n",
".cython.score-253 {background-color: #FFFF09;}\n",
".cython.score-254 {background-color: #FFFF09;}\n",
"pre { line-height: 125%; }\n",
"td.linenos .normal { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
"span.linenos { color: inherit; background-color: transparent; padding-left: 5px; padding-right: 5px; }\n",
"td.linenos .special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
"span.linenos.special { color: #000000; background-color: #ffffc0; padding-left: 5px; padding-right: 5px; }\n",
".cython .hll { background-color: #ffffcc }\n",
".cython { background: #f8f8f8; }\n",
".cython .c { color: #3D7B7B; font-style: italic } /* Comment */\n",
".cython .err { border: 1px solid #FF0000 } /* Error */\n",
".cython .k { color: #008000; font-weight: bold } /* Keyword */\n",
".cython .o { color: #666666 } /* Operator */\n",
".cython .ch { color: #3D7B7B; font-style: italic } /* Comment.Hashbang */\n",
".cython .cm { color: #3D7B7B; font-style: italic } /* Comment.Multiline */\n",
".cython .cp { color: #9C6500 } /* Comment.Preproc */\n",
".cython .cpf { color: #3D7B7B; font-style: italic } /* Comment.PreprocFile */\n",
".cython .c1 { color: #3D7B7B; font-style: italic } /* Comment.Single */\n",
".cython .cs { color: #3D7B7B; font-style: italic } /* Comment.Special */\n",
".cython .gd { color: #A00000 } /* Generic.Deleted */\n",
".cython .ge { font-style: italic } /* Generic.Emph */\n",
".cython .gr { color: #E40000 } /* Generic.Error */\n",
".cython .gh { color: #000080; font-weight: bold } /* Generic.Heading */\n",
".cython .gi { color: #008400 } /* Generic.Inserted */\n",
".cython .go { color: #717171 } /* Generic.Output */\n",
".cython .gp { color: #000080; font-weight: bold } /* Generic.Prompt */\n",
".cython .gs { font-weight: bold } /* Generic.Strong */\n",
".cython .gu { color: #800080; font-weight: bold } /* Generic.Subheading */\n",
".cython .gt { color: #0044DD } /* Generic.Traceback */\n",
".cython .kc { color: #008000; font-weight: bold } /* Keyword.Constant */\n",
".cython .kd { color: #008000; font-weight: bold } /* Keyword.Declaration */\n",
".cython .kn { color: #008000; font-weight: bold } /* Keyword.Namespace */\n",
".cython .kp { color: #008000 } /* Keyword.Pseudo */\n",
".cython .kr { color: #008000; font-weight: bold } /* Keyword.Reserved */\n",
".cython .kt { color: #B00040 } /* Keyword.Type */\n",
".cython .m { color: #666666 } /* Literal.Number */\n",
".cython .s { color: #BA2121 } /* Literal.String */\n",
".cython .na { color: #687822 } /* Name.Attribute */\n",
".cython .nb { color: #008000 } /* Name.Builtin */\n",
".cython .nc { color: #0000FF; font-weight: bold } /* Name.Class */\n",
".cython .no { color: #880000 } /* Name.Constant */\n",
".cython .nd { color: #AA22FF } /* Name.Decorator */\n",
".cython .ni { color: #717171; font-weight: bold } /* Name.Entity */\n",
".cython .ne { color: #CB3F38; font-weight: bold } /* Name.Exception */\n",
".cython .nf { color: #0000FF } /* Name.Function */\n",
".cython .nl { color: #767600 } /* Name.Label */\n",
".cython .nn { color: #0000FF; font-weight: bold } /* Name.Namespace */\n",
".cython .nt { color: #008000; font-weight: bold } /* Name.Tag */\n",
".cython .nv { color: #19177C } /* Name.Variable */\n",
".cython .ow { color: #AA22FF; font-weight: bold } /* Operator.Word */\n",
".cython .w { color: #bbbbbb } /* Text.Whitespace */\n",
".cython .mb { color: #666666 } /* Literal.Number.Bin */\n",
".cython .mf { color: #666666 } /* Literal.Number.Float */\n",
".cython .mh { color: #666666 } /* Literal.Number.Hex */\n",
".cython .mi { color: #666666 } /* Literal.Number.Integer */\n",
".cython .mo { color: #666666 } /* Literal.Number.Oct */\n",
".cython .sa { color: #BA2121 } /* Literal.String.Affix */\n",
".cython .sb { color: #BA2121 } /* Literal.String.Backtick */\n",
".cython .sc { color: #BA2121 } /* Literal.String.Char */\n",
".cython .dl { color: #BA2121 } /* Literal.String.Delimiter */\n",
".cython .sd { color: #BA2121; font-style: italic } /* Literal.String.Doc */\n",
".cython .s2 { color: #BA2121 } /* Literal.String.Double */\n",
".cython .se { color: #AA5D1F; font-weight: bold } /* Literal.String.Escape */\n",
".cython .sh { color: #BA2121 } /* Literal.String.Heredoc */\n",
".cython .si { color: #A45A77; font-weight: bold } /* Literal.String.Interpol */\n",
".cython .sx { color: #008000 } /* Literal.String.Other */\n",
".cython .sr { color: #A45A77 } /* Literal.String.Regex */\n",
".cython .s1 { color: #BA2121 } /* Literal.String.Single */\n",
".cython .ss { color: #19177C } /* Literal.String.Symbol */\n",
".cython .bp { color: #008000 } /* Name.Builtin.Pseudo */\n",
".cython .fm { color: #0000FF } /* Name.Function.Magic */\n",
".cython .vc { color: #19177C } /* Name.Variable.Class */\n",
".cython .vg { color: #19177C } /* Name.Variable.Global */\n",
".cython .vi { color: #19177C } /* Name.Variable.Instance */\n",
".cython .vm { color: #19177C } /* Name.Variable.Magic */\n",
".cython .il { color: #666666 } /* Literal.Number.Integer.Long */\n",
" </style>\n",
"</head>\n",
"<body class=\"cython\">\n",
"<p><span style=\"border-bottom: solid 1px grey;\">Generated by Cython 3.0.0</span></p>\n",
"<p>\n",
" <span style=\"background-color: #FFFF00\">Yellow lines</span> hint at Python interaction.<br />\n",
" Click on a line that starts with a \"<code>+</code>\" to see the C code that Cython generated for it.\n",
"</p>\n",
"<div class=\"cython\"><pre class=\"cython line score-8\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">01</span>: <span class=\"sd\">&quot;&quot;&quot;</span></pre>\n",
"<pre class='cython code score-8 '> __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyDict_NewPresized</span>(0);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 1, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_test, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 1, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">02</span>: <span class=\"sd\">Benchmark an implementation of the Black–Scholes model.</span></pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">03</span>: <span class=\"sd\">&quot;&quot;&quot;</span></pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">04</span>: </pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">05</span>: <span class=\"k\">import</span> <span class=\"nn\">cython</span></pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">06</span>: <span class=\"k\">from</span> <span class=\"nn\">cython.cimports.libc</span> <span class=\"k\">import</span> <span class=\"n\">math</span></pre>\n",
"<pre class=\"cython line score-8\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">07</span>: <span class=\"k\">import</span> <span class=\"nn\">numpy</span> <span class=\"k\">as</span> <span class=\"nn\">np</span></pre>\n",
"<pre class='cython code score-8 '> __pyx_t_2 = <span class='pyx_c_api'>__Pyx_ImportDottedModule</span>(__pyx_n_s_numpy, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 7, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_np, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 7, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">08</span>: </pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">09</span>: <span class=\"c\"># Taken from numba.tests.test_blackscholes</span></pre>\n",
"<pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">10</span>: <span class=\"n\">N</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">int</span> <span class=\"o\">=</span> <span class=\"mf\">16384</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_N, __pyx_int_16384) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 10, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">11</span>: </pre>\n",
"<pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">12</span>: <span class=\"n\">RISKFREE</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"mf\">0.02</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_RISKFREE, __pyx_float_0_02) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 12, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">13</span>: <span class=\"n\">VOLATILITY</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"mf\">0.30</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_VOLATILITY, __pyx_float_0_30) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 13, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">14</span>: </pre>\n",
"<pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">15</span>: <span class=\"n\">A1</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"mf\">0.31938153</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A1, __pyx_float_0_31938153) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 15, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">16</span>: <span class=\"n\">A2</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"o\">-</span><span class=\"mf\">0.356563782</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A2, __pyx_float_neg_0_356563782) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 16, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">17</span>: <span class=\"n\">A3</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"mf\">1.781477937</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A3, __pyx_float_1_781477937) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 17, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">18</span>: <span class=\"n\">A4</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"o\">-</span><span class=\"mf\">1.821255978</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A4, __pyx_float_neg_1_821255978) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 18, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">19</span>: <span class=\"n\">A5</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"mf\">1.330274429</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_A5, __pyx_float_1_330274429) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 19, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">20</span>: <span class=\"n\">RSQRT2PI</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"mf\">0.39894228040143267793994605993438</span></pre>\n",
"<pre class='cython code score-5 '> if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_RSQRT2PI, __pyx_float_0_39894228040143267793994605993438) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 20, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">21</span>: </pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">22</span>: </pre>\n",
"<pre class=\"cython line score-71\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">23</span>: <span class=\"k\">def</span> <span class=\"nf\">cnd</span><span class=\"p\">(</span><span class=\"n\">d</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span><span class=\"p\">):</span></pre>\n",
"<pre class='cython code score-71 '>\n",
"/* \"_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0.pyx\":23\n",
" * \n",
" * \n",
" * def cnd(d: cython.double): # &lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;\n",
" * K: cython.double = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" * ret_val: cython.double = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" */\n",
"\n",
"/* Python wrapper */\n",
"static PyObject *__pyx_pw_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_1cnd(PyObject *__pyx_self, \n",
"#if CYTHON_METH_FASTCALL\n",
"PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
"#else\n",
"PyObject *__pyx_args, PyObject *__pyx_kwds\n",
"#endif\n",
"); /*proto*/\n",
"static PyMethodDef __pyx_mdef_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_1cnd = {\"cnd\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_1cnd, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
"static PyObject *__pyx_pw_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_1cnd(PyObject *__pyx_self, \n",
"#if CYTHON_METH_FASTCALL\n",
"PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
"#else\n",
"PyObject *__pyx_args, PyObject *__pyx_kwds\n",
"#endif\n",
") {\n",
" double __pyx_v_d;\n",
" #if !CYTHON_METH_FASTCALL\n",
" CYTHON_UNUSED const Py_ssize_t __pyx_nargs = <span class='py_macro_api'>PyTuple_GET_SIZE</span>(__pyx_args);\n",
" #endif\n",
" CYTHON_UNUSED PyObject *const *__pyx_kwvalues = <span class='pyx_c_api'>__Pyx_KwValues_FASTCALL</span>(__pyx_args, __pyx_nargs);\n",
" PyObject *__pyx_r = 0;\n",
" <span class='refnanny'>__Pyx_RefNannyDeclarations</span>\n",
" <span class='refnanny'>__Pyx_RefNannySetupContext</span>(\"cnd (wrapper)\", 0);\n",
" {\n",
" PyObject **__pyx_pyargnames[] = {&amp;__pyx_n_s_d,0};\n",
" PyObject* values[1] = {0};\n",
" if (__pyx_kwds) {\n",
" Py_ssize_t kw_args;\n",
" switch (__pyx_nargs) {\n",
" case 1: values[0] = <span class='pyx_c_api'>__Pyx_Arg_FASTCALL</span>(__pyx_args, 0);\n",
" CYTHON_FALLTHROUGH;\n",
" case 0: break;\n",
" default: goto __pyx_L5_argtuple_error;\n",
" }\n",
" kw_args = <span class='pyx_c_api'>__Pyx_NumKwargs_FASTCALL</span>(__pyx_kwds);\n",
" switch (__pyx_nargs) {\n",
" case 0:\n",
" if (likely((values[0] = <span class='pyx_c_api'>__Pyx_GetKwValue_FASTCALL</span>(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_d)) != 0)) kw_args--;\n",
" else if (unlikely(<span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 23, __pyx_L3_error)</span>\n",
" else goto __pyx_L5_argtuple_error;\n",
" }\n",
" if (unlikely(kw_args &gt; 0)) {\n",
" const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
" if (unlikely(<span class='pyx_c_api'>__Pyx_ParseOptionalKeywords</span>(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"cnd\") &lt; 0)) <span class='error_goto'>__PYX_ERR(0, 23, __pyx_L3_error)</span>\n",
" }\n",
" } else if (unlikely(__pyx_nargs != 1)) {\n",
" goto __pyx_L5_argtuple_error;\n",
" } else {\n",
" values[0] = <span class='pyx_c_api'>__Pyx_Arg_FASTCALL</span>(__pyx_args, 0);\n",
" }\n",
" __pyx_v_d = __pyx_<span class='py_c_api'>PyFloat_AsDouble</span>(values[0]); if (unlikely((__pyx_v_d == (double)-1) &amp;&amp; <span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 23, __pyx_L3_error)</span>\n",
" }\n",
" goto __pyx_L4_argument_unpacking_done;\n",
" __pyx_L5_argtuple_error:;\n",
" <span class='pyx_c_api'>__Pyx_RaiseArgtupleInvalid</span>(\"cnd\", 1, 1, 1, __pyx_nargs); <span class='error_goto'>__PYX_ERR(0, 23, __pyx_L3_error)</span>\n",
" __pyx_L3_error:;\n",
" <span class='pyx_c_api'>__Pyx_AddTraceback</span>(\"_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0.cnd\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return NULL;\n",
" __pyx_L4_argument_unpacking_done:;\n",
" __pyx_r = __pyx_pf_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_cnd(__pyx_self, __pyx_v_d);\n",
" int __pyx_lineno = 0;\n",
" const char *__pyx_filename = NULL;\n",
" int __pyx_clineno = 0;\n",
"\n",
" /* function exit code */\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return __pyx_r;\n",
"}\n",
"\n",
"static PyObject *__pyx_pf_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_cnd(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_d) {\n",
" double __pyx_v_K;\n",
" double __pyx_v_ret_val;\n",
" PyObject *__pyx_r = NULL;\n",
" <span class='refnanny'>__Pyx_RefNannyDeclarations</span>\n",
" <span class='refnanny'>__Pyx_RefNannySetupContext</span>(\"cnd\", 0);\n",
"\n",
" /* \"_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0.pyx\":23\n",
" * \n",
" * \n",
" * def cnd(d: cython.double): # &lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;\n",
" * K: cython.double = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" * ret_val: cython.double = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" */\n",
"\n",
" /* function exit code */\n",
" __pyx_L1_error:;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_6);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_7);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_8);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_9);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_10);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_11);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_12);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_13);\n",
" <span class='pyx_c_api'>__Pyx_AddTraceback</span>(\"_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0.cnd\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
" __pyx_r = NULL;\n",
" __pyx_L0:;\n",
" <span class='refnanny'>__Pyx_XGIVEREF</span>(__pyx_r);\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return __pyx_r;\n",
"}\n",
"\n",
" /* \"_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0.pyx\":23\n",
" * \n",
" * \n",
" * def cnd(d: cython.double): # &lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;\n",
" * K: cython.double = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" * ret_val: cython.double = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" */\n",
" __pyx_tuple__2 = <span class='py_c_api'>PyTuple_Pack</span>(3, __pyx_n_s_d, __pyx_n_s_K, __pyx_n_s_ret_val);<span class='error_goto'> if (unlikely(!__pyx_tuple__2)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_tuple__2);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_tuple__2);\n",
"\n",
" /* \"_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0.pyx\":23\n",
" * \n",
" * \n",
" * def cnd(d: cython.double): # &lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;&lt;\n",
" * K: cython.double = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" * ret_val: cython.double = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" */\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyDict_NewPresized</span>(1);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_t_2, __pyx_n_s_d, __pyx_kp_s_cython_double) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_CyFunction_New</span>(&amp;__pyx_mdef_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_1cnd, 0, __pyx_n_s_cnd, NULL, __pyx_n_s_cython_magic_620a5480bd7aeb4956, __pyx_d, ((PyObject *)__pyx_codeobj__3));<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_c_api'>__Pyx_CyFunction_SetAnnotationsDict</span>(__pyx_t_3, __pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_cnd, __pyx_t_3) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_codeobj__3 = (PyObject*)<span class='pyx_c_api'>__Pyx_PyCode_New</span>(1, 0, 0, 3, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__2, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_abdealiloko_cache_ipython, __pyx_n_s_cnd, 23, __pyx_empty_bytes);<span class='error_goto'> if (unlikely(!__pyx_codeobj__3)) __PYX_ERR(0, 23, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">24</span>: <span class=\"n\">K</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"mf\">1.0</span> <span class=\"o\">/</span> <span class=\"p\">(</span><span class=\"mf\">1.0</span> <span class=\"o\">+</span> <span class=\"mf\">0.2316419</span> <span class=\"o\">*</span> <span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">fabs</span><span class=\"p\">(</span><span class=\"n\">d</span><span class=\"p\">))</span></pre>\n",
"<pre class='cython code score-5 '> __pyx_t_1 = (1.0 + (0.2316419 * fabs(__pyx_v_d)));\n",
" if (unlikely(__pyx_t_1 == 0)) {\n",
" <span class='py_c_api'>PyErr_SetString</span>(PyExc_ZeroDivisionError, \"float division\");\n",
" <span class='error_goto'>__PYX_ERR(0, 24, __pyx_L1_error)</span>\n",
" }\n",
" __pyx_v_K = (1.0 / __pyx_t_1);\n",
"</pre><pre class=\"cython line score-32\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">25</span>: <span class=\"n\">ret_val</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">RSQRT2PI</span> <span class=\"o\">*</span> <span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">exp</span><span class=\"p\">(</span><span class=\"o\">-</span><span class=\"mf\">0.5</span> <span class=\"o\">*</span> <span class=\"n\">d</span> <span class=\"o\">*</span> <span class=\"n\">d</span><span class=\"p\">)</span> <span class=\"o\">*</span></pre>\n",
"<pre class='cython code score-32 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_RSQRT2PI);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='py_c_api'>PyFloat_FromDouble</span>(exp(((-0.5 * __pyx_v_d) * __pyx_v_d)));<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_4 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_2, __pyx_t_3);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
"/* … */\n",
" __pyx_t_12 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_4, __pyx_t_13);<span class='error_goto'> if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_12);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_13); __pyx_t_13 = 0;\n",
" __pyx_t_1 = __pyx_<span class='py_c_api'>PyFloat_AsDouble</span>(__pyx_t_12); if (unlikely((__pyx_t_1 == (double)-1) &amp;&amp; <span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 25, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_12); __pyx_t_12 = 0;\n",
" __pyx_v_ret_val = __pyx_t_1;\n",
"</pre><pre class=\"cython line score-98\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">26</span>: <span class=\"p\">(</span><span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"n\">A1</span> <span class=\"o\">+</span> <span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"n\">A2</span> <span class=\"o\">+</span> <span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"n\">A3</span> <span class=\"o\">+</span> <span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"n\">A4</span> <span class=\"o\">+</span> <span class=\"n\">K</span> <span class=\"o\">*</span> <span class=\"n\">A5</span><span class=\"p\">))))))</span></pre>\n",
"<pre class='cython code score-98 '> __pyx_t_3 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_K);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_A1);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_5 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_K);<span class='error_goto'> if (unlikely(!__pyx_t_5)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_5);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_6, __pyx_n_s_A2);<span class='error_goto'> if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_6);\n",
" __pyx_t_7 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_K);<span class='error_goto'> if (unlikely(!__pyx_t_7)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_7);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_8, __pyx_n_s_A3);<span class='error_goto'> if (unlikely(!__pyx_t_8)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_8);\n",
" __pyx_t_9 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_K);<span class='error_goto'> if (unlikely(!__pyx_t_9)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_9);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_10, __pyx_n_s_A4);<span class='error_goto'> if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_10);\n",
" __pyx_t_11 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_K);<span class='error_goto'> if (unlikely(!__pyx_t_11)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_11);\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_12, __pyx_n_s_A5);<span class='error_goto'> if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_12);\n",
" __pyx_t_13 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_11, __pyx_t_12);<span class='error_goto'> if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_13);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_11); __pyx_t_11 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_12); __pyx_t_12 = 0;\n",
" __pyx_t_12 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_10, __pyx_t_13);<span class='error_goto'> if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_12);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_10); __pyx_t_10 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_13); __pyx_t_13 = 0;\n",
" __pyx_t_13 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_9, __pyx_t_12);<span class='error_goto'> if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_13);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_9); __pyx_t_9 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_12); __pyx_t_12 = 0;\n",
" __pyx_t_12 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_8, __pyx_t_13);<span class='error_goto'> if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_12);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_8); __pyx_t_8 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_13); __pyx_t_13 = 0;\n",
" __pyx_t_13 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_7, __pyx_t_12);<span class='error_goto'> if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_13);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_7); __pyx_t_7 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_12); __pyx_t_12 = 0;\n",
" __pyx_t_12 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_6, __pyx_t_13);<span class='error_goto'> if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_12);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_6); __pyx_t_6 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_13); __pyx_t_13 = 0;\n",
" __pyx_t_13 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_5, __pyx_t_12);<span class='error_goto'> if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_13);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_5); __pyx_t_5 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_12); __pyx_t_12 = 0;\n",
" __pyx_t_12 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_2, __pyx_t_13);<span class='error_goto'> if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_12);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_13); __pyx_t_13 = 0;\n",
" __pyx_t_13 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_3, __pyx_t_12);<span class='error_goto'> if (unlikely(!__pyx_t_13)) __PYX_ERR(0, 26, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_13);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_12); __pyx_t_12 = 0;\n",
"</pre><pre class=\"cython line score-0\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">27</span>: <span class=\"k\">if</span> <span class=\"n\">d</span> <span class=\"o\">&gt;</span> <span class=\"mf\">0</span><span class=\"p\">:</span></pre>\n",
"<pre class='cython code score-0 '> __pyx_t_14 = (__pyx_v_d &gt; 0.0);\n",
" if (__pyx_t_14) {\n",
"/* … */\n",
" }\n",
"</pre><pre class=\"cython line score-0\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">28</span>: <span class=\"n\">ret_val</span> <span class=\"o\">=</span> <span class=\"mf\">1.0</span> <span class=\"o\">-</span> <span class=\"n\">ret_val</span></pre>\n",
"<pre class='cython code score-0 '> __pyx_v_ret_val = (1.0 - __pyx_v_ret_val);\n",
"</pre><pre class=\"cython line score-6\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">29</span>: <span class=\"k\">return</span> <span class=\"n\">ret_val</span></pre>\n",
"<pre class='cython code score-6 '> <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_r);\n",
" __pyx_t_12 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_ret_val);<span class='error_goto'> if (unlikely(!__pyx_t_12)) __PYX_ERR(0, 29, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_12);\n",
" __pyx_r = __pyx_t_12;\n",
" __pyx_t_12 = 0;\n",
" goto __pyx_L0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">30</span>: </pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">31</span>: </pre>\n",
"<pre class=\"cython line score-72\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">32</span>: <span class=\"k\">def</span> <span class=\"nf\">blackscholes</span><span class=\"p\">(</span><span class=\"n\">seed</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">int</span><span class=\"p\">):</span></pre>\n",
"<pre class='cython code score-72 '>/* Python wrapper */\n",
"static PyObject *__pyx_pw_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_3blackscholes(PyObject *__pyx_self, \n",
"#if CYTHON_METH_FASTCALL\n",
"PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
"#else\n",
"PyObject *__pyx_args, PyObject *__pyx_kwds\n",
"#endif\n",
"); /*proto*/\n",
"static PyMethodDef __pyx_mdef_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_3blackscholes = {\"blackscholes\", (PyCFunction)(void*)(__Pyx_PyCFunction_FastCallWithKeywords)__pyx_pw_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_3blackscholes, __Pyx_METH_FASTCALL|METH_KEYWORDS, 0};\n",
"static PyObject *__pyx_pw_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_3blackscholes(PyObject *__pyx_self, \n",
"#if CYTHON_METH_FASTCALL\n",
"PyObject *const *__pyx_args, Py_ssize_t __pyx_nargs, PyObject *__pyx_kwds\n",
"#else\n",
"PyObject *__pyx_args, PyObject *__pyx_kwds\n",
"#endif\n",
") {\n",
" int __pyx_v_seed;\n",
" #if !CYTHON_METH_FASTCALL\n",
" CYTHON_UNUSED const Py_ssize_t __pyx_nargs = <span class='py_macro_api'>PyTuple_GET_SIZE</span>(__pyx_args);\n",
" #endif\n",
" CYTHON_UNUSED PyObject *const *__pyx_kwvalues = <span class='pyx_c_api'>__Pyx_KwValues_FASTCALL</span>(__pyx_args, __pyx_nargs);\n",
" PyObject *__pyx_r = 0;\n",
" <span class='refnanny'>__Pyx_RefNannyDeclarations</span>\n",
" <span class='refnanny'>__Pyx_RefNannySetupContext</span>(\"blackscholes (wrapper)\", 0);\n",
" {\n",
" PyObject **__pyx_pyargnames[] = {&amp;__pyx_n_s_seed,0};\n",
" PyObject* values[1] = {0};\n",
" if (__pyx_kwds) {\n",
" Py_ssize_t kw_args;\n",
" switch (__pyx_nargs) {\n",
" case 1: values[0] = <span class='pyx_c_api'>__Pyx_Arg_FASTCALL</span>(__pyx_args, 0);\n",
" CYTHON_FALLTHROUGH;\n",
" case 0: break;\n",
" default: goto __pyx_L5_argtuple_error;\n",
" }\n",
" kw_args = <span class='pyx_c_api'>__Pyx_NumKwargs_FASTCALL</span>(__pyx_kwds);\n",
" switch (__pyx_nargs) {\n",
" case 0:\n",
" if (likely((values[0] = <span class='pyx_c_api'>__Pyx_GetKwValue_FASTCALL</span>(__pyx_kwds, __pyx_kwvalues, __pyx_n_s_seed)) != 0)) kw_args--;\n",
" else if (unlikely(<span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 32, __pyx_L3_error)</span>\n",
" else goto __pyx_L5_argtuple_error;\n",
" }\n",
" if (unlikely(kw_args &gt; 0)) {\n",
" const Py_ssize_t kwd_pos_args = __pyx_nargs;\n",
" if (unlikely(<span class='pyx_c_api'>__Pyx_ParseOptionalKeywords</span>(__pyx_kwds, __pyx_kwvalues, __pyx_pyargnames, 0, values + 0, kwd_pos_args, \"blackscholes\") &lt; 0)) <span class='error_goto'>__PYX_ERR(0, 32, __pyx_L3_error)</span>\n",
" }\n",
" } else if (unlikely(__pyx_nargs != 1)) {\n",
" goto __pyx_L5_argtuple_error;\n",
" } else {\n",
" values[0] = <span class='pyx_c_api'>__Pyx_Arg_FASTCALL</span>(__pyx_args, 0);\n",
" }\n",
" __pyx_v_seed = <span class='pyx_c_api'>__Pyx_PyInt_As_int</span>(values[0]); if (unlikely((__pyx_v_seed == (int)-1) &amp;&amp; <span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 32, __pyx_L3_error)</span>\n",
" }\n",
" goto __pyx_L4_argument_unpacking_done;\n",
" __pyx_L5_argtuple_error:;\n",
" <span class='pyx_c_api'>__Pyx_RaiseArgtupleInvalid</span>(\"blackscholes\", 1, 1, 1, __pyx_nargs); <span class='error_goto'>__PYX_ERR(0, 32, __pyx_L3_error)</span>\n",
" __pyx_L3_error:;\n",
" <span class='pyx_c_api'>__Pyx_AddTraceback</span>(\"_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0.blackscholes\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return NULL;\n",
" __pyx_L4_argument_unpacking_done:;\n",
" __pyx_r = __pyx_pf_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_2blackscholes(__pyx_self, __pyx_v_seed);\n",
" int __pyx_lineno = 0;\n",
" const char *__pyx_filename = NULL;\n",
" int __pyx_clineno = 0;\n",
"\n",
" /* function exit code */\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return __pyx_r;\n",
"}\n",
"\n",
"static PyObject *__pyx_pf_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_2blackscholes(CYTHON_UNUSED PyObject *__pyx_self, int __pyx_v_seed) {\n",
" PyObject *__pyx_v_R = NULL;\n",
" PyObject *__pyx_v_V = NULL;\n",
" PyObject *__pyx_v_S = NULL;\n",
" PyObject *__pyx_v_X = NULL;\n",
" PyObject *__pyx_v_T = NULL;\n",
" PyObject *__pyx_v_callResult = NULL;\n",
" PyObject *__pyx_v_putResult = NULL;\n",
" Py_ssize_t __pyx_v_i;\n",
" double __pyx_v_sqrtT;\n",
" PyObject *__pyx_v_d1 = NULL;\n",
" PyObject *__pyx_v_d2 = NULL;\n",
" PyObject *__pyx_v_cndd1 = NULL;\n",
" PyObject *__pyx_v_cndd2 = NULL;\n",
" double __pyx_v_expRT;\n",
" PyObject *__pyx_r = NULL;\n",
" <span class='refnanny'>__Pyx_RefNannyDeclarations</span>\n",
" <span class='refnanny'>__Pyx_RefNannySetupContext</span>(\"blackscholes\", 0);\n",
"/* … */\n",
" /* function exit code */\n",
" __pyx_r = Py_None; <span class='pyx_macro_api'>__Pyx_INCREF</span>(Py_None);\n",
" goto __pyx_L0;\n",
" __pyx_L1_error:;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4);\n",
" <span class='pyx_c_api'>__Pyx_AddTraceback</span>(\"_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0.blackscholes\", __pyx_clineno, __pyx_lineno, __pyx_filename);\n",
" __pyx_r = NULL;\n",
" __pyx_L0:;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_R);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_V);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_S);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_X);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_T);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_callResult);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_putResult);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_d1);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_d2);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_cndd1);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_v_cndd2);\n",
" <span class='refnanny'>__Pyx_XGIVEREF</span>(__pyx_r);\n",
" <span class='refnanny'>__Pyx_RefNannyFinishContext</span>();\n",
" return __pyx_r;\n",
"}\n",
"/* … */\n",
" __pyx_tuple__4 = <span class='py_c_api'>PyTuple_Pack</span>(15, __pyx_n_s_seed, __pyx_n_s_R, __pyx_n_s_V, __pyx_n_s_S, __pyx_n_s_X, __pyx_n_s_T, __pyx_n_s_callResult, __pyx_n_s_putResult, __pyx_n_s_i, __pyx_n_s_sqrtT, __pyx_n_s_d1, __pyx_n_s_d2, __pyx_n_s_cndd1, __pyx_n_s_cndd2, __pyx_n_s_expRT);<span class='error_goto'> if (unlikely(!__pyx_tuple__4)) __PYX_ERR(0, 32, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_tuple__4);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_tuple__4);\n",
"/* … */\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyDict_NewPresized</span>(1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 32, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_t_3, __pyx_n_s_seed, __pyx_kp_s_cython_int) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 32, __pyx_L1_error)</span>\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_CyFunction_New</span>(&amp;__pyx_mdef_54_cython_magic_620a5480bd7aeb49564da181be5afa223e2b4bc0_3blackscholes, 0, __pyx_n_s_blackscholes, NULL, __pyx_n_s_cython_magic_620a5480bd7aeb4956, __pyx_d, ((PyObject *)__pyx_codeobj__5));<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 32, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_c_api'>__Pyx_CyFunction_SetAnnotationsDict</span>(__pyx_t_2, __pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_blackscholes, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 32, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_codeobj__5 = (PyObject*)<span class='pyx_c_api'>__Pyx_PyCode_New</span>(1, 0, 0, 15, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__4, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_home_abdealiloko_cache_ipython, __pyx_n_s_blackscholes, 32, __pyx_empty_bytes);<span class='error_goto'> if (unlikely(!__pyx_codeobj__5)) __PYX_ERR(0, 32, __pyx_L1_error)</span>\n",
"</pre><pre class=\"cython line score-2\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">33</span>: <span class=\"n\">R</span> <span class=\"o\">=</span> <span class=\"n\">RISKFREE</span></pre>\n",
"<pre class='cython code score-2 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_1, __pyx_n_s_RISKFREE);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 33, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_v_R = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-2\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">34</span>: <span class=\"n\">V</span> <span class=\"o\">=</span> <span class=\"n\">VOLATILITY</span></pre>\n",
"<pre class='cython code score-2 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_1, __pyx_n_s_VOLATILITY);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 34, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_v_V = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-26\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">35</span>: <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">seed</span><span class=\"p\">(</span><span class=\"n\">seed</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-26 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_random);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_seed);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyInt_From_int</span>(__pyx_v_seed);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_4 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; likely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_4 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_4)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 35, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-25\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">36</span>: <span class=\"n\">S</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">uniform</span><span class=\"p\">(</span><span class=\"mf\">5.0</span><span class=\"p\">,</span> <span class=\"mf\">30.0</span><span class=\"p\">,</span> <span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-25 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_random);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_uniform);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_4 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; likely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_4 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_4)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_float_5_0, __pyx_float_30_0, __pyx_t_3};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 3+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 36, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" __pyx_v_S = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-25\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">37</span>: <span class=\"n\">X</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">uniform</span><span class=\"p\">(</span><span class=\"mf\">1.0</span><span class=\"p\">,</span> <span class=\"mf\">100.0</span><span class=\"p\">,</span> <span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-25 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_random);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_uniform);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_4 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; likely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_4 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_4)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_float_1_0, __pyx_float_100_0, __pyx_t_3};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 3+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 37, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" __pyx_v_X = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-25\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">38</span>: <span class=\"n\">T</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">random</span><span class=\"o\">.</span><span class=\"n\">uniform</span><span class=\"p\">(</span><span class=\"mf\">0.25</span><span class=\"p\">,</span> <span class=\"mf\">10.0</span><span class=\"p\">,</span> <span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-25 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_random);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 38, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_uniform);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 38, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 38, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_4 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; likely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_4 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_4)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[4] = {__pyx_t_4, __pyx_float_0_25, __pyx_float_10_0, __pyx_t_3};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 3+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 38, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" __pyx_v_T = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">39</span>: </pre>\n",
"<pre class=\"cython line score-22\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">40</span>: <span class=\"n\">callResult</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">zeros</span><span class=\"p\">(</span><span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-22 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_zeros);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 40, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 40, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_3))) {\n",
" __pyx_t_4 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_3);\n",
" if (likely(__pyx_t_4)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_3, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_2};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 40, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" }\n",
" __pyx_v_callResult = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-22\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">41</span>: <span class=\"n\">putResult</span> <span class=\"o\">=</span> <span class=\"n\">np</span><span class=\"o\">.</span><span class=\"n\">zeros</span><span class=\"p\">(</span><span class=\"n\">N</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-22 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_np);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 41, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_zeros);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 41, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_N);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 41, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_4 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_2))) {\n",
" __pyx_t_4 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_2);\n",
" if (likely(__pyx_t_4)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_2, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_4, __pyx_t_3};\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_2, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (unlikely(!__pyx_t_1)) <span class='error_goto'>__PYX_ERR(0, 41, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" }\n",
" __pyx_v_putResult = __pyx_t_1;\n",
" __pyx_t_1 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">42</span>: </pre>\n",
"<pre class=\"cython line score-5\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">43</span>: <span class=\"k\">for</span> <span class=\"n\">i</span> <span class=\"ow\">in</span> <span class=\"nb\">range</span><span class=\"p\">(</span><span class=\"nb\">len</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">)):</span></pre>\n",
"<pre class='cython code score-5 '> __pyx_t_6 = <span class='py_c_api'>PyObject_Length</span>(__pyx_v_S);<span class='error_goto'> if (unlikely(__pyx_t_6 == ((Py_ssize_t)-1))) __PYX_ERR(0, 43, __pyx_L1_error)</span>\n",
" __pyx_t_7 = __pyx_t_6;\n",
" for (__pyx_t_8 = 0; __pyx_t_8 &lt; __pyx_t_7; __pyx_t_8+=1) {\n",
" __pyx_v_i = __pyx_t_8;\n",
"</pre><pre class=\"cython line score-13\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">44</span>: <span class=\"n\">sqrtT</span><span class=\"p\">:</span> <span class=\"n\">cython</span><span class=\"o\">.</span><span class=\"n\">double</span> <span class=\"o\">=</span> <span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">sqrt</span><span class=\"p\">(</span><span class=\"n\">T</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">])</span></pre>\n",
"<pre class='cython code score-13 '> __pyx_t_1 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_T, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_9 = __pyx_<span class='py_c_api'>PyFloat_AsDouble</span>(__pyx_t_1); if (unlikely((__pyx_t_9 == (double)-1) &amp;&amp; <span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 44, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" __pyx_v_sqrtT = sqrt(__pyx_t_9);\n",
"</pre><pre class=\"cython line score-73\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">45</span>: <span class=\"n\">d1</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">log</span><span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">/</span> <span class=\"n\">X</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">])</span> <span class=\"o\">+</span> <span class=\"p\">(</span><span class=\"n\">R</span> <span class=\"o\">+</span> <span class=\"mf\">0.5</span> <span class=\"o\">*</span> <span class=\"n\">V</span> <span class=\"o\">*</span> <span class=\"n\">V</span><span class=\"p\">)</span> <span class=\"o\">*</span> <span class=\"n\">T</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">])</span> <span class=\"o\">/</span> <span class=\"p\">(</span><span class=\"n\">V</span> <span class=\"o\">*</span> <span class=\"n\">sqrtT</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-73 '> __pyx_t_1 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_S, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_X, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyNumber_Divide</span>(__pyx_t_1, __pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_9 = __pyx_<span class='py_c_api'>PyFloat_AsDouble</span>(__pyx_t_3); if (unlikely((__pyx_t_9 == (double)-1) &amp;&amp; <span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='py_c_api'>PyFloat_FromDouble</span>(log(__pyx_t_9));<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_2 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_float_0_5, __pyx_v_V);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_1 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_2, __pyx_v_V);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_v_R, __pyx_t_1);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_T, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_4 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_2, __pyx_t_1);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" __pyx_t_1 = <span class='py_c_api'>PyNumber_Add</span>(__pyx_t_3, __pyx_t_4);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_sqrtT);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_v_V, __pyx_t_4);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyNumber_Divide</span>(__pyx_t_1, __pyx_t_3);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 45, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_d1, __pyx_t_4);\n",
" __pyx_t_4 = 0;\n",
"</pre><pre class=\"cython line score-18\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">46</span>: <span class=\"n\">d2</span> <span class=\"o\">=</span> <span class=\"n\">d1</span> <span class=\"o\">-</span> <span class=\"n\">V</span> <span class=\"o\">*</span> <span class=\"n\">sqrtT</span></pre>\n",
"<pre class='cython code score-18 '> __pyx_t_4 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_sqrtT);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_v_V, __pyx_t_4);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 46, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_v_d1, __pyx_t_3);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 46, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_d2, __pyx_t_4);\n",
" __pyx_t_4 = 0;\n",
"</pre><pre class=\"cython line score-17\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">47</span>: <span class=\"n\">cndd1</span> <span class=\"o\">=</span> <span class=\"n\">cnd</span><span class=\"p\">(</span><span class=\"n\">d1</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-17 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_cnd);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 47, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_1 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_3))) {\n",
" __pyx_t_1 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_3);\n",
" if (likely(__pyx_t_1)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_3, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_d1};\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" if (unlikely(!__pyx_t_4)) <span class='error_goto'>__PYX_ERR(0, 47, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" }\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_cndd1, __pyx_t_4);\n",
" __pyx_t_4 = 0;\n",
"</pre><pre class=\"cython line score-17\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">48</span>: <span class=\"n\">cndd2</span> <span class=\"o\">=</span> <span class=\"n\">cnd</span><span class=\"p\">(</span><span class=\"n\">d2</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-17 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_cnd);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 48, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_1 = NULL;\n",
" __pyx_t_5 = 0;\n",
" if (CYTHON_UNPACK_METHODS &amp;&amp; unlikely(<span class='py_c_api'>PyMethod_Check</span>(__pyx_t_3))) {\n",
" __pyx_t_1 = <span class='py_macro_api'>PyMethod_GET_SELF</span>(__pyx_t_3);\n",
" if (likely(__pyx_t_1)) {\n",
" PyObject* function = <span class='py_macro_api'>PyMethod_GET_FUNCTION</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(function);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF_SET</span>(__pyx_t_3, function);\n",
" __pyx_t_5 = 1;\n",
" }\n",
" }\n",
" {\n",
" PyObject *__pyx_callargs[2] = {__pyx_t_1, __pyx_v_d2};\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyObject_FastCall</span>(__pyx_t_3, __pyx_callargs+1-__pyx_t_5, 1+__pyx_t_5);\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" if (unlikely(!__pyx_t_4)) <span class='error_goto'>__PYX_ERR(0, 48, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" }\n",
" <span class='pyx_macro_api'>__Pyx_XDECREF_SET</span>(__pyx_v_cndd2, __pyx_t_4);\n",
" __pyx_t_4 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">49</span>: </pre>\n",
"<pre class=\"cython line score-25\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">50</span>: <span class=\"n\">expRT</span> <span class=\"o\">=</span> <span class=\"n\">math</span><span class=\"o\">.</span><span class=\"n\">exp</span><span class=\"p\">((</span><span class=\"o\">-</span><span class=\"mf\">1.</span> <span class=\"o\">*</span> <span class=\"n\">R</span><span class=\"p\">)</span> <span class=\"o\">*</span> <span class=\"n\">T</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">])</span></pre>\n",
"<pre class='cython code score-25 '> __pyx_t_4 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_float_neg_1_, __pyx_v_R);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_T, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_1 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_4, __pyx_t_3);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_9 = __pyx_<span class='py_c_api'>PyFloat_AsDouble</span>(__pyx_t_1); if (unlikely((__pyx_t_9 == (double)-1) &amp;&amp; <span class='py_c_api'>PyErr_Occurred</span>())) <span class='error_goto'>__PYX_ERR(0, 50, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" __pyx_v_expRT = exp(__pyx_t_9);\n",
"</pre><pre class=\"cython line score-38\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">51</span>: <span class=\"n\">callResult</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"n\">cndd1</span> <span class=\"o\">-</span> <span class=\"n\">X</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"n\">expRT</span> <span class=\"o\">*</span> <span class=\"n\">cndd2</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-38 '> __pyx_t_1 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_S, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_1, __pyx_v_cndd1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" __pyx_t_1 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_X, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" __pyx_t_4 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_expRT);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_2 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_1, __pyx_t_4);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_2, __pyx_v_cndd2);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_t_3, __pyx_t_4);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" if (unlikely((<span class='pyx_c_api'>__Pyx_SetItemInt</span>(__pyx_v_callResult, __pyx_v_i, __pyx_t_2, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) &lt; 0))) <span class='error_goto'>__PYX_ERR(0, 51, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-44\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">52</span>: <span class=\"n\">putResult</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">=</span> <span class=\"p\">(</span><span class=\"n\">X</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"n\">expRT</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"mf\">1.0</span> <span class=\"o\">-</span> <span class=\"n\">cndd2</span><span class=\"p\">)</span> <span class=\"o\">-</span> <span class=\"n\">S</span><span class=\"p\">[</span><span class=\"n\">i</span><span class=\"p\">]</span> <span class=\"o\">*</span> <span class=\"p\">(</span><span class=\"mf\">1.0</span> <span class=\"o\">-</span> <span class=\"n\">cndd1</span><span class=\"p\">))</span></pre>\n",
"<pre class='cython code score-44 '> __pyx_t_2 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_X, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = <span class='py_c_api'>PyFloat_FromDouble</span>(__pyx_v_expRT);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_2, __pyx_t_4);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyFloat_SubtractCObj</span>(__pyx_float_1_0, __pyx_v_cndd2, 1.0, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_2 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_3, __pyx_t_4);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_GetItemInt</span>(__pyx_v_S, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyFloat_SubtractCObj</span>(__pyx_float_1_0, __pyx_v_cndd1, 1.0, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_1 = <span class='py_c_api'>PyNumber_Multiply</span>(__pyx_t_4, __pyx_t_3);<span class='error_goto'> if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_1);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_t_2, __pyx_t_1);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_1); __pyx_t_1 = 0;\n",
" if (unlikely((<span class='pyx_c_api'>__Pyx_SetItemInt</span>(__pyx_v_putResult, __pyx_v_i, __pyx_t_3, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1) &lt; 0))) <span class='error_goto'>__PYX_ERR(0, 52, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" }\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">53</span>: </pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">54</span>: <span class=\"c\">#######################</span></pre>\n",
"<pre class=\"cython line score-0\">&#xA0;<span class=\"\">55</span>: <span class=\"c\"># Benchmark</span></pre>\n",
"<pre class=\"cython line score-8\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">56</span>: <span class=\"k\">import</span> <span class=\"nn\">time</span></pre>\n",
"<pre class='cython code score-8 '> __pyx_t_2 = <span class='pyx_c_api'>__Pyx_ImportDottedModule</span>(__pyx_n_s_time, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 56, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_time, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 56, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">57</span>: </pre>\n",
"<pre class=\"cython line score-14\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">58</span>: <span class=\"n\">start</span> <span class=\"o\">=</span> <span class=\"n\">time</span><span class=\"o\">.</span><span class=\"n\">perf_counter</span><span class=\"p\">()</span></pre>\n",
"<pre class='cython code score-14 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_time);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_perf_counter);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 58, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_CallNoArg</span>(__pyx_t_3);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 58, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_start, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 58, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-6\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">59</span>: <span class=\"n\">blackscholes</span><span class=\"p\">(</span><span class=\"mf\">2</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-6 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_blackscholes);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 59, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_t_2, __pyx_tuple__6, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 59, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
"</pre><pre class=\"cython line score-23\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">60</span>: <span class=\"n\">duration</span> <span class=\"o\">=</span> <span class=\"n\">time</span><span class=\"o\">.</span><span class=\"n\">perf_counter</span><span class=\"p\">()</span> <span class=\"o\">-</span> <span class=\"n\">start</span></pre>\n",
"<pre class='cython code score-23 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_time);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_3, __pyx_n_s_perf_counter);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='pyx_c_api'>__Pyx_PyObject_CallNoArg</span>(__pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_start);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_t_3, __pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_duration, __pyx_t_4) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 60, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
"</pre><pre class=\"cython line score-19\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">61</span>: <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s\">&#39;First run:&#39;</span><span class=\"p\">,</span> <span class=\"n\">duration</span> <span class=\"o\">*</span> <span class=\"mf\">1000</span><span class=\"p\">,</span> <span class=\"s\">&#39;ms&#39;</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-19 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_4, __pyx_n_s_duration);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyInt_MultiplyObjC</span>(__pyx_t_4, __pyx_int_1000, 0x3E8, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='py_c_api'>PyTuple_New</span>(3);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 61, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_kp_u_First_run);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_kp_u_First_run);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_4, 0, __pyx_kp_u_First_run);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_t_2);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_4, 1, __pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_n_u_ms);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_n_u_ms);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_4, 2, __pyx_n_u_ms);\n",
" __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_builtin_print, __pyx_t_4, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 61, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-0\">&#xA0;<span class=\"\">62</span>: </pre>\n",
"<pre class=\"cython line score-14\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">63</span>: <span class=\"n\">start</span> <span class=\"o\">=</span> <span class=\"n\">time</span><span class=\"o\">.</span><span class=\"n\">perf_counter</span><span class=\"p\">()</span></pre>\n",
"<pre class='cython code score-14 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_time);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_2, __pyx_n_s_perf_counter);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 63, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_CallNoArg</span>(__pyx_t_4);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 63, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_start, __pyx_t_2) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 63, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre><pre class=\"cython line score-6\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">64</span>: <span class=\"n\">blackscholes</span><span class=\"p\">(</span><span class=\"mf\">2</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-6 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_blackscholes);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 64, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_t_2, __pyx_tuple__6, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 64, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
"</pre><pre class=\"cython line score-23\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">65</span>: <span class=\"n\">duration</span> <span class=\"o\">=</span> <span class=\"n\">time</span><span class=\"o\">.</span><span class=\"n\">perf_counter</span><span class=\"p\">()</span> <span class=\"o\">-</span> <span class=\"n\">start</span></pre>\n",
"<pre class='cython code score-23 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_4, __pyx_n_s_time);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_GetAttrStr</span>(__pyx_t_4, __pyx_n_s_perf_counter);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" __pyx_t_4 = <span class='pyx_c_api'>__Pyx_PyObject_CallNoArg</span>(__pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_4);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_2, __pyx_n_s_start);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" __pyx_t_3 = <span class='py_c_api'>PyNumber_Subtract</span>(__pyx_t_4, __pyx_t_2);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_4); __pyx_t_4 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
" if (<span class='py_c_api'>PyDict_SetItem</span>(__pyx_d, __pyx_n_s_duration, __pyx_t_3) &lt; 0) <span class='error_goto'>__PYX_ERR(0, 65, __pyx_L1_error)</span>\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
"</pre><pre class=\"cython line score-19\" onclick=\"(function(s){s.display=s.display==='block'?'none':'block'})(this.nextElementSibling.style)\">+<span class=\"\">66</span>: <span class=\"k\">print</span><span class=\"p\">(</span><span class=\"s\">&#39;Second run:&#39;</span><span class=\"p\">,</span> <span class=\"n\">duration</span> <span class=\"o\">*</span> <span class=\"mf\">1000</span><span class=\"p\">,</span> <span class=\"s\">&#39;ms&#39;</span><span class=\"p\">)</span></pre>\n",
"<pre class='cython code score-19 '> <span class='pyx_c_api'>__Pyx_GetModuleGlobalName</span>(__pyx_t_3, __pyx_n_s_duration);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyInt_MultiplyObjC</span>(__pyx_t_3, __pyx_int_1000, 0x3E8, 0, 0);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" __pyx_t_3 = <span class='py_c_api'>PyTuple_New</span>(3);<span class='error_goto'> if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 66, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_3);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_kp_u_Second_run);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_kp_u_Second_run);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_3, 0, __pyx_kp_u_Second_run);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_t_2);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_3, 1, __pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_INCREF</span>(__pyx_n_u_ms);\n",
" <span class='refnanny'>__Pyx_GIVEREF</span>(__pyx_n_u_ms);\n",
" <span class='py_macro_api'>PyTuple_SET_ITEM</span>(__pyx_t_3, 2, __pyx_n_u_ms);\n",
" __pyx_t_2 = 0;\n",
" __pyx_t_2 = <span class='pyx_c_api'>__Pyx_PyObject_Call</span>(__pyx_builtin_print, __pyx_t_3, NULL);<span class='error_goto'> if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 66, __pyx_L1_error)</span>\n",
" <span class='refnanny'>__Pyx_GOTREF</span>(__pyx_t_2);\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_3); __pyx_t_3 = 0;\n",
" <span class='pyx_macro_api'>__Pyx_DECREF</span>(__pyx_t_2); __pyx_t_2 = 0;\n",
"</pre></div></body></html>"
],
"text/plain": [
"<IPython.core.display.HTML object>"
]
},
"execution_count": 3,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"%%cython --annotate\n",
"\"\"\"\n",
"Benchmark an implementation of the Black–Scholes model.\n",
"\"\"\"\n",
"\n",
"import cython\n",
"from cython.cimports.libc import math\n",
"import numpy as np\n",
"\n",
"# Taken from numba.tests.test_blackscholes\n",
"N: cython.int = 16384\n",
"\n",
"RISKFREE: cython.double = 0.02\n",
"VOLATILITY: cython.double = 0.30\n",
"\n",
"A1: cython.double = 0.31938153\n",
"A2: cython.double = -0.356563782\n",
"A3: cython.double = 1.781477937\n",
"A4: cython.double = -1.821255978\n",
"A5: cython.double = 1.330274429\n",
"RSQRT2PI: cython.double = 0.39894228040143267793994605993438\n",
"\n",
"\n",
"def cnd(d: cython.double):\n",
" K: cython.double = 1.0 / (1.0 + 0.2316419 * math.fabs(d))\n",
" ret_val: cython.double = (RSQRT2PI * math.exp(-0.5 * d * d) *\n",
" (K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))\n",
" if d > 0:\n",
" ret_val = 1.0 - ret_val\n",
" return ret_val\n",
"\n",
"\n",
"def blackscholes(seed: cython.int):\n",
" R = RISKFREE\n",
" V = VOLATILITY\n",
" np.random.seed(seed)\n",
" S = np.random.uniform(5.0, 30.0, N)\n",
" X = np.random.uniform(1.0, 100.0, N)\n",
" T = np.random.uniform(0.25, 10.0, N)\n",
"\n",
" callResult = np.zeros(N)\n",
" putResult = np.zeros(N)\n",
" \n",
" for i in range(len(S)):\n",
" sqrtT: cython.double = math.sqrt(T[i])\n",
" d1 = (math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i]) / (V * sqrtT)\n",
" d2 = d1 - V * sqrtT\n",
" cndd1 = cnd(d1)\n",
" cndd2 = cnd(d2)\n",
"\n",
" expRT = math.exp((-1. * R) * T[i])\n",
" callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)\n",
" putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))\n",
"\n",
"#######################\n",
"# Benchmark\n",
"import time\n",
"\n",
"start = time.perf_counter()\n",
"blackscholes(1)\n",
"duration = time.perf_counter() - start\n",
"print('First run:', duration * 1000, 'ms')\n",
"\n",
"start = time.perf_counter()\n",
"blackscholes(2)\n",
"duration = time.perf_counter() - start\n",
"print('Second run:', duration * 1000, 'ms')\n"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "d9ef5a27-b3d5-48ef-bbae-03deb69f5ca5",
"metadata": {},
"outputs": [],
"source": []
},
{
"cell_type": "markdown",
"id": "965978d2-69af-4af1-ae26-53eb264a9645",
"metadata": {
"jp-MarkdownHeadingCollapsed": true,
"tags": []
},
"source": [
"# Trying out nuitka"
]
},
{
"cell_type": "code",
"execution_count": 5,
"id": "0c11c561-61f1-400d-8b37-653c84f9797a",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T18:17:09.658378Z",
"iopub.status.busy": "2023-08-19T18:17:09.658070Z",
"iopub.status.idle": "2023-08-19T18:17:09.845888Z",
"shell.execute_reply": "2023-08-19T18:17:09.843174Z",
"shell.execute_reply.started": "2023-08-19T18:17:09.658341Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"\u001b[0;31m*** blackscholes.py\t2023-08-19 21:39:06.344570844 +0530\u001b[0;0m\n",
"\u001b[0;32m--- blackscholes_nuitka.py\t2023-08-19 23:29:10.864568679 +0530\u001b[0;0m\n",
"\u001b[0;33m***************\u001b[0;0m\n",
"\u001b[0;33m*** 49,51 ****\u001b[0;0m\n",
"\u001b[0;33m--- 49,65 ----\u001b[0;0m\n",
"\u001b[0;30m expRT = math.exp((-1. * R) * T[i])\u001b[0;0m\n",
"\u001b[0;30m callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)\u001b[0;0m\n",
"\u001b[0;30m putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))\u001b[0;0m\n",
"\u001b[0;32m+ \u001b[0;0m\n",
"\u001b[0;32m+ #######################\u001b[0;0m\n",
"\u001b[0;32m+ # Benchmark\u001b[0;0m\n",
"\u001b[0;32m+ import time\u001b[0;0m\n",
"\u001b[0;32m+ \u001b[0;0m\n",
"\u001b[0;32m+ start = time.perf_counter()\u001b[0;0m\n",
"\u001b[0;32m+ blackscholes(1)\u001b[0;0m\n",
"\u001b[0;32m+ duration = time.perf_counter() - start\u001b[0;0m\n",
"\u001b[0;32m+ print('First run:', duration * 1000, 'ms')\u001b[0;0m\n",
"\u001b[0;32m+ \u001b[0;0m\n",
"\u001b[0;32m+ start = time.perf_counter()\u001b[0;0m\n",
"\u001b[0;32m+ blackscholes(2)\u001b[0;0m\n",
"\u001b[0;32m+ duration = time.perf_counter() - start\u001b[0;0m\n",
"\u001b[0;32m+ print('Second run:', duration * 1000, 'ms')\u001b[0;0m\n"
]
}
],
"source": [
"!colordiff -c blackscholes.py blackscholes_nuitka.py"
]
},
{
"cell_type": "code",
"execution_count": 11,
"id": "04898fec-36dc-4b9d-aa96-6f9502310ab1",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T18:20:43.795321Z",
"iopub.status.busy": "2023-08-19T18:20:43.795022Z",
"iopub.status.idle": "2023-08-19T18:23:53.122590Z",
"shell.execute_reply": "2023-08-19T18:23:53.120792Z",
"shell.execute_reply.started": "2023-08-19T18:20:43.795298Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"Nuitka-Options:INFO: Used command line options: --standalone --python-flag=no_site blackscholes_nuitka.py\n",
"Nuitka:INFO: Starting Python compilation with Nuitka '1.7.10' on Python '3.7' commercial grade 'not installed'.\n",
"Nuitka:INFO: Completed Python level compilation and optimization. SS 1: 52.6%|█████████████▏ | 249/473, encodings.base64_codec�█▋ | 184/474, socketserverort59_11\n",
"Nuitka:INFO: Generating source code for C backend compiler.\n",
"Nuitka:INFO: Running data composer tool for optimal constant value handling. \n",
"Nuitka:INFO: Running C compilation via Scons.\n",
"Nuitka-Scons:INFO: Backend C compiler: gcc (gcc).\n",
"Nuitka-Scons:INFO: Backend linking program with 99 files (no progress information available for this stage).\n",
"\u001b[91mNuitka-Scons:WARNING: You are not using ccache, re-compilation of identical code\n",
"Nuitka-Scons:WARNING: will be slower than necessary. Use your OS package manager\n",
"Nuitka-Scons:WARNING: to install it.\n",
"Nuitka:INFO: Keeping build directory 'blackscholes_nuitka.build'. \n",
"Nuitka:INFO: Successfully created 'blackscholes_nuitka.dist/blackscholes_nuitka.bin'.\n"
]
}
],
"source": [
"!nuitka3 --standalone --python-flag=no_site blackscholes_nuitka.py"
]
},
{
"cell_type": "code",
"execution_count": 16,
"id": "b6730c84-66b4-40da-9fc9-a2bf98d5fcac",
"metadata": {
"execution": {
"iopub.execute_input": "2023-08-19T18:24:21.291612Z",
"iopub.status.busy": "2023-08-19T18:24:21.290689Z",
"iopub.status.idle": "2023-08-19T18:24:21.728009Z",
"shell.execute_reply": "2023-08-19T18:24:21.725520Z",
"shell.execute_reply.started": "2023-08-19T18:24:21.291577Z"
},
"tags": []
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"First run: 44.52862399921287 ms\n",
"Second run: 51.389883999945596 ms\n"
]
}
],
"source": [
"!./blackscholes_nuitka.dist/blackscholes_nuitka.bin"
]
},
{
"cell_type": "markdown",
"id": "d044b41a-0a20-4afc-ae9a-f2584c930304",
"metadata": {},
"source": [
"### Understanding nuitka's objective\n",
"\n",
"Safe guarding intellectual property of python code when deploying it.\n",
"\n",
"While doing that - it also tries to improve performance with it's compile process"
]
},
{
"cell_type": "code",
"execution_count": null,
"id": "5de41e33-0a16-40fd-b6fa-1c024331da9a",
"metadata": {},
"outputs": [],
"source": []
}
],
"metadata": {
"kernelspec": {
"display_name": "Python 3 (ipykernel)",
"language": "python",
"name": "python3"
},
"language_info": {
"codemirror_mode": {
"name": "ipython",
"version": 3
},
"file_extension": ".py",
"mimetype": "text/x-python",
"name": "python",
"nbconvert_exporter": "python",
"pygments_lexer": "ipython3",
"version": "3.7.16"
}
},
"nbformat": 4,
"nbformat_minor": 5
}
Raw
blackscholes.py
"""
Benchmark an implementation of the Black–Scholes model.
"""
import math
import numpy as np
# Taken from numba.tests.test_blackscholes
N = 16384
RISKFREE = 0.02
VOLATILITY = 0.30
A1 = 0.31938153
A2 = -0.356563782
A3 = 1.781477937
A4 = -1.821255978
A5 = 1.330274429
RSQRT2PI = 0.39894228040143267793994605993438
def cnd(d: float):
K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))
ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))
if d > 0:
ret_val = 1.0 - ret_val
return ret_val
def blackscholes(seed: int):
R = RISKFREE
V = VOLATILITY
np.random.seed(seed)
S = np.random.uniform(5.0, 30.0, N)
X = np.random.uniform(1.0, 100.0, N)
T = np.random.uniform(0.25, 10.0, N)
callResult = np.zeros(N)
putResult = np.zeros(N)
for i in range(len(S)):
sqrtT = math.sqrt(T[i])
d1 = (math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i]) / (V * sqrtT)
d2 = d1 - V * sqrtT
cndd1 = cnd(d1)
cndd2 = cnd(d2)
expRT = math.exp((-1. * R) * T[i])
callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)
putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))
Raw
blackscholes_cython.py
"""
Benchmark an implementation of the Black–Scholes model.
"""
import math
import numpy as np
# Taken from numba.tests.test_blackscholes
N = 16384
RISKFREE = 0.02
VOLATILITY = 0.30
A1 = 0.31938153
A2 = -0.356563782
A3 = 1.781477937
A4 = -1.821255978
A5 = 1.330274429
RSQRT2PI = 0.39894228040143267793994605993438
def cnd(d: float):
K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))
ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))
if d > 0:
ret_val = 1.0 - ret_val
return ret_val
def blackscholes(seed: int):
R = RISKFREE
V = VOLATILITY
np.random.seed(seed)
S = np.random.uniform(5.0, 30.0, N)
X = np.random.uniform(1.0, 100.0, N)
T = np.random.uniform(0.25, 10.0, N)
callResult = np.zeros(N)
putResult = np.zeros(N)
for i in range(len(S)):
sqrtT = math.sqrt(T[i])
d1 = (math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i]) / (V * sqrtT)
d2 = d1 - V * sqrtT
cndd1 = cnd(d1)
cndd2 = cnd(d2)
expRT = math.exp((-1. * R) * T[i])
callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)
putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))
#######################
# Benchmark
import time
start = time.perf_counter()
blackscholes(1)
duration = time.perf_counter() - start
print('First run:', duration * 1000, 'ms')
start = time.perf_counter()
blackscholes(2)
duration = time.perf_counter() - start
print('Second run:', duration * 1000, 'ms')
Raw
blackscholes_cython_optimized.py
"""
Benchmark an implementation of the Black–Scholes model.
"""
import cython
from cython.cimports.libc import math
import numpy as np
# Taken from numba.tests.test_blackscholes
N: cython.int = 16384
RISKFREE: cython.double = 0.02
VOLATILITY: cython.double = 0.30
A1: cython.double = 0.31938153
A2: cython.double = -0.356563782
A3: cython.double = 1.781477937
A4: cython.double = -1.821255978
A5: cython.double = 1.330274429
RSQRT2PI: cython.double = 0.39894228040143267793994605993438
def cnd(d: cython.double):
K: cython.double = 1.0 / (1.0 + 0.2316419 * math.fabs(d))
ret_val: cython.double = (RSQRT2PI * math.exp(-0.5 * d * d) *
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))
if d > 0:
ret_val = 1.0 - ret_val
return ret_val
def blackscholes(seed: cython.int):
R = RISKFREE
V = VOLATILITY
np.random.seed(seed)
S = np.random.uniform(5.0, 30.0, N)
X = np.random.uniform(1.0, 100.0, N)
T = np.random.uniform(0.25, 10.0, N)
callResult = np.zeros(N)
putResult = np.zeros(N)
for i in range(len(S)):
sqrtT = math.sqrt(T[i])
d1 = (math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i]) / (V * sqrtT)
d2 = d1 - V * sqrtT
cndd1 = cnd(d1)
cndd2 = cnd(d2)
expRT = math.exp((-1. * R) * T[i])
callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)
putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))
#######################
# Benchmark
import time
start = time.perf_counter()
blackscholes(1)
duration = time.perf_counter() - start
print('First run:', duration * 1000, 'ms')
start = time.perf_counter()
blackscholes(2)
duration = time.perf_counter() - start
print('Second run:', duration * 1000, 'ms')
Raw
blackscholes_nuitka.py
"""
Benchmark an implementation of the Black–Scholes model.
"""
import math
import numpy as np
# Taken from numba.tests.test_blackscholes
N = 16384
RISKFREE = 0.02
VOLATILITY = 0.30
A1 = 0.31938153
A2 = -0.356563782
A3 = 1.781477937
A4 = -1.821255978
A5 = 1.330274429
RSQRT2PI = 0.39894228040143267793994605993438
def cnd(d: float):
K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))
ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))
if d > 0:
ret_val = 1.0 - ret_val
return ret_val
def blackscholes(seed: int):
R = RISKFREE
V = VOLATILITY
np.random.seed(seed)
S = np.random.uniform(5.0, 30.0, N)
X = np.random.uniform(1.0, 100.0, N)
T = np.random.uniform(0.25, 10.0, N)
callResult = np.zeros(N)
putResult = np.zeros(N)
for i in range(len(S)):
sqrtT = math.sqrt(T[i])
d1 = (math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i]) / (V * sqrtT)
d2 = d1 - V * sqrtT
cndd1 = cnd(d1)
cndd2 = cnd(d2)
expRT = math.exp((-1. * R) * T[i])
callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)
putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))
#######################
# Benchmark
import time
start = time.perf_counter()
blackscholes(1)
duration = time.perf_counter() - start
print('First run:', duration * 1000, 'ms')
start = time.perf_counter()
blackscholes(2)
duration = time.perf_counter() - start
print('Second run:', duration * 1000, 'ms')
Raw
blackscholes_numba.py
"""
Benchmark an implementation of the Black–Scholes model.
"""
import math
import numpy as np
from numba import jit
# Taken from numba.tests.test_blackscholes
N = 16384
RISKFREE = 0.02
VOLATILITY = 0.30
A1 = 0.31938153
A2 = -0.356563782
A3 = 1.781477937
A4 = -1.821255978
A5 = 1.330274429
RSQRT2PI = 0.39894228040143267793994605993438
@jit(nopython=True)
def cnd(d: float):
K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))
ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))
if d > 0:
ret_val = 1.0 - ret_val
return ret_val
@jit(nopython=True)
def blackscholes(seed: int):
R = RISKFREE
V = VOLATILITY
np.random.seed(seed)
S = np.random.uniform(5.0, 30.0, N)
X = np.random.uniform(1.0, 100.0, N)
T = np.random.uniform(0.25, 10.0, N)
callResult = np.zeros(N)
putResult = np.zeros(N)
for i in range(len(S)):
sqrtT = math.sqrt(T[i])
d1 = (math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i]) / (V * sqrtT)
d2 = d1 - V * sqrtT
cndd1 = cnd(d1)
cndd2 = cnd(d2)
expRT = math.exp((-1. * R) * T[i])
callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)
putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))
Raw
blackscholes_pyston_lite.py
"""
Benchmark an implementation of the Black–Scholes model.
"""
import math
import numpy as np
import pyston_lite
pyston_lite.enable()
# Taken from numba.tests.test_blackscholes
N = 16384
RISKFREE = 0.02
VOLATILITY = 0.30
A1 = 0.31938153
A2 = -0.356563782
A3 = 1.781477937
A4 = -1.821255978
A5 = 1.330274429
RSQRT2PI = 0.39894228040143267793994605993438
def cnd(d: float):
K = 1.0 / (1.0 + 0.2316419 * math.fabs(d))
ret_val = (RSQRT2PI * math.exp(-0.5 * d * d) *
(K * (A1 + K * (A2 + K * (A3 + K * (A4 + K * A5))))))
if d > 0:
ret_val = 1.0 - ret_val
return ret_val
def blackscholes(seed: int):
R = RISKFREE
V = VOLATILITY
np.random.seed(seed)
S = np.random.uniform(5.0, 30.0, N)
X = np.random.uniform(1.0, 100.0, N)
T = np.random.uniform(0.25, 10.0, N)
callResult = np.zeros(N)
putResult = np.zeros(N)
for i in range(len(S)):
sqrtT = math.sqrt(T[i])
d1 = (math.log(S[i] / X[i]) + (R + 0.5 * V * V) * T[i]) / (V * sqrtT)
d2 = d1 - V * sqrtT
cndd1 = cnd(d1)
cndd2 = cnd(d2)
expRT = math.exp((-1. * R) * T[i])
callResult[i] = (S[i] * cndd1 - X[i] * expRT * cndd2)
putResult[i] = (X[i] * expRT * (1.0 - cndd2) - S[i] * (1.0 - cndd1))
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment