pyemaps 2.0.0__py3-none-any.whl

pyemaps/CifFile/yapps3_compiled_rt.py

@@ -0,0 +1,390 @@
+#
+# Yapps 2 Runtime, part of Yapps 2 - yet another python parser system
+# Copyright 1999-2003 by Amit J. Patel <amitp@cs.stanford.edu>
+#
+# This version of the Yapps 2 Runtime can be distributed under the
+# terms of the MIT open source license, either found in the LICENSE file
+# included with the Yapps distribution
+# <http://theory.stanford.edu/~amitp/yapps/> or at
+# <http://www.opensource.org/licenses/mit-license.php>
+#
+# Modified for PyCIFRW by JRH to allow external scanner
+#
+# To maximize python3/python2 compatibility
+from __future__ import print_function
+from __future__ import unicode_literals
+from __future__ import division
+from __future__ import absolute_import
+
+""" Detail of JRH modifications.
+
+The compiled module handles all token administration by itself, but
+does not deal with restrictions.  It also effectively removes the
+context-sensitivity of Yapps, as it ignores restrictions, but
+these restrictions turn out to be  unnecessary for CIF.
+
+Interestingly, the module scan function is never called directly
+from python.
+
+"""
+
+"""Run time libraries needed to run parsers generated by Yapps.
+
+This module defines parse-time exception classes, a scanner class, a
+base class for parsers produced by Yapps, and a context class that
+keeps track of the parse stack.
+
+"""
+
+# TODO: it should be possible to embed yappsrt into the generated
+# grammar to make a standalone module.
+
+import sys, re
+
+
+# For normal installation this module is "emapsCifFile.yapps3_compiled_rt"
+# and StarScan is an extension module within the parent CifFile module.
+if __name__.startswith('pyemaps.CifFile.'):
+    try:
+        from . import StarScan
+        have_star_scan = True
+    except ImportError:
+        have_star_scan = False
+# Otherwise assume this is imported from the yapps3/yapps2.py script
+# that is executed from Makefile to generate YappsStarParser sources.
+else:
+    assert __name__ == 'yapps3_compiled_rt', "Unexpected module name."
+    assert sys.argv[0].endswith('yapps2.py'), (
+        "This should be reached only when running yapps2.py in Makefile.")
+    have_star_scan = False
+
+class YappsSyntaxError(Exception):
+    """When we run into an unexpected token, this is the exception to use"""
+    def __init__(self, charpos=-1, msg="Bad Token", context=None):
+        Exception.__init__(self)
+        self.charpos = charpos
+        self.msg = msg
+        self.context = context
+
+    def __str__(self):
+        if self.charpos < 0: return 'SyntaxError'
+        else: return 'SyntaxError@char%s(%s)' % (repr(self.charpos), self.msg)
+
+class NoMoreTokens(Exception):
+    """Another exception object, for when we run out of tokens"""
+    pass
+
+class Scanner:
+    """Yapps scanner.
+
+    The Yapps scanner can work in context sensitive or context
+    insensitive modes.  The token(i) method is used to retrieve the
+    i-th token.  It takes a restrict set that limits the set of tokens
+    it is allowed to return.  In context sensitive mode, this restrict
+    set guides the scanner.  In context insensitive mode, there is no
+    restriction (the set is always the full set of tokens).
+
+    """
+
+    def __init__(self, patterns, ignore, input, scantype="standard"):
+        """Initialize the scanner.
+
+        Parameters:
+          patterns : [(terminal, uncompiled regex), ...] or None
+          ignore : [terminal,...]
+          input : string
+
+        If patterns is None, we assume that the subclass has
+        defined self.patterns : [(terminal, compiled regex), ...].
+        Note that the patterns parameter expects uncompiled regexes,
+        whereas the self.patterns field expects compiled regexes.
+        """
+        self.tokens = [] # [(begin char pos, end char pos, token name, matched text), ...]
+        self.restrictions = []
+        self.input = input
+        self.pos = 0
+        self.ignore = ignore
+        self.scantype = scantype
+        self.first_line_number = 1
+        if self.scantype == "flex" and have_star_scan:
+            StarScan.prepare(input)
+            self.scan = self.compiled_scan
+            self.token = self.compiled_token
+            self.__del__ = StarScan.cleanup
+        elif self.scantype == "flex":
+            print("WARNING: using Python scanner although C scanner requested")
+            self.scantype = "standard"
+        if self.scantype != "flex":
+            self.scan = self.interp_scan
+            self.token = self.interp_token
+
+        if patterns is not None:
+            # Compile the regex strings into regex objects
+            self.patterns = []
+            for terminal, regex in patterns:
+                self.patterns.append( (terminal, re.compile(regex)) )
+
+    def get_token_pos(self):
+        """Get the current token position in the input text."""
+        return len(self.tokens)
+
+    def get_char_pos(self):
+        """Get the current char position in the input text."""
+        return self.pos
+
+    def get_prev_char_pos(self, i=None):
+        """Get the previous position (one token back) in the input text."""
+        if self.pos == 0: return 0
+        if i is None: i = -1
+        return self.tokens[i][0]
+
+    def get_line_number(self):
+        """Get the line number of the current position in the input text."""
+        # TODO: make this work at any token/char position
+        return self.first_line_number + self.get_input_scanned().count('\n')
+
+    def get_column_number(self):
+        """Get the column number of the current position in the input text."""
+        s = self.get_input_scanned()
+        i = s.rfind('\n') # may be -1, but that's okay in this case
+        return len(s) - (i+1)
+
+    def get_input_scanned(self):
+        """Get the portion of the input that has been tokenized."""
+        return self.input[:self.pos]
+
+    def get_input_unscanned(self):
+        """Get the portion of the input that has not yet been tokenized."""
+        return self.input[self.pos:]
+
+    def interp_token(self, i, restrict=None):
+        """Get the i'th token in the input.
+
+        If i is one past the end, then scan for another token.
+
+        Args:
+
+        restrict : [token, ...] or None; if restrict is None, then any
+        token is allowed.  You may call token(i) more than once.
+        However, the restrict set may never be larger than what was
+        passed in on the first call to token(i).
+
+        """
+        if i == len(self.tokens):
+            self.scan(restrict)
+        if i < len(self.tokens):
+            # Make sure the restriction is more restricted.  This
+            # invariant is needed to avoid ruining tokenization at
+            # position i+1 and higher.
+            if restrict and self.restrictions[i]:
+                for r in restrict:
+                    if r not in self.restrictions[i]:
+                        raise NotImplementedError("Unimplemented: restriction set changed")
+            return self.tokens[i]
+        raise NoMoreTokens()
+
+    def compiled_token(self,i,restrict=0):
+        try:
+            return StarScan.token(i)
+        except IndexError:
+            raise NoMoreTokens()
+
+    def __repr__(self):
+        """Print the last 10 tokens that have been scanned in"""
+        output = ''
+        if self.scantype != "flex":
+            for t in self.tokens[-10:]:
+                output = '%s\n  (@%s)  %s  =  %s' % (output,t[0],t[2],repr(t[3]))
+        else:
+            out_tokens = StarScan.last_ten()
+            for t in out_tokens:
+                output = '%s\n  (~line %s)  %s  =  %s' % (output,t[0],t[2],repr(t[3]))
+        return output
+
+    def interp_scan(self, restrict):
+        """Should scan another token and add it to the list, self.tokens,
+        and add the restriction to self.restrictions"""
+        # Prepare accepted pattern list
+        if restrict:
+           # only patterns in the 'restrict' parameter or in self.ignore
+           # are accepted
+           accepted_patterns=[]
+           for p_name, p_regexp in self.patterns:
+               if p_name not in restrict and p_name not in self.ignore:
+                   pass
+               else:
+                   accepted_patterns.append((p_name,p_regexp))
+        else:
+           # every pattern is good
+           accepted_patterns=self.patterns
+        # Keep looking for a token, ignoring any in self.ignore
+        while 1:
+            # Search the patterns for the longest match, with earlier
+            # tokens in the list having preference
+            best_match = -1
+            best_pat = '(error)'
+            for p,regexp in accepted_patterns:
+                m = regexp.match(self.input, self.pos)
+                if m and len(m.group(0)) > best_match:
+                    # We got a match that's better than the previous one
+                    best_pat = p
+                    best_match = len(m.group(0))
+
+            # If we didn't find anything, raise an error
+            if best_pat == '(error)' and best_match < 0:
+                msg = 'Bad Token'
+                if restrict:
+                    msg = 'Trying to find one of '+', '.join(restrict)
+                raise YappsSyntaxError(self.pos, msg)
+
+            # If we found something that isn't to be ignored, return it
+            if best_pat not in self.ignore:
+                # Create a token with this data
+                token = (self.pos, self.pos+best_match, best_pat,
+                         self.input[self.pos:self.pos+best_match])
+                self.pos = self.pos + best_match
+                # Only add this token if it's not in the list
+                # (to prevent looping)
+                if not self.tokens or token != self.tokens[-1]:
+                    self.tokens.append(token)
+                    self.restrictions.append(restrict)
+                return
+            else:
+                # This token should be ignored ..
+                self.pos = self.pos + best_match
+
+    def compiled_scan(self,restrict):
+        token = StarScan.scan()
+        print("Calling compiled scan, got %s" % repr(token))
+        if token[2] not in restrict:
+            msg = "Bad Token"
+            if restrict:
+               msg = "Trying to find one of " + ", ".join(restrict)
+            raise YappsSyntaxError(self.pos,msg)
+        self.tokens.append(token)
+        self.restrictions.append(restrict)
+        return
+
+class Parser:
+    """Base class for Yapps-generated parsers.
+
+    """
+
+    def __init__(self, scanner):
+        self._scanner = scanner
+        self._pos = 0
+
+    def _peek(self, *types):
+        """Returns the token type for lookahead; if there are any args
+        then the list of args is the set of token types to allow"""
+        tok = self._scanner.token(self._pos, types)
+        return tok[2]
+
+    def _scan(self, type):
+        """Returns the matched text, and moves to the next token"""
+        tok = self._scanner.token(self._pos, [type])
+        if tok[2] != type:
+            raise YappsSyntaxError(tok[0], 'Trying to find '+type+' :'+ ' ,')
+        self._pos = 1 + self._pos
+        return tok[3]
+
+class Context:
+    """Class to represent the parser's call stack.
+
+    Every rule creates a Context that links to its parent rule.  The
+    contexts can be used for debugging.
+
+    """
+
+    def __init__(self, parent, scanner, tokenpos, rule, args=()):
+        """Create a new context.
+
+        Args:
+        parent: Context object or None
+        scanner: Scanner object
+        pos: integer (scanner token position)
+        rule: string (name of the rule)
+        args: tuple listing parameters to the rule
+
+        """
+        self.parent = parent
+        self.scanner = scanner
+        self.tokenpos = tokenpos
+        self.rule = rule
+        self.args = args
+
+    def __str__(self):
+        output = ''
+        if self.parent: output = str(self.parent) + ' > '
+        output += self.rule
+        return output
+
+#
+#  Note that this sort of error printout is useless with the
+#  compiled scanner
+#
+
+def print_line_with_pointer(text, p):
+    """Print the line of 'text' that includes position 'p',
+    along with a second line with a single caret (^) at position p"""
+
+    # TODO: separate out the logic for determining the line/character
+    # location from the logic for determining how to display an
+    # 80-column line to stderr.
+
+    # Now try printing part of the line
+    text = text[max(p-80, 0):p+80]
+    p = p - max(p-80, 0)
+
+    # Strip to the left
+    i = text[:p].rfind('\n')
+    j = text[:p].rfind('\r')
+    if i < 0 or (0 <= j < i): i = j
+    if 0 <= i < p:
+        p = p - i - 1
+        text = text[i+1:]
+
+    # Strip to the right
+    i = text.find('\n', p)
+    j = text.find('\r', p)
+    if i < 0 or (0 <= j < i): i = j
+    if i >= 0:
+        text = text[:i]
+
+    # Now shorten the text
+    while len(text) > 70 and p > 60:
+        # Cut off 10 chars
+        text = "..." + text[10:]
+        p = p - 7
+
+    # Now print the string, along with an indicator
+    print('> ',text,file=sys.stderr)
+    print('> ',' '*p + '^',file=sys.stderr)
+
+def print_error(input, err, scanner):
+    """Print error messages, the parser stack, and the input text -- for human-readable error messages."""
+    # NOTE: this function assumes 80 columns :-(
+    # Figure out the line number
+    line_number = scanner.get_line_number()
+    column_number = scanner.get_column_number()
+    print('%d:%d: %s' % (line_number, column_number, err.msg),file=sys.stderr)
+
+    context = err.context
+    if not context:
+        print_line_with_pointer(input, err.charpos)
+
+    while context:
+        # TODO: add line number
+        print('while parsing %s%s:' % (context.rule, tuple(context.args)),file=sys.stderr)
+        print_line_with_pointer(input, context.scanner.get_prev_char_pos(context.tokenpos))
+        context = context.parent
+
+def wrap_error_reporter(parser, rule):
+    try:
+        return getattr(parser, rule)()
+    except YappsSyntaxError as e:
+        input = parser._scanner.input
+        print_error(input, e, parser._scanner)
+    except NoMoreTokens:
+        print('Could not complete parsing; stopped around here:',file=sys.stderr)
+        print(parser._scanner,file=sys.stderr)

pyemaps/README.md

@@ -0,0 +1,201 @@
+<!-- #  Open Source __pyEMAPS__ Development Guidelines -->
+
+1. <a id="contents"></a>[What's in pyEMAPS](#overview)
+2. <a id="contents"></a>[Build pyEMAPS](#build)
+3. <a id="contents"></a>[Installation](#installation)
+4. <a id="contents"></a>[Testing](#test)
+5. <a id="contents"></a>[Development Guidelines](#process)
+5. <a id="contents"></a>[pyEMAPS Contributor License Agreement](#CLA)
+5. <a id="contents"></a>[Code of Conduct](#COC)
+
+## What's in pyEMAPS [`↩`](#contents) <a id="overview"></a>
+**pyEMAPS** package is a collection of python modules and libraries designed 
+for transmission electron diffraction simulations and crystallographic calculations 
+for all crystal systems. The simulation is based on the theories of kinematical and 
+dynamical electron diffraction, as described by Spence and Zuo in the book of Electron Microdiffraction (Plenum, New York, 1992).
+
+The base version is free for personal and commercial use, while additional licensed features in 4DSTEM are available for enhanced functionality.
+
+### Features:
+Free base features:
+- Crystallography
+  - Crystal constructor
+  - Loading from a built-in crystal library
+  - CIF import
+  - Crystallographic transformations
+  - Real and reciprocal vector calculations
+  - Stereodiagram plotting
+  - Crystal Structure Factors Calculations
+
+- Electron diffraction pattern, dynamical
+  - Convergent beam electron diffraction
+  - Electron scattering Matrix
+  - Electron dispersion
+
+- Electron diffraction pattern, kinematical
+  - Selected area diffraction
+  - Kikuchi and high order Laue zone line geometry
+  - Convergent beam electron diffraction
+  - Electron powder diffraction simulations
+
+**Extended features** (requires license):
+- Electron diffraction patterns database builder and explore
+- Electron diffraction pattern indexing
+- Annular bright and dark field
+- Masked images 
+
+Check our full [pyemaps documentation](https://emlab-solutions.github.io/pyemaps) for details of __pyEMAPS__ python classes designs and their interfaces.
+
+We are looking for experts in electron microscope and crystallography, and/or python enthusiasts to join pyEMAPS project as contributors, please contact us at support@emlabsoftware.com if you are interested.
+
+We greatly appreciate your contributions to pyEMAPS and look forward to making it a tool for the communty to accelaerate microscopy and crystallography education and research. If you benefit from __pyEMAPS__ in your microscopy and crystallography research and education, go to [PayPal](https://www.paypal.com/paypalme/pyemaps22) to donate. Your generous donations keep us in the business of providing software tools to the education and research communities. 
+
+See instructions below for contributor:
+
+## Build pyEMAPS [`↩`](#content) <a id="build"></a>
+
+Requirements and recommendations:
+* __Python__: Version 3.12, 3.13, 3.14 or 3.15
+* __Operating Systems__: Windows
+* __VSCode__: code editing (recommended, for contributors only)
+
+Building __pyEMAPS__ itself needs no compiler, because it is pure Python. Its compiled backend, __emaps__, supports Windows with Python 3.12 to 3.15, so __pyEMAPS__ does too. pyEMAPS 1.1.x remains available for Python 3.7. We are also looking for contributors to extend it to other platforms. 
+
+Like many python development, a virtual python environment is recommended to isolate your pyEMAPS development environment from your other python development projects.
+
+Below are steps to establish __pyEMAPS__ build environment with python 3.12 as an example:
+
+* Download the Python 3.12 Windows installer (64-bit) from [python.org](https://www.python.org/downloads/windows/).
+* Run the installer, choose the following in installer GUI:
+  
+     * Select Customize Installation
+     * Check and select pip
+     * Install for all users/specific users   
+* Create a virtual environment called "pyemaps_build" for the build
+     * Create a dev directory:
+       ```
+       mkdir pyemaps-dev
+       ``` 
+       (or choose your own directory name)
+     * Create pyemaps_build virtual environemnt:
+       ```
+       py -3.12 -m venv pyemaps_build
+       ```
+* Activate pyemaps_build vitual environment:
+     ```
+    .\pyemaps_build\Scripts\activate
+     ```
+* Update pip:
+  ```
+   python -m pip install pip --upgrade
+  ```
+* Install other python packages required for building pyemaps, using pip:
+  ``` 
+  pip install setuptools wheel build
+  ```
+* Build directory structure:
+
+<pre>
+📦pyemaps
+  ┣━ 📂.git          <----Source repository configurations
+  ┣━ 📂build         <----Intermediate build folder
+  ┣━ 📂dist          <----Build package files
+  ┣━ 📂cdata         <----Built-in crystal data in proprietory format
+  ┣━ 📂CifFile       <----CIF crystal data reader
+  ┣━ 📂diffract      <----Diffraction modules python interfaces
+  ┣━ 📂docs          <----Documentation using Sphinx. Document your changes!
+  ┣━ 📂samples       <----Sample code. Offical sample code for guiding pyemaps usages
+  ┣━ 📂scattering    <----Scattering data module
+  ┣━ 📂spg           <----Space group data module
+  ┗━ 📂test          <----Test cases including sanity, unit and stree tests. Keep adding them!
+</pre>
+where _docs_ for creation of documents requires Sphinx python package:
+- Sphinx for documentation can be installed:
+```
+       pip install Sphinx=5.3.0
+```
+
+* Build pyEMAPS package, run:
+  ```
+   python build_pyemaps -t -v 1.0.0
+  ```
+  Here the option "-t" indicates build is for local testing purposes. 
+  You can replace the version number '1.0.0' with the one you desire.
+
+  When the option _-v_ is not specified. The build script will figure out the version
+  from pypi.org repository.
+
+  Note: there will be two additional diretcories:
+  - _build_.  folder holding intermediate build files.
+  - _dist_. folder for final package that includes .whl and .tgz. The former is the package file and the latter is the current source code used to build the pacage in compressed format. 
+
+## Installation [`↩`](#contents) <a id="installation"></a>
+
+* Install the new pyEMAPS package:
+  ```
+   pip install .\dist\pyemaps-1.0.0-py3-none-any.whl
+  ```
+  This will install new pyEMAPS just built in current python virtual environment
+  along with all of its dependent packages. 
+  
+  If you have a previous _pyemaps_ with versiual or larger than current package version.
+  In that case, you need to uninstall previous version before installing the new package:
+  ```
+  pip uninstall pyemaps
+  ```
+
+## Testing [`↩`](#contents) <a id="test"></a>
+
+  Current pyEMAPS development comes with a set of basic testing suites, including 
+   * sanity checks
+   * unit tests
+   * stress tests.
+
+   To run these test suites, call:
+   ```
+      .\test\sanity\sanity.bat
+   ```
+   We are looking for your tests contributions to make the development to keep high quality standards for _pyEMAPS_.
+
+## Development Guidelines [`↩`](#contents) <a id="process"></a>
+
+As any open source development project, we strongly recommend contributors to adhere to the following guidelines:
+
+* __Issues creation__. Before making changes for bug fix or feature implementation, create an issue in   the pyEMAPS' repository. Your concise description of the issue(s) serves well not only in laying good foundations for your design and implementations, but also in communicating to your fellow contributors.
+
+* __Development Branch__. Create your own branch from 'main' where you work on your changes. The main branch is kept as production base.
+  
+* __Backwards Compatibilities Tests__. Existing test suites designed for testing most of the features are to ensure that no existing implementations are unintentionally broken after new changes are introduced.
+
+* __New Tests Additions__. Writing new test cases for the new implementations are strongly encouraged. 
+  
+* __Pull Requests__. Before merging your changes into production branch "main", a pull request is required. The request should also accompany a list of code reviewers from the contributors. 
+  
+* __Code Review__. We took code review seriously, whether you are reviewing code or your code is being reviewed. This process provides important step of making sound implementations and preventing new bugs.  
+  
+* __Documentation__. You are the author of the new implementations, so please take the pride by documenting them!  
+  We use sphinx tool for documentation generation. To install sphinx, run:
+  ```
+  pip install -U sphinx
+  ```
+  in your python build virtual environment (pyemaps_build in our example).
+
+  Most of the documentations files are in "docs" directory. After making documentation changes to record your changes, compile them with sphinx:
+  ```
+  sphinx-build -b html source .
+  ```
+  The changes resulted from the above can be previewed by opening index.html with avaliable browser.
+  
+## pyEMAPS Contributor License Agreement [`↩`](#contents) <a id="CLA"></a>
+
+Please read and agree to our [Contributor License Agreement](CONTRIBUTING.md) before contributing to this project.
+
+## Code of Conduct [`↩`](#contents) <a id="COC"></a>
+
+pyEMAPS is committed to providing a welcoming and inclusive environment for all contributors. We follow the [Contributor Covenant](https://www.contributor-covenant.org/version/2/0/code_of_conduct/) as our code of conduct. Please make sure to review it before contributing.
+
+**[Read the Contributor Covenant](https://www.contributor-covenant.org/version/2/0/code_of_conduct/)**
+
+Any instances of unacceptable behavior can be reported to support@emlabsoftware.com.
+
+

pyemaps/__config__.py

@@ -0,0 +1,91 @@
+# This file is generated by numpy's setup.py
+# It contains system_info results at the time of building this package.
+__all__ = ["get_info","show"]
+
+
+import os
+import sys
+
+extra_dll_dir = os.path.join(os.path.dirname(__file__), '.libs')
+
+if sys.platform == 'win32' and os.path.isdir(extra_dll_dir):
+    if sys.version_info >= (3, 8):
+        os.add_dll_directory(extra_dll_dir)
+    else:
+        os.environ.setdefault('PATH', '')
+        os.environ['PATH'] += os.pathsep + extra_dll_dir
+
+
+def get_info(name):
+    g = globals()
+    return g.get(name, g.get(name + "_info", {}))
+
+def show():
+    """
+    Show libraries in the system on which NumPy was built.
+
+    Print information about various resources (libraries, library
+    directories, include directories, etc.) in the system on which
+    NumPy was built.
+
+    See Also
+    --------
+    get_include : Returns the directory containing NumPy C
+                  header files.
+
+    Notes
+    -----
+    Classes specifying the information to be printed are defined
+    in the `numpy.distutils.system_info` module.
+
+    Information may include:
+
+    * ``language``: language used to write the libraries (mostly
+      C or f77)
+    * ``libraries``: names of libraries found in the system
+    * ``library_dirs``: directories containing the libraries
+    * ``include_dirs``: directories containing library header files
+    * ``src_dirs``: directories containing library source files
+    * ``define_macros``: preprocessor macros used by
+      ``distutils.setup``
+    * ``baseline``: minimum CPU features required
+    * ``found``: dispatched features supported in the system
+    * ``not found``: dispatched features that are not supported
+      in the system
+
+    Examples
+    --------
+    >>> import numpy as np
+    >>> np.show_config()
+    blas_opt_info:
+        language = c
+        define_macros = [('HAVE_CBLAS', None)]
+        libraries = ['openblas', 'openblas']
+        library_dirs = ['/usr/local/lib']
+    """
+    from numpy.core._multiarray_umath import (
+        __cpu_features__, __cpu_baseline__, __cpu_dispatch__
+    )
+    for name,info_dict in globals().items():
+        if name[0] == "_" or type(info_dict) is not type({}): continue
+        print(name + ":")
+        if not info_dict:
+            print("  NOT AVAILABLE")
+        for k,v in info_dict.items():
+            v = str(v)
+            if k == "sources" and len(v) > 200:
+                v = v[:60] + " ...\n... " + v[-60:]
+            print("    %s = %s" % (k,v))
+
+    features_found, features_not_found = [], []
+    for feature in __cpu_dispatch__:
+        if __cpu_features__[feature]:
+            features_found.append(feature)
+        else:
+            features_not_found.append(feature)
+
+    print("Supported SIMD extensions in this NumPy install:")
+    print("    baseline = %s" % (','.join(__cpu_baseline__)))
+    print("    found = %s" % (','.join(features_found)))
+    print("    not found = %s" % (','.join(features_not_found)))
+