Function FunctionFactory

code_generators/interp_generator.py:1072–1361

Functions are declinated from operations in cases where the name of the function might change with the library and the dtype. Therefore where possible we use simple rules to build functions, but tables are required. cmath.h functions should be overloaded for modern implement

(opsList: List[Operation], C11: bool=True, mkl: bool=False )

NUMPY_VML_PRE = { 'd': 'vd', 'f':'vs', 'F':'vz', 'D':'vc' }
def FunctionFactory(opsList: List[Operation], C11: bool=True, mkl: bool=False ) -> None:
    '''
    Functions are declinated from operations in cases where the name of the 
    function might change with the library and the dtype.  Therefore where 
    possible we use simple rules to build functions, but tables are required.
    
    cmath.h functions should be overloaded for modern implementations. Some 
    pre-C++/11 implementations (e.g. MSVC), have appended 'f's for the 
    single-precision version. Cmath funcs return the value, i.e. they are not 
    vectorized, but they are usually inlined.
    
    NumExpr complex funtions are prepended by: nc_{function},
        e.g. nc_conj()
    and the return is the last argument.  They are now vectorized, like VML 
    functions, so they need the number of iterators as the first argument.
    
    Intel VML functions are prepended by: v{datatype}{Function},
        e.g. vfSin()
    and the return is the last argument
    
    '''
    global OP_COUNT
    
    ####################
    opsList += [ Operation( 'abs', '$DEST = $ARG1 < 0 ? -$ARG1 : $ARG1', LIB_STD,
                   SIGNED_INT, [SIGNED_INT], vecType=TYPE_LOOP ) ]
    # TODO: test if `fabs()` is faster than ternary
    opsList += [ Operation( 'abs', '$DEST = fabs($ARG1)', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP ) ] 
    opsList += [ Operation( 'arccos', '$DEST = acos($ARG1)', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP ) ]       
    opsList += [ Operation( 'arcsin', '$DEST = asin($ARG1)', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP ) ]           
    opsList += [ Operation( 'arctan', '$DEST = atan($ARG1)', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP ) ] 
    opsList += [ Operation( 'arctan2', '$DEST = atan2($ARG1, $ARG2)', LIB_STD,
                   DECIMAL, [DECIMAL, DECIMAL], vecType=TYPE_LOOP ) ] 
    opsList += [ Operation( 'ceil', '$DEST = ceil($ARG1)', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP ) ]            
    opsList += [ Operation( 'cos', '$DEST = cos($ARG1)', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP ) ]           
    opsList += [ Operation( 'cosh', '$DEST = cosh($ARG1)', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP ) ]       
    opsList += [ Operation( 'exp', '$DEST = exp($ARG1)', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP ) ]         

    opsList += [ Operation( 'floor', '$DEST = floor($ARG1)', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP ) ] 


    # `scipy.special.factorial`` does _not_ round to the nearest integer
    # Also we force int8 and int16 to be up-cast here, otherwise overflow
    # happens very quickly.
    opsList += [ Operation( 'factorial', '$DEST = $ARG1 >= 0 ? ($DTYPE0)exp(lgamma(($DTYPE0)$ARG1 + 1)) : 0', LIB_STD,
                   [np.dtype('float64').char] * 6, [BIG_INT + DECIMAL], vecType=TYPE_LOOP) ] 
    
    opsList += [ Operation( 'rad2deg', '$DEST = $ARG1 * ($DTYPE0)57.2957795130823229', LIB_STD,
                   DECIMAL, [DECIMAL], vecType=TYPE_LOOP, aliases='degrees' ) ]