o à8VaEAã@südZddlZddlmZddlmZddlmZmZddl m Z edƒZerQóz-LLVMJitPrinter._print_Mul..ré)rrr7©rr(ZnodesÚeZnoderr@rÚ _print_MulPó zLLVMJitPrinter._print_Mulcr:)Ncr;rr<r=r@rrrAXrBz-LLVMJitPrinter._print_Add..rrC)rrZfaddrDrr@rÚ _print_AddWrGzLLVMJitPrinter._print_AddcCsf|jj}| |jd¡}|j |¡}|s*t |j|jg¡}t |j ||¡}||j|<|j ||g|¡S©Nr) ÚfuncÚ__name__r2rrr+rr4rr5rrr6)rr(rZe0rr8rrrÚ_print_Function`s zLLVMJitPrinter._print_FunctioncCstdt|ƒƒ‚)Nz,Unsupported type for LLVM JIT conversion: %s)Ú TypeErrorÚtyper'rrrÚemptyPrinterjsÿzLLVMJitPrinter.emptyPrinter)rKÚ __module__Ú__qualname__Ú__doc__rr!r%r)r/r9rFrHrLrOÚ __classcell__rrrrr s r có,eZdZ‡fdd„Zdd„Zdd„Z‡ZS)ÚLLVMJitCallbackPrintercstƒj|i|¤ŽdSr©r r)rrrrrrrrszLLVMJitCallbackPrinter.__init__cCsf|j|j\}}t|jd ¡ƒ}|j |t t d¡|¡g¡}|j |t |j¡¡}|j |¡}|S)Nré )r r3ÚintÚindicesZevalfrÚgeprr"ÚIntTypeÚbitcastÚPointerTyperÚload)rr(ÚarrayÚidxÚoffsetÚ array_ptrÚfp_array_ptrr rrrÚ_print_Indexedusz%LLVMJitCallbackPrinter._print_IndexedcCs~|j |¡}|r |S|j |ddg¡\}}|std|ƒ‚|j |t t d¡|¡g¡}|j |t |j¡¡}|j |¡}|S)Nrr*rW) rr+r r,rrZrr"r[r\r]rr^)rr-r.r_r`rbrcr rrrr/}s ÿz$LLVMJitCallbackPrinter._print_Symbol)rKrPrQrrdr/rSrrrrrUqsrUc@sTeZdZdd„Zdd„Zdd„Zdd„Zd d „Zdd„Zd d„Z dd„Z dd„ZdS)ÚLLVMJitCodecCs@||_t ¡|_t d¡|_d|_g|_|j|_i|_ d|_ dS)NZmod1Ú)Ú signaturerrrZModulerrÚllvm_arg_typesÚ llvm_ret_typeÚ param_dictÚ link_name©rrgrrrr–s zLLVMJitCode.__init__cCsˆ|tjkr t d¡S|tjkr|jS|t tj¡kr t |j¡S|tjkr-t t d¡¡S|tj kr:t t d¡¡St dt|ƒƒdS)NrWzUnhandled ctype = %s)ÚctypesÚc_intrr[Úc_doublerÚPOINTERr]Úc_void_pÚ py_objectÚprintÚstr)rZctyperrrÚ_from_ctype s zLLVMJitCode._from_ctypecs,ˆ ˆjj¡ˆ_‡fdd„ˆjjDƒˆ_dS)z#Create types for function argumentscr;r)rur=r@rrrA²rBz,LLVMJitCode._create_args..N)rurgÚret_typeriÚ arg_ctypesrh)rÚ func_argsrr@rÚ_create_args®sÿzLLVMJitCode._create_argscCsPd}td7a|ttƒ|_t |j¡t |j|j¡}tj |j ||jd|_dS)z,Create function with name and type signatureZjit_funcrC)rN)Úcurrent_link_suffixrtrkÚ link_namesÚaddrr4rirhr5rr)rZdefault_link_namer8rrrÚ_create_function_base´sz!LLVMJitCode._create_function_basecCs:t|ƒD]\}}t|ƒ|jj|_|jj||j|<qdS)z0Mapping of symbolic values to function argumentsN)Ú enumeratertrrrrj©rrxÚir?rrrÚ_create_param_dict¿sþzLLVMJitCode._create_param_dictcCsZ|j d¡}t |¡}t|j||j|jd}| ||¡}|j | ||¡¡t|jƒ}|S)ú'Create function body and return LLVM IRÚentry©r )rÚappend_basic_blockrÚ IRBuilderr rrjÚ _convert_exprrÚretÚ_wrap_returnrt)rr(Úbb_entryrÚljrˆÚstrmodrrrÚ_create_functionÅs ÿ zLLVMJitCode._create_functioncsâ|jjtjkr|dSt t d¡¡}t ||jg¡}t ˆj |d¡‰‡‡fdd„|Dƒ}t|ƒdkr9|d}|St d¡g}| |gt|ƒ¡t ||¡}t ˆj |d¡} t t d¡t|ƒ¡g} | |¡ˆj | | ¡}|S)NrrWZPyFloat_FromDoublecsg|] }ˆj ˆ|g¡‘qSr)rr6)r>Úv©r‹Zwrap_fnrrrAâsz,LLVMJitCode._wrap_return..rCZPyTuple_Pack)rgrvrmrorr]r[r4rr5rÚlenÚextendr"rr6)rr‹ÚvalsZvoid_ptrZ wrap_typeZwrapped_valsZ final_valZtuple_arg_typesZ tuple_typeZtuple_fnZ tuple_argsrrrr‰Ós"õ zLLVMJitCode._wrap_returnc s–z3t|ƒdkr2|d}|d}t|ƒdkr |jjtjkr tdƒ‚|D]\}}ˆ |¡}ˆ ||¡q"Wnty?|g}Ynw‡fdd„|Dƒ}|S)Nr0rrCz>Return of multiple expressions not supported for this callbackcr;rr<)r>rE©r‹rrrArBz-LLVMJitCode._convert_expr..) rrgrvrmroÚNotImplementedErrorr2r!rM) rr‹r(Z tmp_exprsZfinal_exprsrrEr.r’rr“rr‡ös € ÿzLLVMJitCode._convert_exprcCsrt |¡}t ¡}d|_t ¡}| |¡| |¡tj ¡ ¡}t ||¡}| ¡t |¡ | |j¡}|S)Nr0)ÚllvmZparse_assemblyZcreate_pass_manager_builderÚ opt_levelZcreate_module_pass_managerZpopulateÚrunZTargetZfrom_default_tripleZcreate_target_machineZcreate_mcjit_compilerZfinalize_objectÚexe_enginesÚappendrsZ emit_assemblyZget_function_addressrk)rrŒZllmodZpmbZpass_managerZtarget_machineZexe_engÚfptrrrrÚ_compile_functions ÿ zLLVMJitCode._compile_functionN)rKrPrQrruryr}rrr‰r‡r›rrrrre•s #recrT)ÚLLVMJitCodeCallbackcstƒ |¡dSrrVrlrrrr#szLLVMJitCodeCallback.__init__cCsdt|ƒD]+\}}t|tƒr"|jj||f|j|<t|ƒ|jj|_q|jj|jj |f|j|<qdSr) r~Ú isinstancerrrrjrtrrgÚ input_argrrrrr&s ÿûz&LLVMJitCodeCallback._create_param_dictcCsÚ|j d¡}t |¡}t|j||j|jd}| ||¡}|jj r\| |jj|jj t |j ¡¡}t|ƒD]\}}t t d¡|¡} | || g¡} | || ¡q4| t t d¡d¡¡n |j | ||¡¡t|jƒ}|S)r‚rƒr„rWr)rr…rr†rUrrjr‡rgÚret_argr\rr]rr~r"r[rZÚstorerˆrr‰rt)rr(rŠrr‹rˆZ output_fp_ptrr€r.ÚindexZoutput_array_ptrrŒrrrr/s$ ÿ ÿ z$LLVMJitCodeCallback._create_function)rKrPrQrrrrSrrrrrœ"s rœc@seZdZdd„ZdS)Ú CodeSignaturecCs||_g|_d|_d|_dSrI)rvrwržrŸ)rrvrrrrIs zCodeSignature.__init__N)rKrPrQrrrrrr¢Hsr¢cCsP|dur t|ƒ}nt|ƒ}| |¡| ¡| |¡| |¡} | |¡}|S)z5Create a native code function from a Sympy expressionN)rerœryr}rrrsr›)rr(rgÚ callback_typeZjitrŒršrrrÚ_llvm_jit_codeUs r¤)rZscipy)Úmodulesc Cs tstdƒ‚ttjƒ}g}|dur|D] }tj}| |¡qnF|dks'|dkr>tj|_tjt tj¡g}tjtjg}d|_ n'|dkr_tjt tj¡tjtjt tj¡g}tj|_d|_ d|_nt d|ƒ‚||_t||||ƒ}|rw|dkrw|}tj|jg|¢RŽ|ƒ} | S) aNCompile function from a Sympy expression Expressions are evaluated using double precision arithmetic. Some single argument math functions (exp, sin, cos, etc.) are supported in expressions. Parameters ========== args : List of Symbol Arguments to the generated function. Usually the free symbols in the expression. Currently each one is assumed to convert to a double precision scalar. expr : Expr, or (Replacements, Expr) as returned from 'cse' Expression to compile. callback_type : string Create function with signature appropriate to use as a callback. Currently supported: 'scipy.integrate' 'scipy.integrate.test' 'cubature' Returns ======= Compiled function that can evaluate the expression. Examples ======== >>> import sympy.printing.llvmjitcode as jit >>> from sympy.abc import a >>> e = a*a + a + 1 >>> e1 = jit.llvm_callable([a], e) >>> e.subs(a, 1.1) # Evaluate via substitution 3.31000000000000 >>> e1(1.1) # Evaluate using JIT-compiled code 3.3100000000000005 Callbacks for integration functions can be JIT compiled. >>> import sympy.printing.llvmjitcode as jit >>> from sympy.abc import a >>> from sympy import integrate >>> from scipy.integrate import quad >>> e = a*a >>> e1 = jit.llvm_callable([a], e, callback_type='scipy.integrate') >>> integrate(e, (a, 0.0, 2.0)) 2.66666666666667 >>> quad(e1, 0.0, 2.0)[0] 2.66666666666667 The 'cubature' callback is for the Python wrapper around the cubature package ( https://github.com/saullocastro/cubature ) and ( http://ab-initio.mit.edu/wiki/index.php/Cubature ) There are two signatures for the SciPy integration callbacks. The first ('scipy.integrate') is the function to be passed to the integration routine, and will pass the signature checks. The second ('scipy.integrate.test') is only useful for directly calling the function using ctypes variables. It will not pass the signature checks for scipy.integrate. The return value from the cse module can also be compiled. This can improve the performance of the compiled function. If multiple expressions are given to cse, the compiled function returns a tuple. The 'cubature' callback handles multiple expressions (set `fdim` to match in the integration call.) >>> import sympy.printing.llvmjitcode as jit >>> from sympy import cse >>> from sympy.abc import x,y >>> e1 = x*x + y*y >>> e2 = 4*(x*x + y*y) + 8.0 >>> after_cse = cse([e1,e2]) >>> after_cse ([(x0, x**2), (x1, y**2)], [x0 + x1, 4*x0 + 4*x1 + 8.0]) >>> j1 = jit.llvm_callable([x,y], after_cse) # doctest: +SKIP >>> j1(1.0, 2.0) # doctest: +SKIP (5.0, 28.0) z$llvmlite is required for llvmjitcodeNzscipy.integratezscipy.integrate.testrCZcubatureézUnknown callback type: %s)rrr¢rmrrror™rvrnrpržrqrŸÚ ValueErrorrwr¤Z CFUNCTYPE) rr(r£rgrwÚ_Z arg_ctypeZarg_ctypes_formalršZcfuncrrrrgs>S þ ür)rRrmZsympy.externalrZsympy.printing.printerrZsympyrrZsympy.utilities.decoratorrrZirrZbindingr•Z initializeZinitialize_native_targetZinitialize_native_asmprinterZ__doctest_requires__r rUr˜Úsetr{rzrerœr¢r¤rrrrrÚs4 W&