Try   HackMD

Collected material

tags: planning

Python API generators

f2py

Python wrapper generator that is part of NumPy

Main limitations:

  • Doesn't support derived types

f90wrap

Fortran to Python interface generator that extends f2yp with derived type support.

fmodpy

"An easy-to-use Fortran wrapper for Python." Still in development.

gfort2py

Library to allow calling fortran code from python.

  • Only works with gfortran

F2x

"A versatile, template-based Fortran wrapper written in Python."

  • Lacks documentation

Forthon

"Forthon generates links between Fortran95 and Python."

  • Lacks documentation

SWIG-Fortran

  • Fairly well supported but is still an unfriendly fork with no path to being merged upstream

Various packages that don't seem to be maintained

fwrap

C interfaces from Python

ctypes

Foreign function library in the Python standard library.

cffi

Python wrapper generator for C

Cython

Compiler for Python C-extensions. Can load shared libaries.

Making your C library callable from Python by wrapping it with Cython

numpy.ctypeslib

Module to facilitate working with NumPy arrays in C interfaces

numpy.ctypeslib.as_ctypes
Converting array to C array

numpy.ctypeslib.as_array
Convert C array to NumPy array

numpy.ctypeslib.load_library
Alternative to ctypes.cdll that takes care of platform-specific things

numpy.ndarray.ctypes

An object to simplify the interaction of NumPy arrays with the ctypes module

x.ctypes.data
Attribute to access data as C array

SWIG

Python wrapper generator for C

Tools for patching Python wheels with dynamic libraries

  • Building Python packages with shared libraries means that the library needs to be present at runtime for the end user.
  • Tools are available to patch the binary wheels to include these shared libraries.
  • Support for Windows is currently lacking.

delocate

Well-established tool for MacOs

auditwheel

Well-established tool for Linux

delvewheel

Preliminary tool for Windows

Available guides

Calling Fortran from Python
Fortran90.org: Interfacing with Python
Fortran Wiki: Generating C Interfaces
Fortran Wiki: Python
Foreign Fortran
Python-Fortran bindings examples
Interfacing Fortran code
Using fortran from python
High-Performance Python – Compiled Code and Fortran Interface
Combining Python with Fortran, C and C++
Writing fast Fortran routines for Python
Interfacing With Other Programming Languages Using Cython

Slides

Interfacing Python with Fortran
Slides from INF3331 lectures – combining Python with Fortran/C/C++

Running Python from Fortran

forcallpy
forpy
call_py_fort

Last changed by 
 
Python-Fortran interface minibook
Space to work on Python-Fortran interface minibook for Fortran-lang.org
0
314

Read more

Importing a shared library

ctypes The ctypes library is part of the Python standard libary and provides convenient access to C compatible data types and loading of shared libraries. C datatypes like c_int, c_double, c_long etc. are supported and libraries are loaded with CDLL. A simple example on the use of ctypes was given in the Introduction. Working with NumPy arrays The most convenient way to work with arrays is through numpy.ctypeslib. In particular, it includes the functions as_array, which converts a C array to a NumPy ndarray, and as_ctypes, which converts an ndarray to a C array. Here is an example passing a NumPy array to a Fortran subroutine that sums the column values: from ctypes import CDLL, byref, c_int import numpy as np

May 29, 2021
Building and distributing

Some introduction The end goal is to be able to make our code installable with package managers such as conda or pip without the end user having to worry about compiling code, setting up paths for shared libraries etc. f2py Packaging Fortran code with f2py is embarrasingly easy thanks to numpy.distutils. We can tell setuptools to build Fortran source files by using the numpy.distutils drop-in replacements for the regular Extension and setup. Let's start with our function that does addition. ! file: add.f90

May 29, 2021
Introduction

Authors: Kjell Jorner, ... In recent years, Python has taken over as the most commonly used language in applied science. Although Python itself as a scripting language is quite slow, it often serves as a glue between computationally demanding procedures written in compiled languages such as Fortran or C. Prime examples of this approch are the NumPy and SciPy packages that power applications such as machine learning via scikit-learn and quantum chemistry via PySCF. There are a number of reasons why you would want to interface Python and Fortran, such as: Making your Fortran application available within the Python eco-system Speeding up slow parts of a Python code

May 29, 2021
Writing a Fortran-C interface

The reason why Fortran can be called from Python is the C interoperability features that were added with Fortran 2003 and expanded later. By writing our code to be interoperable with C, we can call procedures, module variables and derived types from C code. Many other programming languages, such as Python, then gain access to our Fortran code, as they are able to call C code. C interoperable code The two most important parts of making your Fortran code C interoperable are: Using the bind(c) attribute Using C interoperable types bind(c) is built in, while the C interoperable types are available through the intrinsic module iso_c_binding that needs to be imported. We have seen one basic example of this in the Introduction:

May 29, 2021
Read more from Python-Fortran interface minibook
Published on HackMD