neulab/docprompting-conala huggingface dataset:
numpy.core.defchararray.asarray   core.defchararray.asarray(obj, itemsize=None, unicode=None, order=None)[source]
 
Convert the input to a chararray, copying the data only if necessary. Versus a regular NumPy array of type str or unicode, this class adds the following functionality:  values automatically have whitespace removed from the end when indexed comparison operators automatically remove whitespace from the end when comparing values vectorized string operations are provided as methods (e.g. str.endswith) and infix operators (e.g. +, *,``%``)   Parameters 
 
objarray of str or unicode-like


itemsizeint, optional


itemsize is the number of characters per scalar in the resulting array. If itemsize is None, and obj is an object array or a Python list, the itemsize will be automatically determined. If itemsize is provided and obj is of type str or unicode, then the obj string will be chunked into itemsize pieces.  
unicodebool, optional


When true, the resulting chararray can contain Unicode characters, when false only 8-bit characters. If unicode is None and obj is one of the following:  a chararray, an ndarray of type str or ‘unicode` a Python str or unicode object,  then the unicode setting of the output array will be automatically determined.  
order{‘C’, ‘F’}, optional


Specify the order of the array. If order is ‘C’ (default), then the array will be in C-contiguous order (last-index varies the fastest). If order is ‘F’, then the returned array will be in Fortran-contiguous order (first-index varies the fastest).
numpy.core.records.array   core.records.array(obj, dtype=None, shape=None, offset=0, strides=None, formats=None, names=None, titles=None, aligned=False, byteorder=None, copy=True)[source]
 
Construct a record array from a wide-variety of objects. A general-purpose record array constructor that dispatches to the appropriate recarray creation function based on the inputs (see Notes).  Parameters 
 
objany


Input object. See Notes for details on how various input types are treated.  
dtypedata-type, optional


Valid dtype for array.  
shapeint or tuple of ints, optional


Shape of each array.  
offsetint, optional


Position in the file or buffer to start reading from.  
stridestuple of ints, optional


Buffer (buf) is interpreted according to these strides (strides define how many bytes each array element, row, column, etc. occupy in memory).  formats, names, titles, aligned, byteorder :

If dtype is None, these arguments are passed to numpy.format_parser to construct a dtype. See that function for detailed documentation.  
copybool, optional


Whether to copy the input object (True), or to use a reference instead. This option only applies when the input is an ndarray or recarray. Defaults to True.    Returns 
 np.recarray

Record array created from the specified object.     Notes If obj is None, then call the recarray constructor. If obj is a string, then call the fromstring constructor. If obj is a list or a tuple, then if the first object is an ndarray, call fromarrays, otherwise call fromrecords. If obj is a recarray, then make a copy of the data in the recarray (if copy=True) and use the new formats, names, and titles. If obj is a file, then call fromfile. Finally, if obj is an ndarray, then return obj.view(recarray), making a copy of the data if copy=True. Examples >>> a = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
array([[1, 2, 3],
       [4, 5, 6],
       [7, 8, 9]])
 >>> np.core.records.array(a)
rec.array([[1, 2, 3],
           [4, 5, 6],
           [7, 8, 9]],
    dtype=int32)
 >>> b = [(1, 1), (2, 4), (3, 9)]
>>> c = np.core.records.array(b, formats = ['i2', 'f2'], names = ('x', 'y'))
>>> c
rec.array([(1, 1.0), (2, 4.0), (3, 9.0)],
          dtype=[('x', '<i2'), ('y', '<f2')])
 >>> c.x
rec.array([1, 2, 3], dtype=int16)
 >>> c.y
rec.array([ 1.0,  4.0,  9.0], dtype=float16)
 >>> r = np.rec.array(['abc','def'], names=['col1','col2'])
>>> print(r.col1)
abc
 >>> r.col1
array('abc', dtype='<U3')
 >>> r.col2
array('def', dtype='<U3')
numpy.core.records.fromarrays   core.records.fromarrays(arrayList, dtype=None, shape=None, formats=None, names=None, titles=None, aligned=False, byteorder=None)[source]
 
Create a record array from a (flat) list of arrays  Parameters 
 
arrayListlist or tuple


List of array-like objects (such as lists, tuples, and ndarrays).  
dtypedata-type, optional


valid dtype for all arrays  
shapeint or tuple of ints, optional


Shape of the resulting array. If not provided, inferred from arrayList[0].  formats, names, titles, aligned, byteorder :

If dtype is None, these arguments are passed to numpy.format_parser to construct a dtype. See that function for detailed documentation.    Returns 
 np.recarray

Record array consisting of given arrayList columns.     Examples >>> x1=np.array([1,2,3,4])
>>> x2=np.array(['a','dd','xyz','12'])
>>> x3=np.array([1.1,2,3,4])
>>> r = np.core.records.fromarrays([x1,x2,x3],names='a,b,c')
>>> print(r[1])
(2, 'dd', 2.0) # may vary
>>> x1[1]=34
>>> r.a
array([1, 2, 3, 4])
 >>> x1 = np.array([1, 2, 3, 4])
>>> x2 = np.array(['a', 'dd', 'xyz', '12'])
>>> x3 = np.array([1.1, 2, 3,4])
>>> r = np.core.records.fromarrays(
...     [x1, x2, x3],
...     dtype=np.dtype([('a', np.int32), ('b', 'S3'), ('c', np.float32)]))
>>> r
rec.array([(1, b'a', 1.1), (2, b'dd', 2. ), (3, b'xyz', 3. ),
           (4, b'12', 4. )],
          dtype=[('a', '<i4'), ('b', 'S3'), ('c', '<f4')])
numpy.core.records.fromfile   core.records.fromfile(fd, dtype=None, shape=None, offset=0, formats=None, names=None, titles=None, aligned=False, byteorder=None)[source]
 
Create an array from binary file data  Parameters 
 
fdstr or file type


If file is a string or a path-like object then that file is opened, else it is assumed to be a file object. The file object must support random access (i.e. it must have tell and seek methods).  
dtypedata-type, optional


valid dtype for all arrays  
shapeint or tuple of ints, optional


shape of each array.  
offsetint, optional


Position in the file to start reading from.  formats, names, titles, aligned, byteorder :

If dtype is None, these arguments are passed to numpy.format_parser to construct a dtype. See that function for detailed documentation    Returns 
 np.recarray

record array consisting of data enclosed in file.     Examples >>> from tempfile import TemporaryFile
>>> a = np.empty(10,dtype='f8,i4,a5')
>>> a[5] = (0.5,10,'abcde')
>>>
>>> fd=TemporaryFile()
>>> a = a.newbyteorder('<')
>>> a.tofile(fd)
>>>
>>> _ = fd.seek(0)
>>> r=np.core.records.fromfile(fd, formats='f8,i4,a5', shape=10,
... byteorder='<')
>>> print(r[5])
(0.5, 10, 'abcde')
>>> r.shape
(10,)
numpy.core.records.fromrecords   core.records.fromrecords(recList, dtype=None, shape=None, formats=None, names=None, titles=None, aligned=False, byteorder=None)[source]
 
Create a recarray from a list of records in text form.  Parameters 
 
recListsequence


data in the same field may be heterogeneous - they will be promoted to the highest data type.  
dtypedata-type, optional


valid dtype for all arrays  
shapeint or tuple of ints, optional


shape of each array.  formats, names, titles, aligned, byteorder :

If dtype is None, these arguments are passed to numpy.format_parser to construct a dtype. See that function for detailed documentation. If both formats and dtype are None, then this will auto-detect formats. Use list of tuples rather than list of lists for faster processing.    Returns 
 np.recarray

record array consisting of given recList rows.     Examples >>> r=np.core.records.fromrecords([(456,'dbe',1.2),(2,'de',1.3)],
... names='col1,col2,col3')
>>> print(r[0])
(456, 'dbe', 1.2)
>>> r.col1
array([456,   2])
>>> r.col2
array(['dbe', 'de'], dtype='<U3')
>>> import pickle
>>> pickle.loads(pickle.dumps(r))
rec.array([(456, 'dbe', 1.2), (  2, 'de', 1.3)],
          dtype=[('col1', '<i8'), ('col2', '<U3'), ('col3', '<f8')])
numpy.core.records.fromstring   core.records.fromstring(datastring, dtype=None, shape=None, offset=0, formats=None, names=None, titles=None, aligned=False, byteorder=None)[source]
 
Create a record array from binary data Note that despite the name of this function it does not accept str instances.  Parameters 
 
datastringbytes-like


Buffer of binary data  
dtypedata-type, optional


Valid dtype for all arrays  
shapeint or tuple of ints, optional


Shape of each array.  
offsetint, optional


Position in the buffer to start reading from.  formats, names, titles, aligned, byteorder :

If dtype is None, these arguments are passed to numpy.format_parser to construct a dtype. See that function for detailed documentation.    Returns 
 np.recarray

Record array view into the data in datastring. This will be readonly if datastring is readonly.      See also  numpy.frombuffer
  Examples >>> a = b'\x01\x02\x03abc'
>>> np.core.records.fromstring(a, dtype='u1,u1,u1,S3')
rec.array([(1, 2, 3, b'abc')],
        dtype=[('f0', 'u1'), ('f1', 'u1'), ('f2', 'u1'), ('f3', 'S3')])
 >>> grades_dtype = [('Name', (np.str_, 10)), ('Marks', np.float64),
...                 ('GradeLevel', np.int32)]
>>> grades_array = np.array([('Sam', 33.3, 3), ('Mike', 44.4, 5),
...                         ('Aadi', 66.6, 6)], dtype=grades_dtype)
>>> np.core.records.fromstring(grades_array.tobytes(), dtype=grades_dtype)
rec.array([('Sam', 33.3, 3), ('Mike', 44.4, 5), ('Aadi', 66.6, 6)],
        dtype=[('Name', '<U10'), ('Marks', '<f8'), ('GradeLevel', '<i4')])
 >>> s = '\x01\x02\x03abc'
>>> np.core.records.fromstring(s, dtype='u1,u1,u1,S3')
Traceback (most recent call last)
   ...
TypeError: a bytes-like object is required, not 'str'
numpy.DataSource.abspath method   DataSource.abspath(path)[source]
 
Return absolute path of file in the DataSource directory. If path is an URL, then abspath will return either the location the file exists locally or the location it would exist when opened using the open method.  Parameters 
 
pathstr


Can be a local file or a remote URL.    Returns 
 
outstr


Complete path, including the DataSource destination directory.     Notes The functionality is based on os.path.abspath.
numpy.DataSource.exists method   DataSource.exists(path)[source]
 
Test if path exists. Test if path exists as (and in this order):  a local file. a remote URL that has been downloaded and stored locally in the DataSource directory. a remote URL that has not been downloaded, but is valid and accessible.   Parameters 
 
pathstr


Can be a local file or a remote URL.    Returns 
 
outbool


True if path exists.     Notes When path is an URL, exists will return True if it’s either stored locally in the DataSource directory, or is a valid remote URL. DataSource does not discriminate between the two, the file is accessible if it exists in either location.
numpy.DataSource.open method   DataSource.open(path, mode='r', encoding=None, newline=None)[source]
 
Open and return file-like object. If path is an URL, it will be downloaded, stored in the DataSource directory and opened from there.  Parameters 
 
pathstr


Local file path or URL to open.  
mode{‘r’, ‘w’, ‘a’}, optional


Mode to open path. Mode ‘r’ for reading, ‘w’ for writing, ‘a’ to append. Available modes depend on the type of object specified by path. Default is ‘r’.  
encoding{None, str}, optional


Open text file with given encoding. The default encoding will be what io.open uses.  
newline{None, str}, optional


Newline to use when reading text file.    Returns 
 
outfile object


File object.
numpy.distutils.ccompiler.CCompiler_compile   distutils.ccompiler.CCompiler_compile(self, sources, output_dir=None, macros=None, include_dirs=None, debug=0, extra_preargs=None, extra_postargs=None, depends=None)[source]
 
Compile one or more source files. Please refer to the Python distutils API reference for more details.  Parameters 
 
sourceslist of str


A list of filenames  
output_dirstr, optional


Path to the output directory.  
macroslist of tuples


A list of macro definitions.  
include_dirslist of str, optional


The directories to add to the default include file search path for this compilation only.  
debugbool, optional


Whether or not to output debug symbols in or alongside the object file(s).  
extra_preargs, extra_postargs?


Extra pre- and post-arguments.  
dependslist of str, optional


A list of file names that all targets depend on.    Returns 
 
objectslist of str


A list of object file names, one per source file sources.    Raises 
 CompileError

If compilation fails.
numpy.distutils.ccompiler.CCompiler_customize   distutils.ccompiler.CCompiler_customize(self, dist, need_cxx=0)[source]
 
Do any platform-specific customization of a compiler instance. This method calls distutils.sysconfig.customize_compiler for platform-specific customization, as well as optionally remove a flag to suppress spurious warnings in case C++ code is being compiled.  Parameters 
 
distobject


This parameter is not used for anything.  
need_cxxbool, optional


Whether or not C++ has to be compiled. If so (True), the "-Wstrict-prototypes" option is removed to prevent spurious warnings. Default is False.    Returns 
 None
   Notes All the default options used by distutils can be extracted with: from distutils import sysconfig
sysconfig.get_config_vars('CC', 'CXX', 'OPT', 'BASECFLAGS',
                          'CCSHARED', 'LDSHARED', 'SO')
numpy.distutils.ccompiler.CCompiler_customize_cmd   distutils.ccompiler.CCompiler_customize_cmd(self, cmd, ignore=())[source]
 
Customize compiler using distutils command.  Parameters 
 
cmdclass instance


An instance inheriting from distutils.cmd.Command.  
ignoresequence of str, optional


List of CCompiler commands (without 'set_') that should not be altered. Strings that are checked for are: ('include_dirs', 'define', 'undef', 'libraries', 'library_dirs',
'rpath', 'link_objects').    Returns 
 None
numpy.distutils.ccompiler.CCompiler_cxx_compiler   distutils.ccompiler.CCompiler_cxx_compiler(self)[source]
 
Return the C++ compiler.  Parameters 
 None
  Returns 
 
cxxclass instance


The C++ compiler, as a CCompiler instance.
numpy.distutils.ccompiler.CCompiler_find_executables   distutils.ccompiler.CCompiler_find_executables(self)[source]
 
Does nothing here, but is called by the get_version method and can be overridden by subclasses. In particular it is redefined in the FCompiler class where more documentation can be found.
numpy.distutils.ccompiler.CCompiler_get_version   distutils.ccompiler.CCompiler_get_version(self, force=False, ok_status=[0])[source]
 
Return compiler version, or None if compiler is not available.  Parameters 
 
forcebool, optional


If True, force a new determination of the version, even if the compiler already has a version attribute. Default is False.  
ok_statuslist of int, optional


The list of status values returned by the version look-up process for which a version string is returned. If the status value is not in ok_status, None is returned. Default is [0].    Returns 
 
versionstr or None


Version string, in the format of distutils.version.LooseVersion.
numpy.distutils.ccompiler.CCompiler_object_filenames   distutils.ccompiler.CCompiler_object_filenames(self, source_filenames, strip_dir=0, output_dir='')[source]
 
Return the name of the object files for the given source files.  Parameters 
 
source_filenameslist of str


The list of paths to source files. Paths can be either relative or absolute, this is handled transparently.  
strip_dirbool, optional


Whether to strip the directory from the returned paths. If True, the file name prepended by output_dir is returned. Default is False.  
output_dirstr, optional


If given, this path is prepended to the returned paths to the object files.    Returns 
 
obj_nameslist of str


The list of paths to the object files corresponding to the source files in source_filenames.
numpy.distutils.ccompiler.CCompiler_show_customization   distutils.ccompiler.CCompiler_show_customization(self)[source]
 
Print the compiler customizations to stdout.  Parameters 
 None
  Returns 
 None
   Notes Printing is only done if the distutils log threshold is < 2.
numpy.distutils.ccompiler.CCompiler_spawn   distutils.ccompiler.CCompiler_spawn(self, cmd, display=None, env=None)[source]
 
Execute a command in a sub-process.  Parameters 
 
cmdstr


The command to execute.  
displaystr or sequence of str, optional


The text to add to the log file kept by numpy.distutils. If not given, display is equal to cmd.  env: a dictionary for environment variables, optional
  Returns 
 None
  Raises 
 DistutilsExecError

If the command failed, i.e. the exit status was not 0.
numpy.distutils.ccompiler.gen_lib_options   distutils.ccompiler.gen_lib_options(compiler, library_dirs, runtime_library_dirs, libraries)[source]
numpy.distutils.ccompiler.new_compiler   distutils.ccompiler.new_compiler(plat=None, compiler=None, verbose=None, dry_run=0, force=0)[source]
numpy.distutils.ccompiler.replace_method   distutils.ccompiler.replace_method(klass, method_name, func)[source]
numpy.distutils.ccompiler.simple_version_match   distutils.ccompiler.simple_version_match(pat='[-.\\d]+', ignore='', start='')[source]
 
Simple matching of version numbers, for use in CCompiler and FCompiler.  Parameters 
 
patstr, optional


A regular expression matching version numbers. Default is r'[-.\d]+'.  
ignorestr, optional


A regular expression matching patterns to skip. Default is '', in which case nothing is skipped.  
startstr, optional


A regular expression matching the start of where to start looking for version numbers. Default is '', in which case searching is started at the beginning of the version string given to matcher.    Returns 
 
matchercallable


A function that is appropriate to use as the .version_match attribute of a CCompiler class. matcher takes a single parameter, a version string.
numpy.distutils.ccompiler_opt.CCompilerOpt.cache_flush method   distutils.ccompiler_opt.CCompilerOpt.cache_flush()[source]
 
Force update the cache.
numpy.distutils.ccompiler_opt.CCompilerOpt.cc_normalize_flags method   distutils.ccompiler_opt.CCompilerOpt.cc_normalize_flags(flags)[source]
 
Remove the conflicts that caused due gathering implied features flags.  Parameters 
 ‘flags’ list, compiler flags

flags should be sorted from the lowest to the highest interest.    Returns 
 list, filtered from any conflicts.
   Examples >>> self.cc_normalize_flags(['-march=armv8.2-a+fp16', '-march=armv8.2-a+dotprod'])
['armv8.2-a+fp16+dotprod']
 >>> self.cc_normalize_flags(
    ['-msse', '-msse2', '-msse3', '-mssse3', '-msse4.1', '-msse4.2', '-mavx', '-march=core-avx2']
)
['-march=core-avx2']
numpy.distutils.ccompiler_opt.CCompilerOpt.conf_features attribute   distutils.ccompiler_opt.CCompilerOpt.conf_features = {'ASIMD': {'implies': 'NEON_FP16 NEON_VFPV4', 'implies_detect': False, 'interest': 4}, 'ASIMDDP': {'implies': 'ASIMD', 'interest': 6}, 'ASIMDFHM': {'implies': 'ASIMDHP', 'interest': 7}, 'ASIMDHP': {'implies': 'ASIMD', 'interest': 5}, 'AVX': {'headers': 'immintrin.h', 'implies': 'SSE42', 'implies_detect': False, 'interest': 8}, 'AVX2': {'implies': 'F16C', 'interest': 13}, 'AVX512CD': {'implies': 'AVX512F', 'interest': 21}, 'AVX512F': {'extra_checks': 'AVX512F_REDUCE', 'implies': 'FMA3 AVX2', 'implies_detect': False, 'interest': 20}, 'AVX512_CLX': {'detect': 'AVX512_CLX', 'group': 'AVX512VNNI', 'implies': 'AVX512_SKX', 'interest': 43}, 'AVX512_CNL': {'detect': 'AVX512_CNL', 'group': 'AVX512IFMA AVX512VBMI', 'implies': 'AVX512_SKX', 'implies_detect': False, 'interest': 44}, 'AVX512_ICL': {'detect': 'AVX512_ICL', 'group': 'AVX512VBMI2 AVX512BITALG AVX512VPOPCNTDQ', 'implies': 'AVX512_CLX AVX512_CNL', 'implies_detect': False, 'interest': 45}, 'AVX512_KNL': {'detect': 'AVX512_KNL', 'group': 'AVX512ER AVX512PF', 'implies': 'AVX512CD', 'implies_detect': False, 'interest': 40}, 'AVX512_KNM': {'detect': 'AVX512_KNM', 'group': 'AVX5124FMAPS AVX5124VNNIW AVX512VPOPCNTDQ', 'implies': 'AVX512_KNL', 'implies_detect': False, 'interest': 41}, 'AVX512_SKX': {'detect': 'AVX512_SKX', 'extra_checks': 'AVX512BW_MASK AVX512DQ_MASK', 'group': 'AVX512VL AVX512BW AVX512DQ', 'implies': 'AVX512CD', 'implies_detect': False, 'interest': 42}, 'F16C': {'implies': 'AVX', 'interest': 11}, 'FMA3': {'implies': 'F16C', 'interest': 12}, 'FMA4': {'headers': 'x86intrin.h', 'implies': 'AVX', 'interest': 10}, 'NEON': {'headers': 'arm_neon.h', 'interest': 1}, 'NEON_FP16': {'implies': 'NEON', 'interest': 2}, 'NEON_VFPV4': {'implies': 'NEON_FP16', 'interest': 3}, 'POPCNT': {'headers': 'popcntintrin.h', 'implies': 'SSE41', 'interest': 6}, 'SSE': {'headers': 'xmmintrin.h', 'implies': 'SSE2', 'interest': 1}, 'SSE2': {'headers': 'emmintrin.h', 'implies': 'SSE', 'interest': 2}, 'SSE3': {'headers': 'pmmintrin.h', 'implies': 'SSE2', 'interest': 3}, 'SSE41': {'headers': 'smmintrin.h', 'implies': 'SSSE3', 'interest': 5}, 'SSE42': {'implies': 'POPCNT', 'interest': 7}, 'SSSE3': {'headers': 'tmmintrin.h', 'implies': 'SSE3', 'interest': 4}, 'VSX': {'extra_checks': 'VSX_ASM', 'headers': 'altivec.h', 'interest': 1}, 'VSX2': {'implies': 'VSX', 'implies_detect': False, 'interest': 2}, 'VSX3': {'implies': 'VSX2', 'implies_detect': False, 'interest': 3}, 'XOP': {'headers': 'x86intrin.h', 'implies': 'AVX', 'interest': 9}}
numpy.distutils.ccompiler_opt.CCompilerOpt.conf_features_partial method   distutils.ccompiler_opt.CCompilerOpt.conf_features_partial()[source]
 
Return a dictionary of supported CPU features by the platform, and accumulate the rest of undefined options in conf_features, the returned dict has same rules and notes in class attribute conf_features, also its override any options that been set in ‘conf_features’.
numpy.distutils.ccompiler_opt.CCompilerOpt.cpu_baseline_flags method   distutils.ccompiler_opt.CCompilerOpt.cpu_baseline_flags()[source]
 
Returns a list of final CPU baseline compiler flags
numpy.distutils.ccompiler_opt.CCompilerOpt.cpu_baseline_names method   distutils.ccompiler_opt.CCompilerOpt.cpu_baseline_names()[source]
 
return a list of final CPU baseline feature names
numpy.distutils.ccompiler_opt.CCompilerOpt.cpu_dispatch_names method   distutils.ccompiler_opt.CCompilerOpt.cpu_dispatch_names()[source]
 
return a list of final CPU dispatch feature names
numpy.distutils.ccompiler_opt.CCompilerOpt.dist_compile method   distutils.ccompiler_opt.CCompilerOpt.dist_compile(sources, flags, ccompiler=None, **kwargs)[source]
 
Wrap CCompiler.compile()
numpy.distutils.ccompiler_opt.CCompilerOpt.dist_info method   distutils.ccompiler_opt.CCompilerOpt.dist_info()[source]
 
Return a tuple containing info about (platform, compiler, extra_args), required by the abstract class ‘_CCompiler’ for discovering the platform environment. This is also used as a cache factor in order to detect any changes happening from outside.
numpy.distutils.ccompiler_opt.CCompilerOpt.dist_test method   distutils.ccompiler_opt.CCompilerOpt.dist_test(source, flags, macros=[])[source]
 
Return True if ‘CCompiler.compile()’ able to compile a source file with certain flags.
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_ahead method   distutils.ccompiler_opt.CCompilerOpt.feature_ahead(names)[source]
 
Return list of features in ‘names’ after remove any implied features and keep the origins.  Parameters 
 ‘names’: sequence

sequence of CPU feature names in uppercase.    Returns 
 list of CPU features sorted as-is ‘names’
   Examples >>> self.feature_ahead(["SSE2", "SSE3", "SSE41"])
["SSE41"]
# assume AVX2 and FMA3 implies each other and AVX2
# is the highest interest
>>> self.feature_ahead(["SSE2", "SSE3", "SSE41", "AVX2", "FMA3"])
["AVX2"]
# assume AVX2 and FMA3 don't implies each other
>>> self.feature_ahead(["SSE2", "SSE3", "SSE41", "AVX2", "FMA3"])
["AVX2", "FMA3"]
numpy.distutils.ccompiler_opt.CCompilerOpt.feature_c_preprocessor method   distutils.ccompiler_opt.CCompilerOpt.feature_c_preprocessor(feature_name, tabs=0)[source]
 
Generate C preprocessor definitions and include headers of a CPU feature.  Parameters 
 ‘feature_name’: str

CPU feature name in uppercase.  ‘tabs’: int

if > 0, align the generated strings to the right depend on number of tabs.    Returns 
 str, generated C preprocessor
   Examples >>> self.feature_c_preprocessor("SSE3")
/** SSE3 **/
#define NPY_HAVE_SSE3 1
#include <pmmintrin.h>