.. _l-functions: Functions ========= .. contents:: :local: :depth: 1 Summary +++++++ +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | function | class parent | truncated documentation | +=====================================================================================================================+==============+===========================================================================================================================================================================================+ | :func:`UnorderedMapRHStrInt64_Create ` | | Creates a faster unordered map `{ (str, int): int }`.\nThis map is using `robin_hood implementation `_. ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`UnorderedMapRHStrInt64_Get_Fast ` | | Inserts a value into a map `{ (str, int): int }` | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`UnorderedMapRHStrInt64_Insert_Fast ` | | Inserts a value into a map `{ (str, int): int }` | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`UnorderedMapStrInt64_Create ` | | Creates an unordered map `{ (str, int): int }`. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`UnorderedMapStrInt64_Get ` | | Inserts a value into a map `{ (str, int): int }` | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`UnorderedMapStrInt64_Get_Fast ` | | Inserts a value into a map `{ (str, int): int }` | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`UnorderedMapStrInt64_Insert ` | | Inserts a value into a map `{ (str, int): int }` | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`UnorderedMapStrInt64_Insert_Fast ` | | Inserts a value into a map `{ (str, int): int }` | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_fcts ` | | Returns functions to measure. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_profiling_delete ` | | Release all references on stored python objects. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_profiling_dump_and_clear ` | | Copies the buffer into another one allocated before calling this method.The function does not lock the :epkg:`GIL`. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_profiling_get_saved_maps ` | | Returns a tuple with two dictionaries. One for all the event frames, a second one for the event arguments. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_profiling_log_event ` | | Logs an event. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_profiling_n_columns ` | | Returns the number of informations stored per event. Total size must be multiplied `sizeof(int64_t)`. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_profiling_register_pyinstance ` | | Registers an object called when the buffer is full. This one should call @see fn _profiling_dump_and_clear to empty the ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_profiling_start ` | | Starts the profiler. One instance is stored in a static pointer. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_profiling_stop ` | | Stops the profiler. The function checks that the profiler was emptied. The static instance is removed. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`_setup_hook ` | | if this function is added to the module, the help automation and unit tests call it first before anything goes on ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`begin_capture ` | | Starts capturing the standard output. Signature: *def begin_capture():*. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`capture_output ` | | Catch standard output and error for function *function_to_call*. If lang is *'py'*, calls :func:`capture_output_py` ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`capture_output_c ` | | Capture the standard output and error for function *function_to_call*, it wraps C code which catches information ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`capture_output_py ` | | Capture the standard output and error for function *function_to_call* with function `redirect_stdout `_ ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`cblas_daxpy ` | | Calls axpy on double `cblas_daxpy `_. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`cblas_daxpy_void ` | | Calls axpy on double `cblas_daxpy `_. *x* ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`cblas_ddot ` | | Computes a dot product with `cblas_ddot `_. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`cblas_saxpy ` | | Calls axpy on float `cblas_saxpy `_. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`cblas_saxpy_void ` | | Calls axpy on double `cblas_daxpy `_. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`cblas_sdot ` | | Computes a dot product with `cblas_sdot `_. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`check ` | | Checks the library is working. It raises an exception. If you want to disable the logs: | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`check_speed ` | | Prints out some information about speed computation of this laptop. See :ref:`cbenchmarkbranchingrst` to compare. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`cprint ` | | Displays a string on the standard output in C++. Signature: *def cprint(*args):*. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`df2array ` | | Converts a dataframe into a :epkg:`numpy:array` without copying. :epkg:`pandas` is merging consecutive columns sharing ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`df2arrays ` | | Converts a dataframe into a list of a list of tuple *(column name, :epkg:`numpy:array`)* without copying. :epkg:`pandas` ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`dgelss ` | | Finds *X* in the problem :math:`AX=B` by minimizing :math:`\norm{AX - B}^2`. Uses function `dgels `_. ... | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`dummy_capsule ` | | Returns a dummy capsule with 128 uint32_t. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`edit_distance_string ` | | Computes the edit distance between strings *s1* and *s2*. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`end_capture ` | | Stops capturing the standard output. Signature: *def end_capture():*. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`get_capture ` | | Gets the captured output. Signature: *def get_capture() -> (str, str):*. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`get_memory_content ` | | Returns the content of the memory between addresses [ptr, ptr+size[ where ptr is the pointer held by the capsule. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`kill_thread ` | | Terminates a thread. Signature: *def kill_thread(int thread_id):*. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+ | :func:`measure_time ` | | Measures a statement and returns the results as a dictionary. | +---------------------------------------------------------------------------------------------------------------------+--------------+-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------+