In [1]:
%load_ext f2pymagic
In [2]:
import numpy as np
In [3]:
%%f2py -f
      SUBROUTINE FOO(A,B)
      REAL*8 A, B
Cf2py intent(in) a
Cf2py intent(inout) b
      PRINT*, "    A=",A," B=",B
      PRINT*, "INCREMENT A AND B"
      A = A + 1D0
      B = B + 1D0
      PRINT*, "NEW A=",A," B=",B
      END
Compilation went OK...
foo is ready for use
In [4]:
print(foo.__doc__)
foo(a,b)

Wrapper for ``foo``.

Parameters
----------
a : input float
b : in/output rank-0 array(float,'d')


In [5]:
a=np.array(2)   # these are integer rank-0 arrays
b=np.array(3)
print(a,b)
foo(a,b)
print(a, b)
(array(2), array(3))
(array(2), array(4))

In [6]:
%%f2py
      SUBROUTINE FIB(A,N)
C
C     CALCULATE FIRST N FIBONACCI NUMBERS
C
      INTEGER N
      REAL*8 A(N)
Cf2py intent(in) n
Cf2py intent(out) a
Cf2py depend(n) a
      DO I=1,N
         IF (I.EQ.1) THEN
            A(I) = 0.0D0
         ELSEIF (I.EQ.2) THEN
            A(I) = 1.0D0
         ELSE
            A(I) = A(I-1) + A(I-2)
         ENDIF
      ENDDO
      END
Compilation went OK...
fib is ready for use
In [7]:
print(fib.__doc__)
a = fib(n)

Wrapper for ``fib``.

Parameters
----------
n : input int

Returns
-------
a : rank-1 array('d') with bounds (n)


In [8]:
a = fib(10)
print(a)
[  0.   1.   1.   2.   3.   5.   8.  13.  21.  34.]

In [9]:
%%f2py
real function r(m,t)
    integer m
    real t
    
    r = 0.1 * t * (m ** 2 + 14 * m + 46)
    if (r .LT. 0) r =0.0
    return
end
Compilation went OK...
r is ready for use
In [10]:
r(1, 10.0)
Out[10]:
61.0
In [11]:
%%f2py
subroutine dbl(x)
    real, intent(inout) :: x
    x = 2.0e0 * x
end subroutine
Compilation went OK...
dbl is ready for use
In [12]:
myvar=np.array((10.0,))
dbl(myvar)
print(myvar)
[ 20.]

In [13]:
%%f2py
module laplace
    implicit none
    contains
    subroutine for_update1(u, dx2, dy2, nx, ny)
        real(8), intent(inout) :: u(nx,ny)
        real(8), intent(in) :: dx2, dy2
        integer, intent(in) :: nx, ny
        integer :: i, j
        do j = 2, ny-1
            do i = 2, nx-1
                u(i, j) = ((u(i+1, j) + u(i-1, j)) * dy2 + &
                   (u(i, j+1) + u(i, j-1)) * dx2) / (2*(dx2+dy2))
            end do
        end do
    end subroutine

    subroutine for_update2(u, dx2, dy2, nx, ny)
        real(8), intent(inout) :: u(nx,ny)
        real(8), intent(in) :: dx2, dy2
        integer, intent(in) :: nx, ny
        u(2:nx-1,2:ny-1) = ((u(3:,2:ny-1)+u(:ny-2,2:ny-1))*dy2 + &
                (u(2:nx-1,3:) + u(2:nx-1,:ny-2))*dx2) / (2*(dx2+dy2))
    end subroutine
        
end module laplace
Compilation went OK...
laplace is ready for use
In [14]:
print(laplace.__doc__)
for_update1(u,dx2,dy2,[nx,ny])

Wrapper for ``for_update1``.

Parameters
----------
u : in/output rank-2 array('d') with bounds (nx,ny)
dx2 : input float
dy2 : input float

Other Parameters
----------------
nx : input int, optional
    Default: shape(u,0)
ny : input int, optional
    Default: shape(u,1)
for_update2(u,dx2,dy2,[nx,ny])

Wrapper for ``for_update2``.

Parameters
----------
u : in/output rank-2 array('d') with bounds (nx,ny)
dx2 : input float
dy2 : input float

Other Parameters
----------------
nx : input int, optional
    Default: shape(u,0)
ny : input int, optional
    Default: shape(u,1)


In [ ]: