meta:

  • name: keywords content: 在Python中使用F2PY构建 NumPy
  • name: description content: Fortran / C例程，公共块或F2PY生成的Fortran 90模块数据的所有包装器都作为fortran 类型对象公开给Python。

在Python中使用F2PY构建

Fortran / C例程，公共块或F2PY生成的Fortran 90模块数据的所有包装器都作为fortran 类型对象公开给Python 。 例程包装器是可调用fortran类型对象，而Fortran数据包装器具有引用数据对象的属性。

所有fortran类型对象都具有_cpointer包含CObject的属性，该CObject引用相应Fortran / C函数的C指针或C级别的变量。当这些函数的计算部分在C或Fortran中实现并用F2PY（或任何其他工具）包装时，这些CObject可以用作F2PY生成函数的回调参数，以绕过从Fortran或C调用Python函数的Python C / API层。能够提供功能的CObject）。

考虑一个Fortran 77文件ftype.f：

  1. C FILE: FTYPE.F
  2.       SUBROUTINE FOO(N)
  3.       INTEGER N
  4. Cf2py integer optional,intent(in) :: n = 13
  5.       REAL A,X
  6.       COMMON /DATA/ A,X(3)
  7.       PRINT*, "IN FOO: N=",N," A=",A," X=[",X(1),X(2),X(3),"]"
  8.       END
  9. C END OF FTYPE.F

并使用。构建一个包装器。f2py -c ftype.f -m ftype

在Python中：

  1. >>> import ftype
  2. >>> print ftype.__doc__
  3. This module 'ftype' is auto-generated with f2py (version:2.28.198-1366).
  4. Functions:
  5.   foo(n=13)
  6. COMMON blocks:
  7.   /data/ a,x(3)
  8. .
  9. >>> type(ftype.foo),type(ftype.data)
  10. (<type 'fortran'>, <type 'fortran'>)
  11. >>> ftype.foo()
  12.  IN FOO: N= 13 A=  0. X=[  0.  0.  0.]
  13. >>> ftype.data.a = 3
  14. >>> ftype.data.x = [1,2,3]
  15. >>> ftype.foo()
  16.  IN FOO: N= 13 A=  3. X=[  1.  2.  3.]
  17. >>> ftype.data.x[1] = 45  
  18. >>> ftype.foo(24)
  19.  IN FOO: N= 24 A=  3. X=[  1.  45.  3.]
  20. >>> ftype.data.x
  21. array([  1.,  45.,   3.],'f')

标量参数

通常，F2PY生成的包装函数的标量参数可以是普通的Python标量（整数，浮点数，复数）以及标量的任意序列对象（列表，元组，数组，字符串）。在后一种情况下，序列对象的第一个元素作为标量参数传递给Fortran例程。

请注意，当需要进行类型转换并且可能丢失信息时（例如，当将类型转换浮动为整数或复数转换为浮动时），F2PY不会引发任何异常。在复杂到真实的类型转换中，仅使用复数的实部。

intent(inout)标量参数被假定为数组对象，以便 原位 更改生效。建议使用具有适当类型的数组，但也可以使用其他类型的数组。

考虑以下Fortran 77代码：

  1. C FILE: SCALAR.F
  2.       SUBROUTINE FOO(A,B)
  3.       REAL*8 A, B
  4. Cf2py intent(in) a
  5. Cf2py intent(inout) b
  6.       PRINT*, "    A=",A," B=",B
  7.       PRINT*, "INCREMENT A AND B"
  8.       A = A + 1D0
  9.       B = B + 1D0
  10.       PRINT*, "NEW A=",A," B=",B
  11.       END
  12. C END OF FILE SCALAR.F

并使用它包装。f2py -c -m scalar scalar.f

在Python中：

  1. >>> import scalar
  2. >>> print scalar.foo.__doc__
  3. foo - Function signature:
  4.   foo(a,b)
  5. Required arguments:
  6.   a : input float
  7.   b : in/output rank-0 array(float,'d')
  9. >>> scalar.foo(2,3)   
  10.      A=  2. B=  3.
  11.  INCREMENT A AND B
  12.  NEW A=  3. B=  4.
  13. >>> import numpy
  14. >>> a=numpy.array(2)   # these are integer rank-0 arrays
  15. >>> b=numpy.array(3)
  16. >>> scalar.foo(a,b)
  17.      A=  2. B=  3.
  18.  INCREMENT A AND B
  19.  NEW A=  3. B=  4.
  20. >>> print a,b            # note that only b is changed in situ
  21. 2 4

字符串参数

F2PY生成的包装函数接受（几乎）任何Python对象作为字符串参数，str应用于非字符串对象。例外是NumPy数组必须具有类型代码'c'或 '1'用作字符串参数。

当将字符串用作F2PY生成的包装函数的字符串参数时，字符串可以具有任意长度。如果长度大于预期，则字符串将被截断。如果长度小于预期，则分配并填充额外的内存\0。

因为Python字符串是不可变的，所以intent(inout)参数需要字符串的数组版本才能使 原位 更改生效。

考虑以下Fortran 77代码：

  1. C FILE: STRING.F
  2.       SUBROUTINE FOO(A,B,C,D)
  3.       CHARACTER*5 A, B
  4.       CHARACTER*(*) C,D
  5. Cf2py intent(in) a,c
  6. Cf2py intent(inout) b,d
  7.       PRINT*, "A=",A
  8.       PRINT*, "B=",B
  9.       PRINT*, "C=",C
  10.       PRINT*, "D=",D
  11.       PRINT*, "CHANGE A,B,C,D"
  12.       A(1:1) = 'A'
  13.       B(1:1) = 'B'
  14.       C(1:1) = 'C'
  15.       D(1:1) = 'D'
  16.       PRINT*, "A=",A
  17.       PRINT*, "B=",B
  18.       PRINT*, "C=",C
  19.       PRINT*, "D=",D
  20.       END
  21. C END OF FILE STRING.F

并使用它包装。f2py -c -m mystring string.f

Python会话：

  1. >>> import mystring
  2. >>> print mystring.foo.__doc__
  3. foo - Function signature:
  4.   foo(a,b,c,d)
  5. Required arguments:
  6.   a : input string(len=5)
  7.   b : in/output rank-0 array(string(len=5),'c')
  8.   c : input string(len=-1)
  9.   d : in/output rank-0 array(string(len=-1),'c')
  11. >>> import numpy
  12. >>> a=numpy.array('123')
  13. >>> b=numpy.array('123')
  14. >>> c=numpy.array('123')
  15. >>> d=numpy.array('123')
  16. >>> mystring.foo(a,b,c,d)
  17.  A=123
  18.  B=123
  19.  C=123
  20.  D=123
  21.  CHANGE A,B,C,D
  22.  A=A23
  23.  B=B23
  24.  C=C23
  25.  D=D23
  26. >>> a.tostring(),b.tostring(),c.tostring(),d.tostring()
  27. ('123', 'B23', '123', 'D23')

数组参数

通常，F2PY生成的包装函数的数组参数接受可以转换为NumPy数组对象的任意序列。一个例外是intent(inout)数组参数，它们必须始终是正确连续的并且具有正确的类型，否则会引发异常。另一个例外是intent(inplace)数组参数，如果参数的类型与预期不同，则属性将在原位更改（intent(inplace)有关更多信息，请参阅属性）。

通常，如果NumPy数组是正确连续的并且具有适当的类型，那么它将直接传递给包装的Fortran / C函数。否则，将生成输入数组的元素副本，并将正确连续且具有适当类型的副本用作数组参数。

有两种类型的适当连续的NumPy数组：

  • 当数据按列存储时，Fortran连续数组，即存储在存储器中的数据索引从最低维开始;
  • 当数据以行方式存储时，C-连续或简单连续的数组，即存储在存储器中的数据的索引从最高维度开始。

对于一维数组，这些概念重合。

例如，如果2x2数组A的元素按以下顺序存储在内存中，则它是Fortran连续的：

  1. A[0,0] A[1,0] A[0,1] A[1,1]

如果订单如下，则为C-contiguous：

  1. A[0,0] A[0,1] A[1,0] A[1,1]

要测试数组是否为C-contiguous，请使用.iscontiguous() NumPy数组的方法。为了测试Fortran连续性，所有F2PY生成的扩展模块都提供了一个功能 has_column_major_storage()。此功能相当于 .flags.f_contiguous但效率更高。

通常不需要担心数组如何存储在内存中以及包装函数（Fortran函数还是C函数）是否采用一个或另一个存储顺序。F2PY自动确保包装函数以适当的存储顺序获取参数; 相应的算法被设计为仅在绝对必要时才复制数组。但是，当处理大小接近计算机中物理内存大小的非常大的多维输入数组时，必须注意始终使用适当连续且正确的类型参数。

要在将输入数组传递给Fortran例程之前将其转换为列主存储顺序，请使用as_column_major_storage()由所有F2PY生成的扩展模块提供的函数 。

考虑Fortran 77代码：

  1. C FILE: ARRAY.F
  2.       SUBROUTINE FOO(A,N,M)
  3. C
  4. C     INCREMENT THE FIRST ROW AND DECREMENT THE FIRST COLUMN OF A
  5. C
  6.       INTEGER N,M,I,J
  7.       REAL*8 A(N,M)
  8. Cf2py intent(in,out,copy) a
  9. Cf2py integer intent(hide),depend(a) :: n=shape(a,0), m=shape(a,1)
  10.       DO J=1,M
  11.          A(1,J) = A(1,J) + 1D0
  12.       ENDDO
  13.       DO I=1,N
  14.          A(I,1) = A(I,1) - 1D0
  15.       ENDDO
  16.       END
  17. C END OF FILE ARRAY.F

并使用它包装。f2py -c -m arr array.f -DF2PY_REPORT_ON_ARRAY_COPY=1

在Python中：

  1. >>> import arr
  2. >>> from numpy import array
  3. >>> print arr.foo.__doc__
  4. foo - Function signature:
  5.   a = foo(a,[overwrite_a])
  6. Required arguments:
  7.   a : input rank-2 array('d') with bounds (n,m)
  8. Optional arguments:
  9.   overwrite_a := 0 input int
  10. Return objects:
  11.   a : rank-2 array('d') with bounds (n,m)
  13. >>> a=arr.foo([[1,2,3],
  14. ...            [4,5,6]])
  15. copied an array using PyArray_CopyFromObject: size=6, elsize=8
  16. >>> print a
  17. [[ 1.  3.  4.]
  18.  [ 3.  5.  6.]]
  19. >>> a.iscontiguous(), arr.has_column_major_storage(a)
  20. (0, 1)
  21. >>> b=arr.foo(a)              # even if a is proper-contiguous
  22. ...                           # and has proper type, a copy is made
  23. ...                           # forced by intent(copy) attribute
  24. ...                           # to preserve its original contents
  25. ... 
  26. copied an array using copy_ND_array: size=6, elsize=8
  27. >>> print a
  28. [[ 1.  3.  4.]
  29.  [ 3.  5.  6.]]
  30. >>> print b
  31. [[ 1.  4.  5.]
  32.  [ 2.  5.  6.]]
  33. >>> b=arr.foo(a,overwrite_a=1) # a is passed directly to Fortran
  34. ...                            # routine and its contents is discarded
  35. ... 
  36. >>> print a
  37. [[ 1.  4.  5.]
  38.  [ 2.  5.  6.]]
  39. >>> print b
  40. [[ 1.  4.  5.]
  41.  [ 2.  5.  6.]]
  42. >>> a is b                       # a and b are actually the same objects
  43. 1
  44. >>> print arr.foo([1,2,3])       # different rank arrays are allowed
  45. copied an array using PyArray_CopyFromObject: size=3, elsize=8
  46. [ 1.  1.  2.]
  47. >>> print arr.foo([[[1],[2],[3]]])
  48. copied an array using PyArray_CopyFromObject: size=3, elsize=8
  49. [ [[ 1.]
  50.   [ 3.]
  51.   [ 4.]]]
  52. >>>
  53. >>> # Creating arrays with column major data storage order:
  54. ...
  55. >>> s = arr.as_column_major_storage(array([[1,2,3],[4,5,6]]))
  56. copied an array using copy_ND_array: size=6, elsize=4
  57. >>> arr.has_column_major_storage(s)
  58. 1
  59. >>> print s
  60. [[1 2 3]
  61.  [4 5 6]]
  62. >>> s2 = arr.as_column_major_storage(s)
  63. >>> s2 is s    # an array with column major storage order 
  64.                # is returned immediately
  65. 1

回调参数

F2PY支持从Fortran或C代码调用Python函数。

考虑以下Fortran 77代码：

  1. C FILE: CALLBACK.F
  2.       SUBROUTINE FOO(FUN,R)
  3.       EXTERNAL FUN
  4.       INTEGER I
  5.       REAL*8 R
  6. Cf2py intent(out) r
  7.       R = 0D0
  8.       DO I=-5,5
  9.          R = R + FUN(I)
  10.       ENDDO
  11.       END
  12. C END OF FILE CALLBACK.F

并使用它包装。f2py -c -m callback callback.f

在Python中：

  1. >>> import callback
  2. >>> print callback.foo.__doc__
  3. foo - Function signature:
  4.   r = foo(fun,[fun_extra_args])
  5. Required arguments:
  6.   fun : call-back function
  7. Optional arguments:
  8.   fun_extra_args := () input tuple
  9. Return objects:
  10.   r : float
  11. Call-back functions:
  12.   def fun(i): return r
  13.   Required arguments:
  14.     i : input int
  15.   Return objects:
  16.     r : float
  18. >>> def f(i): return i*i
  19. ... 
  20. >>> print callback.foo(f)     
  21. 110.0
  22. >>> print callback.foo(lambda i:1)
  23. 11.0

在上面的示例中，F2PY能够准确地猜测回叫函数的签名。但是，有时F2PY无法按照人们的意愿建立签名，然后必须手动修改签名文件中的回调函数的签名。即，签名文件可以包含特殊模块（这些模块的名称包含子串__user__），其收集回调函数的各种签名。例程签名中的回调参数具有属性external（另请参见intent(callback)属性）。要在__user__模块块中关联回调参数及其签名，请使用use如下所示的语句。回调参数的相同签名可以在不同的例程签名中引用。

我们使用与前面示例相同的Fortran 77代码，但现在我们假装F2PY无法正确猜测回调参数的签名。首先，我们callback2.pyf使用F2PY 创建一个初始签名文件：

  1. f2py -m callback2 -h callback2.pyf callback.f

然后按如下方式修改它

  1. !    -*- f90 -*-
  2. python module __user__routines 
  3.     interface
  4.         function fun(i) result (r)
  5.             integer :: i
  6.             real*8 :: r
  7.         end function fun
  8.     end interface
  9. end python module __user__routines
  11. python module callback2
  12.     interface
  13.         subroutine foo(f,r)
  14.             use __user__routines, f=>fun
  15.             external f
  16.             real*8 intent(out) :: r
  17.         end subroutine foo
  18.     end interface 
  19. end python module callback2

最后，使用构建扩展模块。f2py -c callback2.pyf callback.f

示例Python会话与前面的示例相同，只是参数名称会有所不同。

有时，Fortran程序包可能要求用户提供程序包将使用的例程。F2PY可以构造这种例程的接口，以便可以从Fortran调用Python函数。

考虑以下Fortran 77子例程，它接受一个数组并将一个函数func应用于其元素。

  1. subroutine calculate(x,n)
  2. cf2py intent(callback) func
  3.       external func
  4. c     The following lines define the signature of func for F2PY:
  5. cf2py real*8 y
  6. cf2py y = func(y)
  7. c
  8. cf2py intent(in,out,copy) x
  9.       integer n,i
  10.       real*8 x(n)
  11.       do i=1,n
  12.          x(i) = func(x(i))
  13.       end do
  14.       end

预计功能func已在外部定义。为了使用Python函数func，它必须具有一个属性intent(callback)（必须在external语句之前指定）。

最后，使用构建扩展模块 f2py -c -m foo calculate.f

在Python中：

  1. >>> import foo
  2. >>> foo.calculate(range(5), lambda x: x*x)
  3. array([  0.,   1.,   4.,   9.,  16.])
  4. >>> import math
  5. >>> foo.calculate(range(5), math.exp)
  6. array([  1.        ,   2.71828175,   7.38905621,  20.08553696,  54.59814835])

该函数作为参数包含在对Fortran子例程的python函数调用中，即使它 不在 Fortran子例程参数列表中。“外部”是指由f2py生成的C函数，而不是python函数本身。必须将python函数提供给C函数。

回调函数也可以在模块中明确设置。然后，没有必要将参数列表中的函数传递给Fortran函数。如果调用python回调函数的Fortran函数本身由另一个Fortran函数调用，则可能需要这样做。

考虑以下Fortran 77子例程：

  1. subroutine f1()
  2.          print *, "in f1, calling f2 twice.."
  3.          call f2()
  4.          call f2()
  5.          return
  6.       end
  8.       subroutine f2()
  9. cf2py    intent(callback, hide) fpy
  10.          external fpy
  11.          print *, "in f2, calling f2py.."
  12.          call fpy()
  13.          return
  14.       end

并使用它包装。f2py -c -m pfromf extcallback.f

在Python中：

  1. >>> import pfromf
  2. >>> pfromf.f2()
  3. Traceback (most recent call last):
  4.   File "<stdin>", line 1, in ?
  5. pfromf.error: Callback fpy not defined (as an argument or module pfromf attribute).
  7. >>> def f(): print "python f"
  8. ... 
  9. >>> pfromf.fpy = f
  10. >>> pfromf.f2()
  11.  in f2, calling f2py..
  12. python f
  13. >>> pfromf.f1()
  14.  in f1, calling f2 twice..
  15.  in f2, calling f2py..
  16. python f
  17.  in f2, calling f2py..
  18. python f
  19. >>>

解决回调函数的参数

F2PY生成的接口在回调参数方面非常灵活。对于每个回调参数_extra_args，F2PY引入了另一个可选参数。此参数可用于将额外参数传递给用户提供的回调参数。

如果F2PY生成的包装函数需要以下回调参数：

  1. def fun(a_1,...,a_n):
  2.    ...
  3.    return x_1,...,x_k

但是以下Python函数

  1. def gun(b_1,...,b_m):
  2.    ...
  3.    return y_1,...,y_l

由用户提供，此外，

  1. fun_extra_args = (e_1,...,e_p)

如果使用Fortran或C函数调用回调参数，则应用以下规则gun：

  • 如果那时被调用，这里 。p == 0gun(a_1, …, a_q)q = min(m, n)
  • 如果那时被召唤。n + p <= mgun(a_1, …, a_n, e_1, …, e_p)``
  • 如果那时被调用，这里 。p <= m < n + pgun(a_1, …, a_q, e_1, …, e_p)q=m-p
  • 如果那时被召唤。p > mgun(e_1, …, e_m)``
  • 如果小于所需参数的数量， 则引发异常。n + pgun``

该函数gun可以将任意数量的对象作为元组返回。然后应用以下规则：

  • 如果，则忽略。k < ly_{k + 1}, …, y_l``
  • 如果，那么只设置。k > lx_1, …, x_l``

常用块

F2PY common为例程签名块中定义的块生成包装器。所有与当前扩展模块链接的Fortran代码都可以看到公共块，但不能看到其他扩展模块（这种限制是由于Python导入共享库的原因）。在Python中，common块的F2PY包装器fortran是具有与公共块的数据成员相关的（动态）属性的类型对象。访问时，这些属性作为NumPy数组对象（多维数组是Fortran连续）返回，这些对象直接链接到公共块中的数据成员。可以通过直接赋值或通过对相应数组对象的就地更改来更改数据成员。

考虑以下Fortran 77代码：

  1. C FILE: COMMON.F
  2.       SUBROUTINE FOO
  3.       INTEGER I,X
  4.       REAL A
  5.       COMMON /DATA/ I,X(4),A(2,3)
  6.       PRINT*, "I=",I
  7.       PRINT*, "X=[",X,"]"
  8.       PRINT*, "A=["
  9.       PRINT*, "[",A(1,1),",",A(1,2),",",A(1,3),"]"
  10.       PRINT*, "[",A(2,1),",",A(2,2),",",A(2,3),"]"
  11.       PRINT*, "]"
  12.       END
  13. C END OF COMMON.F

并使用它包装。f2py -c -m common common.f

在Python中：

  1. >>> import common
  2. >>> print common.data.__doc__
  3. i - 'i'-scalar
  4. x - 'i'-array(4)
  5. a - 'f'-array(2,3)
  7. >>> common.data.i = 5
  8. >>> common.data.x[1] = 2 
  9. >>> common.data.a = [[1,2,3],[4,5,6]]
  10. >>> common.foo()
  11.  I= 5
  12.  X=[ 0 2 0 0]
  13.  A=[
  14.  [  1.,  2.,  3.]
  15.  [  4.,  5.,  6.]
  16.  ]
  17. >>> common.data.a[1] = 45
  18. >>> common.foo()
  19.  I= 5
  20.  X=[ 0 2 0 0]
  21.  A=[
  22.  [  1.,  2.,  3.]
  23.  [  45.,  45.,  45.]
  24.  ]
  25. >>> common.data.a                 # a is Fortran-contiguous
  26. array([[  1.,   2.,   3.],
  27.        [ 45.,  45.,  45.]],'f')

Fortran 90模块数据

Fortran 90模块数据的F2PY接口类似于Fortran 77公共块。

考虑以下Fortran 90代码：

  1. module mod
  2.   integer i
  3.   integer :: x(4)
  4.   real, dimension(2,3) :: a
  5.   real, allocatable, dimension(:,:) :: b 
  6. contains
  7.   subroutine foo
  8.     integer k
  9.     print*, "i=",i
  10.     print*, "x=[",x,"]"
  11.     print*, "a=["
  12.     print*, "[",a(1,1),",",a(1,2),",",a(1,3),"]"
  13.     print*, "[",a(2,1),",",a(2,2),",",a(2,3),"]"
  14.     print*, "]"
  15.     print*, "Setting a(1,2)=a(1,2)+3"
  16.     a(1,2) = a(1,2)+3
  17.   end subroutine foo
  18. end module mod

并使用它包装。f2py -c -m moddata moddata.f90

在Python中：

  1. >>> import moddata
  2. >>> print moddata.mod.__doc__
  3. i - 'i'-scalar
  4. x - 'i'-array(4)
  5. a - 'f'-array(2,3)
  6. foo - Function signature:
  7.   foo()
  10. >>> moddata.mod.i = 5  
  11. >>> moddata.mod.x[:2] = [1,2]
  12. >>> moddata.mod.a = [[1,2,3],[4,5,6]]
  13. >>> moddata.mod.foo()                
  14.  i=           5
  15.  x=[           1           2           0           0 ]
  16.  a=[
  17.  [   1.000000     ,   2.000000     ,   3.000000     ]
  18.  [   4.000000     ,   5.000000     ,   6.000000     ]
  19.  ]
  20.  Setting a(1,2)=a(1,2)+3
  21. >>> moddata.mod.a               # a is Fortran-contiguous
  22. array([[ 1.,  5.,  3.],
  23.        [ 4.,  5.,  6.]],'f')

可分配数组

F2PY对Fortran 90模块可分配阵​​列提供基本支持。

考虑以下Fortran 90代码：

  1. module mod
  2.   real, allocatable, dimension(:,:) :: b 
  3. contains
  4.   subroutine foo
  5.     integer k
  6.     if (allocated(b)) then
  7.        print*, "b=["
  8.        do k = 1,size(b,1)
  9.           print*, b(k,1:size(b,2))
  10.        enddo
  11.        print*, "]"
  12.     else
  13.        print*, "b is not allocated"
  14.     endif
  15.   end subroutine foo
  16. end module mod

并使用它包装。f2py -c -m allocarr allocarr.f90

在Python中：

  1. >>> import allocarr 
  2. >>> print allocarr.mod.__doc__
  3. b - 'f'-array(-1,-1), not allocated
  4. foo - Function signature:
  5.   foo()
  7. >>> allocarr.mod.foo()  
  8.  b is not allocated
  9. >>> allocarr.mod.b = [[1,2,3],[4,5,6]]         # allocate/initialize b
  10. >>> allocarr.mod.foo()
  11.  b=[
  12.    1.000000       2.000000       3.000000    
  13.    4.000000       5.000000       6.000000    
  14.  ]
  15. >>> allocarr.mod.b                             # b is Fortran-contiguous
  16. array([[ 1.,  2.,  3.],
  17.        [ 4.,  5.,  6.]],'f')
  18. >>> allocarr.mod.b = [[1,2,3],[4,5,6],[7,8,9]] # reallocate/initialize b
  19. >>> allocarr.mod.foo()
  20.  b=[
  21.    1.000000       2.000000       3.000000    
  22.    4.000000       5.000000       6.000000    
  23.    7.000000       8.000000       9.000000    
  24.  ]
  25. >>> allocarr.mod.b = None                      # deallocate array
  26. >>> allocarr.mod.foo()
  27.  b is not allocated