numpy-1.6.1.tar.gz

.. -*- rest -*- ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ F2PY: Fortran to Python interface generator ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ :Author: Pearu Peterson <pearu@cens.ioc.ee> :License: NumPy License :Web-site: http://cens.ioc.ee/projects/f2py2e/ :Discussions to: `f2py-users mailing list`_ :Documentation: `User's Guide`__, FAQ__ :Platforms: All :Date: $Date: 2005/01/30 18:54:53 $ .. _f2py-users mailing list: http://cens.ioc.ee/mailman/listinfo/f2py-users/ __ usersguide/index.html __ FAQ.html ------------------------------- .. topic:: NEWS!!! January 5, 2006 WARNING -- these notes are out of date! The package structure for NumPy and SciPy has changed considerably. Much of this information is now incorrect. January 30, 2005 Latest F2PY release (version 2.45.241_1926). New features: wrapping unsigned integers, support for ``.pyf.src`` template files, callback arguments can now be CObjects, fortran objects, built-in functions. Introduced ``intent(aux)`` attribute. Wrapped objects have ``_cpointer`` attribute holding C pointer to wrapped functions or variables. Many bug fixes and improvements, updated documentation. `Differences with the previous release (version 2.43.239_1831)`__. __ http://cens.ioc.ee/cgi-bin/cvsweb/python/f2py2e/docs/HISTORY.txt.diff?r1=1.163&r2=1.137&f=h October 4, 2004 F2PY bug fix release (version 2.43.239_1831). Better support for 64-bit platforms. Introduced ``--help-link`` and ``--link-<resource>`` options. Bug fixes. `Differences with the previous release (version 2.43.239_1806)`__. __ http://cens.ioc.ee/cgi-bin/cvsweb/python/f2py2e/docs/HISTORY.txt.diff?r1=1.137&r2=1.131&f=h September 25, 2004 Latest F2PY release (version 2.43.239_1806). Support for ``ENTRY`` statement. New attributes: ``intent(inplace)``, ``intent(callback)``. Supports Numarray 1.1. Introduced ``-*- fix -*-`` header content. Improved ``PARAMETER`` support. Documentation updates. `Differences with the previous release (version 2.39.235-1693)`__. __ http://cens.ioc.ee/cgi-bin/cvsweb/python/f2py2e/docs/HISTORY.txt.diff?r1=1.131&r2=1.98&f=h `History of NEWS`__ __ OLDNEWS.html ------------------------------- .. Contents:: ============== Introduction ============== The purpose of the F2PY --*Fortran to Python interface generator*-- project is to provide connection between Python_ and Fortran languages. F2PY is a Python extension tool for creating Python C/API modules from (handwritten or F2PY generated) signature files (or directly from Fortran sources). The generated extension modules facilitate: * Calling Fortran 77/90/95, Fortran 90/95 module, and C functions from Python. * Accessing Fortran 77 ``COMMON`` blocks and Fortran 90/95 module data (including allocatable arrays) from Python. * Calling Python functions from Fortran or C (call-backs). * Automatically handling the difference in the data storage order of multi-dimensional Fortran and Numerical Python (i.e. C) arrays. In addition, F2PY can build the generated extension modules to shared libraries with one command. F2PY uses the ``numpy_distutils`` module from SciPy_ that supports number of major Fortran compilers. .. (see `COMPILERS.txt`_ for more information). F2PY generated extension modules depend on NumPy_ package that provides fast multi-dimensional array language facility to Python. --------------- Main features --------------- Here follows a more detailed list of F2PY features: * F2PY scans real Fortran codes to produce the so-called signature files (.pyf files). The signature files contain all the information (function names, arguments and their types, etc.) that is needed to construct Python bindings to Fortran (or C) functions. The syntax of signature files is borrowed from the Fortran 90/95 language specification and has some F2PY specific extensions. The signature files can be modified to dictate how Fortran (or C) programs are called from Python: + F2PY solves dependencies between arguments (this is relevant for the order of initializing variables in extension modules). + Arguments can be specified to be optional or hidden that simplifies calling Fortran programs from Python considerably. + In principle, one can design any Python signature for a given Fortran function, e.g. change the order arguments, introduce auxiliary arguments, hide the arguments, process the arguments before passing to Fortran, return arguments as output of F2PY generated functions, etc. * F2PY automatically generates __doc__ strings (and optionally LaTeX documentation) for extension modules. * F2PY generated functions accept arbitrary (but sensible) Python objects as arguments. The F2PY interface automatically takes care of type-casting and handling of non-contiguous arrays. * The following Fortran constructs are recognized by F2PY: + All basic Fortran types:: integer[ | *1 | *2 | *4 | *8 ], logical[ | *1 | *2 | *4 | *8 ] integer*([ -1 | -2 | -4 | -8 ]) character[ | *(*) | *1 | *2 | *3 | ... ] real[ | *4 | *8 | *16 ], double precision complex[ | *8 | *16 | *32 ] Negative ``integer`` kinds are used to wrap unsigned integers. + Multi-dimensional arrays of all basic types with the following dimension specifications:: <dim> | <start>:<end> | * | : + Attributes and statements:: intent([ in | inout | out | hide | in,out | inout,out | c | copy | cache | callback | inplace | aux ]) dimension(<dimspec>) common, parameter allocatable optional, required, external depend([<names>]) check([<C-booleanexpr>]) note(<LaTeX text>) usercode, callstatement, callprotoargument, threadsafe, fortranname pymethoddef entry * Because there are only little (and easily handleable) differences between calling C and Fortran functions from F2PY generated extension modules, then F2PY is also well suited for wrapping C libraries to Python. * Practice has shown that F2PY generated interfaces (to C or Fortran functions) are less error prone and even more efficient than handwritten extension modules. The F2PY generated interfaces are easy to maintain and any future optimization of F2PY generated interfaces transparently apply to extension modules by just regenerating them with the latest version of F2PY. * `F2PY Users Guide and Reference Manual`_ =============== Prerequisites =============== F2PY requires the following software installed: * Python_ (versions 1.5.2 or later; 2.1 and up are recommended). You must have python-dev package installed. * NumPy_ (versions 13 or later; 20.x, 21.x, 22.x, 23.x are recommended) * Numarray_ (version 0.9 and up), optional, partial support. * Scipy_distutils (version 0.2.2 and up are recommended) from SciPy_ project. Get it from Scipy CVS or download it below. Python 1.x users also need distutils_. Of course, to build extension modules, you'll need also working C and/or Fortran compilers installed. ========== Download ========== You can download the sources for the latest F2PY and numpy_distutils releases as: * `2.x`__/`F2PY-2-latest.tar.gz`__ * `2.x`__/`numpy_distutils-latest.tar.gz`__ Windows users might be interested in Win32 installer for F2PY and Scipy_distutils (these installers are built using Python 2.3): * `2.x`__/`F2PY-2-latest.win32.exe`__ * `2.x`__/`numpy_distutils-latest.win32.exe`__ Older releases are also available in the directories `rel-0.x`__, `rel-1.x`__, `rel-2.x`__, `rel-3.x`__, `rel-4.x`__, `rel-5.x`__, if you need them. .. __: 2.x/ .. __: 2.x/F2PY-2-latest.tar.gz .. __: 2.x/ .. __: 2.x/numpy_distutils-latest.tar.gz .. __: 2.x/ .. __: 2.x/F2PY-2-latest.win32.exe .. __: 2.x/ .. __: 2.x/numpy_distutils-latest.win32.exe .. __: rel-0.x .. __: rel-1.x .. __: rel-2.x .. __: rel-3.x .. __: rel