Fortran可否从长度未知字符串读取格式未知浮点数？

snljty

用C/C++/Python等语言处理Fortran写的程序的输出文件的时候，很大的一个麻烦是浮点数的格式。Fortran的格式和前面几个不完全统一，比如以下几点。
1.Fortran用的不是标准科学记数法，默认输出小数部分是(0.1,1]的一个数，C是(1,10]，不过这个一般无关痛痒。
2.Fortran程序员有时候会用D代表双精度浮点数，比如0.2D+02，除了强调双精度浮点以外这个和0.2E+02没有区别，但是前者不能被C识别。
3.当指数超出了限制范围（比如限定指数2位，实际算出来3位的时候），代表浮点数的字母D或者E会被省略，如0.1+100可能代表0.1D+100.
4.输出一堆****的时候，有时候可以考虑当成NaN处理。
上述2.3等问题导致C没法直接读Fortran输出的诸多浮点数格式。虽然可以用一系列字符串处理方法，比如D替换成E，发现没字母就补一个之类的，但是终究很麻烦，也不优雅。

所以我想如果有一个简单方法，可以让Fortran从一个任意长度的字符串（字符数组，对于C只要传递指向数组首位的指针），中读取一个任意格式的浮点数，就好办了。
把这个函数写个简单的fortran文件，当做一个接口，和其他C写的程序混合编译一下即可，那就可以方便很多C/C++/Python开发者。C的字符串就是字符指针和一段空间，用'\0'来标记字符串结束。但Fortran好像没有这种设定。

希望是这个样子。

Makefile:

1. # C和Fortran混合编译测试文件test.exe
   
2. 
   
3. CC      = gcc
   
4. FC      = gfortran
   
5. FLINKER = $(FC)
   
6. 
   
7. all: test.exe
   
8. 
   
9. test.exe: test.o read_double.o
   
10.         $(FLINKER) -o $@ $^
    
11. 
    
12. test.o: test.c
    
13.         $(CC) -o $@ -c $^
    
14. 
    
15. read_double.o: read_double.f90
    
16.         $(FC) -o $@ -c $^
    
17. 
    
18. .PHONY: clean
    
19. clean:
    
20.         -del test.o read_double.o 2>NUL 1>NUL
    
21.         -del test.exe 2>NUL 1>NUL
    
22. 
    

复制代码

test.c:

1. /*  调用Fortran写的 read_double_from_string_ 函数，注意常见编译器会把fortran编译的函数名字后面多加个下划线  */
   
2. 
   
3. # include <stdio.h>
   
4. 
   
5. void read_double_from_string_(const char *const, double *);
   
6. 
   
7. int main()
   
8. {
   
9.     char a[] = "1.23";
   
10.     double d = 0.0;
    
11. 
    
12.     read_double_from_string_(a, & d);
    
13.     /* 如果只是C支持的格式，其实用sscanf(a, "%lf", & d);就行了。  */
    
14. 
    
15.     printf("%.2lf\n", d);
    
16. 
    
17.     return 0;
    
18. }
    

复制代码

read_double.f90

1. ! 这个文件提供一个函数，从任意长度字符串读取任意格式浮点数
   
2. 
   
3. subroutine read_double_from_string(read_str, d_number)
   
4.     implicit none
   
5.     character, pointer :: read_str ! 这里这么写应该不行。
   
6.     real(kind=8) :: d_number
   
7. 
   
8.     read(read_str, "(D)") d_number ! 这里这么写编译器通不过。
   
9.     return
   
10. end subroutine read_double_from_string

复制代码

请问这个read_double.f90有没有办法写出来？谢谢！
抱歉实在不熟悉Fortran，问题有些幼稚的地方还请见笑了。

zjxitcc

我已经忘记C了。以下代码可以运行，结果也是对的。不知道是不是足够合理。
C代码

1. #include<stdio.h>
   
2. #include<string.h>
   
3. 
   
4. int main()
   
5. {
   
6.     char a[] = "1.23";
   
7.     double d = 0.0;
   
8.     int la = (int)strlen(a);
   
9. 
   
10.     read_double_from_string_(&la, a, &d);
    
11. 
    
12.     printf("%.2lf\n", d);
    
13. 
    
14.     return 0;
    
15. }

复制代码

Fortran90代码，fortran读的时候不需要操心数据类型，写*即可，后面读取的变量对了就行。

1. subroutine read_double_from_string(lstr, read_str, d_number)
   
2. implicit none
   
3. integer, intent(in) :: lstr
   
4. character(len=lstr), intent(in) :: read_str
   
5. real(kind=8), intent(out) :: d_number
   
6. 
   
7. read(read_str,*) d_number
   
8. return
   
9. end subroutine read_double_from_string

复制代码

也可以从一个带空格的字符串中读取若干个数据，例如开两个双精度数d1, d2，

这里改为char a[] = "1.23 1.25";
（当然中间要先声明d1, d2，不详细写了）后面fortran可以改为
read(read_str,*) d1, d2

snljty

zjxitcc 发表于 2020-12-17 18:02
我已经忘记C了。以下代码可以运行，结果也是对的。不知道是不是足够合理。
C代码

谢谢邹神！就知道论坛一定能解决！我以前记错了，还以为栈里不能声明大小编译时期未知的变量，因为编译器无法确认尺寸呢...原来有
integer :: lstr
character(len=lstr) :: read_str
这种写法。
不过编译器为什么能允许这种操作...?才发现C语言也行，看来确实是我记错了...之前每次这种情况都是用allocate的...

snljty

更新：把python版本的测试代码也发上来了，编译python需要的pyd库的方法是使用numpy包的f2py模块。

1. f2py -m read_double -c read_double.f90

复制代码

根据2L的回复，稍微改了一下，供参考。
假设要用C从input.txt里面读一行文本，然后从文本里读几个(Fortran格式的)双精度浮点数。

input.txt:

1. 1.23  0.456E+01  0.789D+02   0.100+111
   

复制代码

test.c:

1. /**************************************************************
   
2. *  This file uses Fortran function read_double_from_string_  *
   
3. **************************************************************/
   
4. 
   
5. # ifdef __cplusplus
   
6. extern "C" {
   
7. # endif
   
8. 
   
9. # include <stdio.h>
   
10. # include <string.h>
    
11. 
    
12. /*  note  */
    
13. /*  for most compilers, Fortran will append a '_' to the name of the function,  */
    
14. /*  and uses only lower letters in name of functions.  */
    
15. /*  also, please remember that Fortran passes addresses of arguments, but C/C++ passes values,  */
    
16. /*  hence if you want to call a Fortran function in a C program, you have to pass pointers for all.  */
    
17. void read_double_from_string_(const int *const str_length, const char *const read_str, double *d_number);
    
18. 
    
19. void read_fortran_double(const char *const read_str, double *d_number);
    
20. 
    
21. int main()
    
22. {
    
23.     const char splitter[] = " \r\n\t\v";
    
24.     FILE *ifp = fopen("input.txt", "rt");
    
25. 
    
26.     char buf[BUFSIZ + 1u] = "";
    
27.     double d = 0.0;
    
28.     char *tok = NULL;
    
29. 
    
30.     fgets(buf, BUFSIZ, ifp);
    
31.     tok = strtok(buf, splitter);
    
32.     while(tok)
    
33.     {
    
34.         read_fortran_double(tok, & d);
    
35.         /*  sscanf(a, "%lf", & d);  */
    
36.         printf("%g\n", d);
    
37.         tok = strtok(NULL, splitter);
    
38.     }
    
39. 
    
40.     fclose(ifp);
    
41.     ifp = NULL;
    
42. 
    
43.     return 0;
    
44. }
    
45. 
    
46. void read_fortran_double(const char *const read_str, double *d_number)
    
47. {
    
48.     int len = (int)strlen(read_str);
    
49. 
    
50.     read_double_from_string_(& len, read_str, d_number);
    
51. 
    
52.     return;
    
53. }
    
54. 
    
55. # ifdef __cplusplus
    
56. }
    
57. # endif
    
58. 
    

复制代码

test.py:

1. #! /usr/bin/env python3
   
2. # -*- Coding: UTF-8 -*-
   
3. 
   
4. r"""
   
5. This program uses fortran module read_double
   
6. """
   
7. 
   
8. import read_double
   
9. 
   
10. with open('input.txt') as f:
    
11.     l = f.readline()
    
12. 
    
13. read_fortran_double = lambda _: read_double.read_double_from_string(len(_), _)
    
14. 
    
15. for s in l.strip().split():
    
16.     print(read_fortran_double(s))
    

复制代码

read_double.f90:

1. ! this file reads a double from a string.
   
2. 
   
3. subroutine read_double_from_string(str_length, read_str, d_number)
   
4.     implicit none
   
5.     integer(kind=4), intent(in) :: str_length
   
6.     character(len=str_length), intent(in) :: read_str
   
7.     real(kind=8), intent(out) :: d_number
   
8. 
   
9.     read(read_str, *) d_number
   
10.     return
    
11. end subroutine read_double_from_string
    
12. 
    

复制代码

Makefile:

1. # Makefile for test
   
2. 
   
3. CC      = gcc
   
4. FC      = gfortran
   
5. CLINKER = $(CC)
   
6. FLINKER = $(FC)
   
7. ARCH   = ar
   
8. 
   
9. all: test.exe
   
10. 
    
11. test.exe: test.o static_lib
    
12.         # 可以用Fortran编译器链接
    
13.         $(FLINKER) -o $@ test.o -L . -l read_double
    
14.         # 也可以用C编译器链接，但是gcc默认是不链接libgfortran.*库的，可以加上-l gfortran
    
15.         # $(CLINKER) -o $@ test.o -L . -l read_double -l gfortran
    
16. 
    
17. test.o: test.c
    
18.         $(CC) -o $@ -c $^
    
19. 
    
20. read_double.o: read_double.f90
    
21.         $(FC) -o $@ $^
    
22. 
    
23. static_lib: libread_double.a
    
24. 
    
25. libread_double.a: read_double.o
    
26.         $(ARCH) -rsc $@ $^
    
27. 
    
28. .PHONY: clean
    
29. clean:
    
30.         -rm test.o read_double.o
    
31.         -rm test.exe
    
32.         -rm libread_double.a
    
33. 
    

复制代码

感觉这个方法很适合像我这样C写起来相对顺手，极度恐惧Fortran，超过5行Fortran写起来都难受的人...

snljty

zjxitcc 发表于 2020-12-17 18:02
我已经忘记C了。以下代码可以运行，结果也是对的。不知道是不是足够合理。
C代码

邹老师好，这个fortran文件在用f2py编译后用python无法调用，能请您看看么？
Win10系统，
python是MSC v.1916 64 bit (AMD64)，版本3.8，装了libpython。
fortran编译器用的TDM-gcc 9.2.0里面的gfortran，x86_64-w64-mingw32里面的
f2py是对应numpy 1.19.2的版本。

编译使用

1. f2py -m read_double -c read_double.f90

复制代码

然后生成了read_double.cp38-win_amd64.pyd

python里面报错如下：

1. >>> import read_double
   
2. Traceback (most recent call last):
   
3.   File "<stdin>", line 1, in <module>
   
4. ImportError: DLL load failed while importing read_double: A dynamic link library (DLL) initialization routine failed.

复制代码

也尝试了在别的操作系统下编译，没有成功。
用一个最简单的subroutine测试了一下（两个整数相加），编译完了加载没有问题，f2py应该至少（部分）是配置好的。
谢谢！

hebrewsnabla

snljty 发表于 2020-12-21 20:36
邹老师好，这个fortran文件在用f2py编译后用python无法调用，能请您看看么？
Win10系统，
python是MSC  ...

linux下是可以的。

zjxitcc

snljty 发表于 2020-12-21 20:36
邹老师好，这个fortran文件在用f2py编译后用python无法调用，能请您看看么？
Win10系统，
python是MSC  ...

我没法安装你的这么多软件所以没法调试。我在linux下用anaconda python的f2py编译试了，是可以import的，结果也正常。为保稳妥，你可以采取如下形式复杂写法

1. subroutine read_double_from_string(lstr, read_str, d_number)
   
2. implicit none
   
3. integer :: lstr
   
4. !f2py intent(in) :: lstr
   
5. character(len=lstr) :: read_str
   
6. !f2py depend(lstr) :: read_str
   
7. !f2py intent(in) :: read_str
   
8. real(kind=8) :: d_number
   
9. !f2py intent(out) :: d_number
   
10. 
    
11. read(read_str,*) d_number
    
12. return
    
13. end subroutine read_double_from_string

复制代码

注意!f2py最好顶格，!与f2py间无空格。运行
$python
>>>from aaa import read_double_from_string
>>>i = read_double_from_string(4, '1.23')
>>>print(i)
1.23

可能是旧的编译器无法自动识别变量depend吧

snljty

hebrewsnabla 发表于 2020-12-21 20:54
linux下是可以的。

谢谢！刚又试了一下ubuntu下其实是成功的，就是很奇怪python能用，但是ipython找不到库。之前用ipython调试的，没仔细看还以为是一样的报错。

snljty

zjxitcc 发表于 2020-12-21 21:03
我没法安装你的这么多软件所以没法调试。我在linux下用anaconda python的f2py编译试了，是可以import ...

谢谢！这种写法我也试过，目前Windows下还是不行，估计是gnu编译器版本和python里面某些不兼容。我尝试一下用conda装的mingw（这个装上用就报错，正在调试。）

snljty

zjxitcc 发表于 2020-12-21 21:03
我没法安装你的这么多软件所以没法调试。我在linux下用anaconda python的f2py编译试了，是可以import ...

已经解决，谢谢您！用conda装了个mingw，把mingw安装目录写在PATH最前面，然后用conda里面mingw的gnu编译器(4.7.0)就通过了。估计还是兼容性问题。