I see that rather than try to convert a C++ function to
Fortran, it might be better to call it from a Fortran
program. So I found a description of how to do it, and
it involves an interface:

interface
subroutine normal_vec(seed, n, x) bind(c)
import c_int, c_double
integer(kind=c_int), intent(in), value :: seed, n
real(kind=c_double) :: x(n)
end subroutine normal_vec
end interface

This is for an example of a random number generator.
I note a declaration of the variable type c_double.
The function I want to call declares "long double"
but I doubt that I can use

import c_long double
....
real(kind=c_long double) :: t, JBAND

where t is the variable passed to the function JBAND

What should I put there?
--
Dieter Britz

On Monday, September 4, 2023 at 7:43:44 AM UTC-7, db wrote:
(snip)

> This is for an example of a random number generator.
> I note a declaration of the variable type c_double.
> The function I want to call declares "long double"
> but I doubt that I can use
>
> import c_long double
> ...
> real(kind=c_long double) :: t, JBAND

The constants are supposed to be defined for the types supported
by the associated C compiler. (You need to write C callable C++ code.)

Le 04/09/2023 à 16:43, db a écrit :
> I see that rather than try to convert a C++ function to
> Fortran, it might be better to call it from a Fortran
> program. So I found a description of how to do it, and
> it involves an interface:
>
> interface
> subroutine normal_vec(seed, n, x) bind(c)
> import c_int, c_double
> integer(kind=c_int), intent(in), value :: seed, n
> real(kind=c_double)                    :: x(n)
> end subroutine normal_vec
> end interface
>
> This is for an example of a random number generator.
> I note a declaration of the variable type c_double.
> The function I want to call declares "long double"
> but I doubt that I can use
>
> import c_long double
> ...
> real(kind=c_long double) :: t, JBAND
>
> where t is the variable passed to the function JBAND
>
>
> What should I put there?

real(kind=c_long_double) :: ...

--
"...sois ouvert aux idées des autres pour peu qu'elles aillent dans le
même sens que les tiennes.", ST sur fr.bio.medecine
ST passe le mur du çon : <j3nn2hFmqj7U1@mid.individual.net>

On 05.09.2023 11.50, pehache wrote:
> Le 04/09/2023 à 16:43, db a écrit :
>> I see that rather than try to convert a C++ function to
>> Fortran, it might be better to call it from a Fortran
>> program. So I found a description of how to do it

It resulted in a Forytran program that calls a Fortran function
that calls the C++ function IBAND (exists as iband.cpp). Here is
the code (sorry for the length)

module STUFF
integer, parameter :: dbl=selected_real_kind(14)
integer, parameter :: qud=selected_real_kind(30)
end module STUFF
program JBAND_TEST
use STUFF; implicit none

real(dbl) :: curr, FORTJBAND
real(qud) :: tbar
do
read *, tbar
if (tbar < 0) exit
curr = FORTJBAND (tbar)
print '(" curr =", f10.4)', curr
enddo
end program JBAND_TEST
function FORTJBAND (tbar)
use STUFF; implicit none
interface
function JBAND (tbar) bind(c)
import JBAND, c_long_double
import tbar, c_long_double
end function JBAND
end interface
real(dbl) :: FORTJBAND
real(qud) :: tbar, JBAND
FORTJBAND = JBAND (tbar)
end function FORTJBAND

The file jband.cpp is large. It is declared as long double and so
is the input to it, tbar.

I then wrote a script for running it, reproducing what the link
tells me:

cpp -o jband.o jband.cpp
gfortran -o jbandtest.o jbandtest.f90
gfortran jband.o jbandtest.o
../a.out << eoi
1.0
10.0
-1
eoi

When I run this, I get this:

~/ownlib90/tests> ./jbandtest
cpp: fatal error: cannot execute 'cc1plus': execvp: No such file or
directory
compilation terminated.
jbandtest.f90:21:31:

21 | import JBAND, c_long_double
| 1
Error: Cannot IMPORT 'c_long_double' from host scoping unit at (1) -
does not exist.
jbandtest.f90:22:30:

22 | import tbar, c_long_double
| 1
Error: Cannot IMPORT 'c_long_double' from host scoping unit at (1) -
does not exist.
jbandtest.f90:27:14:

27 | FORTJBAND = JBAND (tbar)
| 1
Error: Type mismatch in argument 'tbar' at (1); passed REAL(16) to REAL(4)

etc, What is cc1plus, where does that come in? Why is long double
not recognised? What do I do to get this running?
--
Dieter Britz

On Wednesday, September 6, 2023 at 5:24:52 AM UTC-7, db wrote:

(snip)

> When I run this, I get this:
>
> ~/ownlib90/tests> ./jbandtest
> cpp: fatal error: cannot execute 'cc1plus': execvp: No such file or
> directory
> compilation terminated.
cc1plus is the first pass of the C++ compiler.
(I suspect it also won't find the second pass, but didn't get that far.)

You need to install a C++ compiler.

Le 06/09/2023 à 14:24, db a écrit :
> On 05.09.2023 11.50, pehache wrote:
>> Le 04/09/2023 à 16:43, db a écrit :
>>> I see that rather than try to convert a C++ function to
>>> Fortran, it might be better to call it from a Fortran
>>> program. So I found a description of how to do it
>
> It resulted in a Forytran program that calls a Fortran function
> that calls the C++ function IBAND (exists as iband.cpp). Here is
> the code (sorry for the length)
>
> module STUFF
>   integer, parameter :: dbl=selected_real_kind(14)
>   integer, parameter :: qud=selected_real_kind(30)
> end module STUFF
> program JBAND_TEST
>   use STUFF;   implicit none
>
>   real(dbl) :: curr, FORTJBAND
>   real(qud) :: tbar
>   do
>      read *, tbar
>      if (tbar < 0) exit
>      curr = FORTJBAND (tbar)
>      print '(" curr =", f10.4)', curr
>   enddo
> end program JBAND_TEST
> function FORTJBAND (tbar)
>   use STUFF;   implicit none
>   interface
>     function JBAND (tbar) bind(c)
>     import JBAND, c_long_double
>     import tbar, c_long_double
>     end function JBAND
>   end interface
>   real(dbl) :: FORTJBAND
>   real(qud) :: tbar, JBAND
>   FORTJBAND = JBAND (tbar)
> end function FORTJBAND

1) You are missing the ISO_C_BINDING module
2) I don't get the syntax with the "import"
3) you don't need to declare JBAND in addition to the interface

=======================================
function FORTJBAND (tbar)
use ISO_C_BINDING
use STUFF
implicit none
interface
function JBAND (tbar) bind(c)
real(c_lonf_double) :: JBAND
real(c_lonf_double) :: tbar
end function JBAND
end interface
real(dbl) :: FORTJBAND
real(qud) :: tbar
FORTJBAND = JBAND (tbar)
end function FORTJBAND
=======================================

>
> I then wrote a script for running it, reproducing what the link
> tells me:
>
> cpp -o jband.o jband.cpp
> gfortran -o jbandtest.o jbandtest.f90
> gfortran jband.o jbandtest.o
> ./a.out << eoi
> 1.0
> 10.0
> -1
> eoi
>
> When I run this, I get this:
>
> ~/ownlib90/tests> ./jbandtest
> cpp: fatal error: cannot execute 'cc1plus': execvp: No such file or
> directory
> compilation terminated.

Isn't "cpp" just the C/C++ preprocessor? Shouldn't you use "g++" instead?

--
"...sois ouvert aux idées des autres pour peu qu'elles aillent dans le
même sens que les tiennes.", ST sur fr.bio.medecine
ST passe le mur du çon : <j3nn2hFmqj7U1@mid.individual.net>

On 06.09.2023 23.35, pehache wrote:
> Le 06/09/2023 à 14:24, db a écrit :
>> On 05.09.2023 11.50, pehache wrote:
>>> Le 04/09/2023 à 16:43, db a écrit :
>>>> I see that rather than try to convert a C++ function to
>>>> Fortran, it might be better to call it from a Fortran
>>>> program. So I found a description of how to do it
>>
>> It resulted in a Forytran program that calls a Fortran function
>> that calls the C++ function IBAND (exists as iband.cpp). Here is
>> the code (sorry for the length)
>>
>> module STUFF
>>    integer, parameter :: dbl=selected_real_kind(14)
>>    integer, parameter :: qud=selected_real_kind(30)
>> end module STUFF
>> program JBAND_TEST
>>    use STUFF;   implicit none
>>
>>    real(dbl) :: curr, FORTJBAND
>>    real(qud) :: tbar
>>    do
>>       read *, tbar
>>       if (tbar < 0) exit
>>       curr = FORTJBAND (tbar)
>>       print '(" curr =", f10.4)', curr
>>    enddo
>> end program JBAND_TEST
>> function FORTJBAND (tbar)
>>    use STUFF;   implicit none
>>    interface
>>      function JBAND (tbar) bind(c)
>>      import JBAND, c_long_double
>>      import tbar, c_long_double
>>      end function JBAND
>>    end interface
>>    real(dbl) :: FORTJBAND
>>    real(qud) :: tbar, JBAND
>>    FORTJBAND = JBAND (tbar)
>> end function FORTJBAND
>
> 1) You are missing the ISO_C_BINDING module
> 2) I don't get the syntax with the "import"
> 3) you don't need to declare JBAND in addition to the interface
>
> =======================================
> function FORTJBAND (tbar)
>    use ISO_C_BINDING
>    use STUFF
>    implicit none
>    interface
>      function JBAND (tbar) bind(c)
>        real(c_lonf_double) :: JBAND
>        real(c_lonf_double) :: tbar
>      end function JBAND
>    end interface
>    real(dbl) :: FORTJBAND
>    real(qud) :: tbar
>    FORTJBAND = JBAND (tbar)
> end function FORTJBAND
> =======================================
>
>>
>> I then wrote a script for running it, reproducing what the link
>> tells me:
>>
>> cpp -o jband.o jband.cpp
>> gfortran -o jbandtest.o jbandtest.f90
>> gfortran jband.o jbandtest.o
>> ./a.out << eoi
>> 1.0
>> 10.0
>> -1
>> eoi
>>
>> When I run this, I get this:
>>
>> ~/ownlib90/tests> ./jbandtest
>> cpp: fatal error: cannot execute 'cc1plus': execvp: No such file or
>> directory
>> compilation terminated.
>
> Isn't "cpp" just the C/C++ preprocessor? Shouldn't you use "g++" instead?
>
Ah, OK, I thought it mean c plus plus. I will install C++ now
and compile with G++ (i suppose).

--
Dieter Britz

On Thursday, September 7, 2023 at 2:49:24 AM UTC-7, db wrote:

(snip)

> > Isn't "cpp" just the C/C++ preprocessor? Shouldn't you use "g++" instead?

Tradition is that it figures out what to do based on the file names.

In any case, cc1 is the usual first pass of the C compilers, and I suspect that
cc1plus is the first pass of the C++ compiler.

It is usual for C and C++ compilers to include the preprocessor, and not
run it as a separate pass. You can still ask for only the preprocessor, though.

Traditionally, that is:

cc -E
> Ah, OK, I thought it mean c plus plus. I will install C++ now
> and compile with G++ (i suppose).

Le 07/09/2023 à 15:25, gah4 a écrit :
> On Thursday, September 7, 2023 at 2:49:24 AM UTC-7, db wrote:
>
> (snip)
>
>> > Isn't "cpp" just the C/C++ preprocessor? Shouldn't you use "g++" instead?
>
> Tradition is that it figures out what to do based on the file names.
>
> In any case, cc1 is the usual first pass of the C compilers, and I suspect that
> cc1plus is the first pass of the C++ compiler.
>
> It is usual for C and C++ compilers to include the preprocessor, and not
> run it as a separate pass. You can still ask for only the preprocessor, though.
>
> Traditionally, that is:
>
> cc -E
>

Sure, but the preprocessor is also available as a separate command.

https://linux.die.net/man/1/cpp

On 07.09.2023 11.49, db wrote:
> On 06.09.2023 23.35, pehache wrote:
>> Le 06/09/2023 à 14:24, db a écrit :
>>> On 05.09.2023 11.50, pehache wrote:
>>>> Le 04/09/2023 à 16:43, db a écrit :
>>>>> I see that rather than try to convert a C++ function to
>>>>> Fortran, it might be better to call it from a Fortran
>>>>> program. So I found a description of how to do it
>>>
>>> It resulted in a Forytran program that calls a Fortran function
>>> that calls the C++ function IBAND (exists as iband.cpp). Here is
>>> the code (sorry for the length)
>>>
>>> module STUFF
>>>    integer, parameter :: dbl=selected_real_kind(14)
>>>    integer, parameter :: qud=selected_real_kind(30)
>>> end module STUFF
>>> program JBAND_TEST
>>>    use STUFF;   implicit none
>>>
>>>    real(dbl) :: curr, FORTJBAND
>>>    real(qud) :: tbar
>>>    do
>>>       read *, tbar
>>>       if (tbar < 0) exit
>>>       curr = FORTJBAND (tbar)
>>>       print '(" curr =", f10.4)', curr
>>>    enddo
>>> end program JBAND_TEST
>>> function FORTJBAND (tbar)
>>>    use STUFF;   implicit none
>>>    interface
>>>      function JBAND (tbar) bind(c)
>>>      import JBAND, c_long_double
>>>      import tbar, c_long_double
>>>      end function JBAND
>>>    end interface
>>>    real(dbl) :: FORTJBAND
>>>    real(qud) :: tbar, JBAND
>>>    FORTJBAND = JBAND (tbar)
>>> end function FORTJBAND
>>
>> 1) You are missing the ISO_C_BINDING module
>> 2) I don't get the syntax with the "import"
>> 3) you don't need to declare JBAND in addition to the interface
>>
>> =======================================
>> function FORTJBAND (tbar)
>>     use ISO_C_BINDING
>>     use STUFF
>>     implicit none
>>     interface
>>       function JBAND (tbar) bind(c)
>>         real(c_lonf_double) :: JBAND
>>         real(c_lonf_double) :: tbar
>>       end function JBAND
>>     end interface
>>     real(dbl) :: FORTJBAND
>>     real(qud) :: tbar
>>     FORTJBAND = JBAND (tbar)
>> end function FORTJBAND
>> =======================================
>>
>>>
>>> I then wrote a script for running it, reproducing what the link
>>> tells me:
>>>
>>> cpp -o jband.o jband.cpp
>>> gfortran -o jbandtest.o jbandtest.f90
>>> gfortran jband.o jbandtest.o
>>> ./a.out << eoi
>>> 1.0
>>> 10.0
>>> -1
>>> eoi
>>>
>>> When I run this, I get this:
>>>
>>> ~/ownlib90/tests> ./jbandtest
>>> cpp: fatal error: cannot execute 'cc1plus': execvp: No such file or
>>> directory
>>> compilation terminated.
>>
>> Isn't "cpp" just the C/C++ preprocessor? Shouldn't you use "g++" instead?
>>
> Ah, OK, I thought it mean c plus plus. I will install C++ now
> and compile with G++ (i suppose).
>
I now have g++ installed and ran it with g++ instead of cpp. I still
get complaints about long double:

jbandtest.f90:21:31:

21 | import JBAND, c_long_double
| 1
Error: Cannot IMPORT 'c_long_double' from host scoping unit at (1) -
does not exist.
jbandtest.f90:22:30:

(several times). Is it the underscores? Inside the C++ function, it
is just "long double".
--
Dieter Britz

On 08.09.2023 14.52, db wrote:
> On 07.09.2023 11.49, db wrote:
>> On 06.09.2023 23.35, pehache wrote:
>>> Le 06/09/2023 à 14:24, db a écrit :
>>>> On 05.09.2023 11.50, pehache wrote:
>>>>> Le 04/09/2023 à 16:43, db a écrit :
>>>>>> I see that rather than try to convert a C++ function to
>>>>>> Fortran, it might be better to call it from a Fortran
>>>>>> program. So I found a description of how to do it
>>>>
>>>> It resulted in a Forytran program that calls a Fortran function
>>>> that calls the C++ function IBAND (exists as iband.cpp). Here is
>>>> the code (sorry for the length)
>>>>
>>>> module STUFF
>>>>    integer, parameter :: dbl=selected_real_kind(14)
>>>>    integer, parameter :: qud=selected_real_kind(30)
>>>> end module STUFF
>>>> program JBAND_TEST
>>>>    use STUFF;   implicit none
>>>>
>>>>    real(dbl) :: curr, FORTJBAND
>>>>    real(qud) :: tbar
>>>>    do
>>>>       read *, tbar
>>>>       if (tbar < 0) exit
>>>>       curr = FORTJBAND (tbar)
>>>>       print '(" curr =", f10.4)', curr
>>>>    enddo
>>>> end program JBAND_TEST
>>>> function FORTJBAND (tbar)
>>>>    use STUFF;   implicit none
>>>>    interface
>>>>      function JBAND (tbar) bind(c)
>>>>      import JBAND, c_long_double
>>>>      import tbar, c_long_double
>>>>      end function JBAND
>>>>    end interface
>>>>    real(dbl) :: FORTJBAND
>>>>    real(qud) :: tbar, JBAND
>>>>    FORTJBAND = JBAND (tbar)
>>>> end function FORTJBAND
>>>
>>> 1) You are missing the ISO_C_BINDING module
>>> 2) I don't get the syntax with the "import"
>>> 3) you don't need to declare JBAND in addition to the interface
>>>
>>> =======================================
>>> function FORTJBAND (tbar)
>>>     use ISO_C_BINDING
>>>     use STUFF
>>>     implicit none
>>>     interface
>>>       function JBAND (tbar) bind(c)
>>>         real(c_lonf_double) :: JBAND
>>>         real(c_lonf_double) :: tbar
>>>       end function JBAND
>>>     end interface
>>>     real(dbl) :: FORTJBAND
>>>     real(qud) :: tbar
>>>     FORTJBAND = JBAND (tbar)
>>> end function FORTJBAND
>>> =======================================
>>>
>>>>
>>>> I then wrote a script for running it, reproducing what the link
>>>> tells me:
>>>>
>>>> cpp -o jband.o jband.cpp
>>>> gfortran -o jbandtest.o jbandtest.f90
>>>> gfortran jband.o jbandtest.o
>>>> ./a.out << eoi
>>>> 1.0
>>>> 10.0
>>>> -1
>>>> eoi
>>>>
>>>> When I run this, I get this:
>>>>
>>>> ~/ownlib90/tests> ./jbandtest
>>>> cpp: fatal error: cannot execute 'cc1plus': execvp: No such file or
>>>> directory
>>>> compilation terminated.
>>>
>>> Isn't "cpp" just the C/C++ preprocessor? Shouldn't you use "g++"
>>> instead?
>>>
>> Ah, OK, I thought it mean c plus plus. I will install C++ now
>> and compile with G++ (i suppose).
>>
> I now have g++ installed and ran it with g++ instead of cpp. I still
> get complaints about long double:
>
> jbandtest.f90:21:31:
>
>    21 |     import JBAND, c_long_double
>       |                               1
> Error: Cannot IMPORT 'c_long_double' from host scoping unit at (1) -
> does not exist.
> jbandtest.f90:22:30:
>
> (several times). Is it the underscores? Inside the C++ function, it
> is just "long double".

I just tried reducing all long double entities to plain double in both
the C++ and calling Fortran units. Now it says that C_double does not
exist. So the problem is getting Fortran to specify a C++ type. I
thought that the import statement does that.

--
Dieter Britz

Le 08/09/2023 à 15:15, db a écrit :
> On 08.09.2023 14.52, db wrote:
>> On 07.09.2023 11.49, db wrote:
>>> On 06.09.2023 23.35, pehache wrote:
>>>> Le 06/09/2023 à 14:24, db a écrit :
>>>>> On 05.09.2023 11.50, pehache wrote:
>>>>>> Le 04/09/2023 à 16:43, db a écrit :
>>>>>>> I see that rather than try to convert a C++ function to
>>>>>>> Fortran, it might be better to call it from a Fortran
>>>>>>> program. So I found a description of how to do it
>>>>>
>>>>> It resulted in a Forytran program that calls a Fortran function
>>>>> that calls the C++ function IBAND (exists as iband.cpp). Here is
>>>>> the code (sorry for the length)
>>>>>
>>>>> module STUFF
>>>>>    integer, parameter :: dbl=selected_real_kind(14)
>>>>>    integer, parameter :: qud=selected_real_kind(30)
>>>>> end module STUFF
>>>>> program JBAND_TEST
>>>>>    use STUFF;   implicit none
>>>>>
>>>>>    real(dbl) :: curr, FORTJBAND
>>>>>    real(qud) :: tbar
>>>>>    do
>>>>>       read *, tbar
>>>>>       if (tbar < 0) exit
>>>>>       curr = FORTJBAND (tbar)
>>>>>       print '(" curr =", f10.4)', curr
>>>>>    enddo
>>>>> end program JBAND_TEST
>>>>> function FORTJBAND (tbar)
>>>>>    use STUFF;   implicit none
>>>>>    interface
>>>>>      function JBAND (tbar) bind(c)
>>>>>      import JBAND, c_long_double
>>>>>      import tbar, c_long_double
>>>>>      end function JBAND
>>>>>    end interface
>>>>>    real(dbl) :: FORTJBAND
>>>>>    real(qud) :: tbar, JBAND
>>>>>    FORTJBAND = JBAND (tbar)
>>>>> end function FORTJBAND
>>>>
>>>> 1) You are missing the ISO_C_BINDING module
>>>> 2) I don't get the syntax with the "import"
>>>> 3) you don't need to declare JBAND in addition to the interface
>>>>
>>>> =======================================
>>>> function FORTJBAND (tbar)
>>>>     use ISO_C_BINDING
>>>>     use STUFF
>>>>     implicit none
>>>>     interface
>>>>       function JBAND (tbar) bind(c)
>>>>         real(c_lonf_double) :: JBAND
>>>>         real(c_lonf_double) :: tbar
>>>>       end function JBAND
>>>>     end interface
>>>>     real(dbl) :: FORTJBAND
>>>>     real(qud) :: tbar
>>>>     FORTJBAND = JBAND (tbar)
>>>> end function FORTJBAND
>>>> =======================================
>>>>
>>>>>
>>>>> I then wrote a script for running it, reproducing what the link
>>>>> tells me:
>>>>>
>>>>> cpp -o jband.o jband.cpp
>>>>> gfortran -o jbandtest.o jbandtest.f90
>>>>> gfortran jband.o jbandtest.o
>>>>> ./a.out << eoi
>>>>> 1.0
>>>>> 10.0
>>>>> -1
>>>>> eoi
>>>>>
>>>>> When I run this, I get this:
>>>>>
>>>>> ~/ownlib90/tests> ./jbandtest
>>>>> cpp: fatal error: cannot execute 'cc1plus': execvp: No such file or
>>>>> directory
>>>>> compilation terminated.
>>>>
>>>> Isn't "cpp" just the C/C++ preprocessor? Shouldn't you use "g++"
>>>> instead?
>>>>
>>> Ah, OK, I thought it mean c plus plus. I will install C++ now
>>> and compile with G++ (i suppose).
>>>
>> I now have g++ installed and ran it with g++ instead of cpp. I still
>> get complaints about long double:
>>
>> jbandtest.f90:21:31:
>>
>>    21 |     import JBAND, c_long_double
>>       |                               1
>> Error: Cannot IMPORT 'c_long_double' from host scoping unit at (1) -
>> does not exist.
>> jbandtest.f90:22:30:
>>
>> (several times). Is it the underscores? Inside the C++ function, it
>> is just "long double".
>
> I just tried reducing all long double entities to plain double in both
> the C++ and calling Fortran units. Now it says that C_double does not
> exist. So the problem is getting Fortran to specify a C++ type. I
> thought that the import statement does that.

Please go back to one of my previous message where I wrote: "I don't get
the syntax with the "import"". And proposed the correct syntax.

On 04.09.2023 16.43, db wrote:
> I see that rather than try to convert a C++ function to
> Fortran, it might be better to call it from a Fortran
> program. So I found a description of how to do it, and
I askked this both here and in the C++ ng. I got a lot of different
advice, none of which worked. So I have now reduced it to a mini-
example. Here is the Fortran program that calls a C++ function:

program MINI_TEST
use ISO_C_BINDING
implicit none
integer, parameter :: dbl=selected_real_kind(14)
real(dbl) :: MINI, arg, arg2
interface
function MINI (tbar)
real(c_double) :: MINI
real(c_double) :: arg
end function MINI
end interface
read *, arg
arg2 = MINI (arg)
print '(" MINI returned =", f10.4)', arg2
end program MINI_TEST

The function is

#include <iostream>
#include <fstream>
#include <iomanip>
#include "math.h"
using namespace std;
const double mini(const double arg)
{ return arg * 2;
}

I know this works because I got a C++ calling program from
a friend, that called it and the result is correct.

I wrote a shell script to run this, using another suggestion

gfortran -o minitest.out minitest.f90 mini.cpp -lstdc++ -lm
../minitest.out << eoi
1.0
eoi
rm minitest.out

and ran that. The main problem is that it doesn't recognise
the C++ type c_double:

minitest.f90:8:11:

8 | real(c_double) :: MINI
| 1
Error: Parameter 'c_double' at (1) has not been declared or is a
variable, which does not reduce to a constant expression

(same for arg) plus a type mismatch arising from it.

So: can you suggest how to make this work? If so, then
I can implement that with the much longer actual function
I am trying to call from Fortran.

--
Dieter Britz

I wonder if you add ISO_C_BINDING inside the function interface if it
helps resolve the reference.

On 9/30/2023 8:42 AM, db wrote:
> On 04.09.2023 16.43, db wrote:
>> I see that rather than try to convert a C++ function to
>> Fortran, it might be better to call it from a Fortran
>> program. So I found a description of how to do it, and
> I askked this both here and in the C++ ng. I got a lot of different
> advice, none of which worked. So I have now reduced it to a mini-
> example. Here is the Fortran program that calls a C++ function:
>
> program MINI_TEST
>   use ISO_C_BINDING
>   implicit none
>   integer, parameter :: dbl=selected_real_kind(14)
>   real(dbl) :: MINI, arg, arg2
>   interface
>     function MINI (tbar)
>       real(c_double) :: MINI
>       real(c_double) :: arg
>     end function MINI
>   end interface
>   read *, arg
>   arg2 = MINI (arg)
>   print '(" MINI returned =", f10.4)', arg2
> end program MINI_TEST
>
> The function is
>
> #include <iostream>
> #include <fstream>
> #include <iomanip>
> #include "math.h"
> using namespace std;
> const double mini(const double arg)
> {
> return arg * 2;
> }
>
>
> I know this works because I got a C++ calling program from
> a friend, that called it and the result is correct.
>
> I wrote a shell script to run this, using another suggestion
>
> gfortran -o minitest.out minitest.f90 mini.cpp -lstdc++ -lm
> ./minitest.out << eoi
> 1.0
> eoi
> rm minitest.out
>
> and ran that. The main problem is that it doesn't recognise
> the C++ type c_double:
>
> minitest.f90:8:11:
>
>     8 |       real(c_double) :: MINI
>       |           1
> Error: Parameter 'c_double' at (1) has not been declared or is a
> variable, which does not reduce to a constant expression
>
> (same for arg) plus a type mismatch arising from it.
>
> So: can you suggest how to make this work? If so, then
> I can implement that with the much longer actual function
> I am trying to call from Fortran.
>
>

On Saturday, September 30, 2023 at 9:42:34 AM UTC-4, db wrote:

> On 04.09.2023 16.43, db wrote:
> ..
> I askked this both here and in the C++ ng. I got a lot of different
> advice, none of which worked. So I have now reduced it to a mini-
> example. Here is the Fortran program that calls a C++ function:
> ..

@db,

Please review the following illustration:

--- begin console output ---
C:\temp>type c++.cpp
extern "C" const double mini(const double arg) {
return arg*2;
}

C:\temp>type p.f90
use, intrinsic :: iso_c_binding, only : c_double
interface
function mini( arg ) result(r) bind(C, name="mini")
import :: c_double
real(c_double), value, intent(in) :: arg
! function result
real(c_double) :: r
end function
end interface
real(c_double) :: arg, arg2
arg = 2.0
arg2 = mini(arg)
print '(" MINI returned =", f10.4)', arg2
end

C:\temp>gfortran c++.cpp p.f90 -o p.exe

C:\temp>p.exe
MINI returned = 4.0000
--- end console output ---

Now, please note the following:

1. extern "C" decoration of the C++ function. If you seek portable and simpler interoperation of C++ code with Fortran and thus seek to use the standard facilities in Fortran, then note the interoperation is between a Fortran processor and a companion C processor only. It is NOT with C++ directly. In C++ code, you achieve the companion C processor semantics via *extern "C"*. Without *extern "C"*, you need to look into the processor extensions and see how C++ and Fortran might work that processor (e.g, GCC/gfortran system). That is, if at all they interoperate - note there is no standard Fortran here.

2. In Fortran code, look at the IMPORT statement in the INTERFACE block. Note an INTERFACE block in Fortran generally is stand-alone, it has no knowledge of the host unit except for what it's informed. In lieu of IMPORT, you can duplicate the USE statement in the INTERFACE block, if you so choose. I don't recommend it though. Bottom-line: an IMPORT or USE is needed to inform the INTERFACE for this MINI function what `c_double` is.

3. Consider using KINDs from ISO_C_BINDING module for the Fortran objects that interoperate with the external procedures such as `MINI`. So note `arg` and `arg2` can both be declared as real(c_double). You can use renaming facility in Fortran to shorten the kind name to `CD` or some such, if you prefer.

By the way, have you considered studying from books closely such as Chapman on Fortran 2008 and Modern Fortran Explained? It appears you will benefit yourself by doing so - you are getting stuck with very basic semantics and syntax aspects of modern Fortran and you would do well by putting aside a bit of time to read first to save yourself a lot of time with debugging basic errors and engaging on online forums seeking help to resolve them.

On 30.09.2023 18.53, FortranFan wrote:
> On Saturday, September 30, 2023 at 9:42:34 AM UTC-4, db wrote:
>
>> On 04.09.2023 16.43, db wrote:
>> ..
>> I askked this both here and in the C++ ng. I got a lot of different
>> advice, none of which worked. So I have now reduced it to a mini-
>> example. Here is the Fortran program that calls a C++ function:
>> ..
>
> @db,
>
> Please review the following illustration:
>
> --- begin console output ---
> C:\temp>type c++.cpp
> extern "C" const double mini(const double arg) {
> return arg*2;
> }
>
>
> C:\temp>type p.f90
> use, intrinsic :: iso_c_binding, only : c_double
> interface
> function mini( arg ) result(r) bind(C, name="mini")
> import :: c_double
> real(c_double), value, intent(in) :: arg
> ! function result
> real(c_double) :: r
> end function
> end interface
> real(c_double) :: arg, arg2
> arg = 2.0
> arg2 = mini(arg)
> print '(" MINI returned =", f10.4)', arg2
> end
>
> C:\temp>gfortran c++.cpp p.f90 -o p.exe
>
> C:\temp>p.exe
> MINI returned = 4.0000
> --- end console output ---
>
> Now, please note the following:
>
> 1. extern "C" decoration of the C++ function. If you seek portable and simpler interoperation of C++ code with Fortran and thus seek to use the standard facilities in Fortran, then note the interoperation is between a Fortran processor and a companion C processor only. It is NOT with C++ directly. In C++ code, you achieve the companion C processor semantics via *extern "C"*. Without *extern "C"*, you need to look into the processor extensions and see how C++ and Fortran might work that processor (e.g, GCC/gfortran system). That is, if at all they interoperate - note there is no standard Fortran here.
>
> 2. In Fortran code, look at the IMPORT statement in the INTERFACE block. Note an INTERFACE block in Fortran generally is stand-alone, it has no knowledge of the host unit except for what it's informed. In lieu of IMPORT, you can duplicate the USE statement in the INTERFACE block, if you so choose. I don't recommend it though. Bottom-line: an IMPORT or USE is needed to inform the INTERFACE for this MINI function what `c_double` is.
>
> 3. Consider using KINDs from ISO_C_BINDING module for the Fortran objects that interoperate with the external procedures such as `MINI`. So note `arg` and `arg2` can both be declared as real(c_double). You can use renaming facility in Fortran to shorten the kind name to `CD` or some such, if you prefer.
>
> By the way, have you considered studying from books closely such as Chapman on Fortran 2008 and Modern Fortran Explained? It appears you will benefit yourself by doing so - you are getting stuck with very basic semantics and syntax aspects of modern Fortran and you would do well by putting aside a bit of time to read first to save yourself a lot of time with debugging basic errors and engaging on online forums seeking help to resolve them.

Thank you, that worked, also with my original mini.cpp afterI commented
out the first few lines

#include <iostream>
#include <fstream>
#include <iomanip>
#include "math.h"
using namespace std;

And I added your extern "C".

I have never used C ++ so I just used what the original, much
longer, C++ function code used, but these lines seem not to
be needed. I must now implement all this with the actual
function, trimmed appropriately.

You might be right that I could study more modern Fortran but so
far f90 has served me well. As for online fora, this is what they
are for, aren't they? You have solved my problem. If everyone
knew everything, there would be no need for this ng.
--
Dieter Britz

On 01.10.2023 14.44, db wrote:
> On 30.09.2023 18.53, FortranFan wrote:
>> On Saturday, September 30, 2023 at 9:42:34 AM UTC-4, db wrote:
>>
>>> On 04.09.2023 16.43, db wrote:
>>> ..
>>> I askked this both here and in the C++ ng. I got a lot of different
>>> advice, none of which worked. So I have now reduced it to a mini-
>>> example. Here is the Fortran program that calls a C++ function:
>>> ..
>>
>> @db,
>>
>> Please review the following illustration:
>>
>> --- begin console output ---
>> C:\temp>type c++.cpp
>> extern "C" const double mini(const double arg) {
>>     return arg*2;
>> }
>>
>>
>> C:\temp>type p.f90
>>     use, intrinsic :: iso_c_binding, only : c_double
>>     interface
>>        function mini( arg ) result(r) bind(C, name="mini")
>>           import :: c_double
>>           real(c_double), value, intent(in) :: arg
>>           ! function result
>>           real(c_double) :: r
>>        end function
>>     end interface
>>     real(c_double) :: arg, arg2
>>     arg = 2.0
>>     arg2 = mini(arg)
>>     print '(" MINI returned =", f10.4)', arg2
>> end
>>
>> C:\temp>gfortran c++.cpp p.f90 -o p.exe
>>
>> C:\temp>p.exe
>>   MINI returned =    4.0000
>> --- end console output ---
>>
>> Now, please note the following:
>>
>> 1. extern "C" decoration of the C++ function.  If you seek portable
>> and simpler interoperation of C++ code with Fortran and thus seek to
>> use the standard facilities in Fortran, then note the interoperation
>> is between a Fortran processor and a companion C processor only.  It
>> is NOT with C++ directly.  In C++ code, you achieve the companion C
>> processor semantics via *extern "C"*.  Without *extern "C"*, you need
>> to look into the processor extensions and see how C++ and Fortran
>> might work that processor (e.g, GCC/gfortran system).  That is, if at
>> all they interoperate - note there is no standard Fortran here.
>>
>> 2. In Fortran code, look at the IMPORT statement in the INTERFACE
>> block.  Note an INTERFACE block in Fortran generally is stand-alone,
>> it has no knowledge of the host unit except for what it's informed.
>> In lieu of IMPORT, you can duplicate the USE statement in the
>> INTERFACE block, if you so choose.  I don't recommend it though.
>> Bottom-line: an IMPORT or USE is needed to inform the INTERFACE for
>> this MINI function what `c_double` is.
>>
>> 3. Consider using KINDs from ISO_C_BINDING module for the Fortran
>> objects that interoperate with the external procedures such as
>> `MINI`.  So note `arg` and `arg2` can both be declared as
>> real(c_double).  You can use renaming facility in Fortran to shorten
>> the kind name to `CD` or some such, if you prefer.
>>
>> By the way, have you considered studying from books closely such as
>> Chapman on Fortran 2008 and Modern Fortran Explained?  It appears you
>> will benefit yourself by doing so - you are getting stuck with very
>> basic semantics and syntax aspects of modern Fortran and you would do
>> well by putting aside a bit of time to read first to save yourself a
>> lot of time with debugging basic errors and engaging on online forums
>> seeking help to resolve them.
>
> Thank you, that worked, also with my original mini.cpp afterI commented
> out the first few lines
>
> #include <iostream>
> #include <fstream>
> #include <iomanip>
> #include "math.h"
> using namespace std;
>
> And I added your extern "C".
>
> I have never used C ++ so I just used what the original, much
> longer, C++ function code used, but these lines seem not to
> be needed. I must now implement all this with the actual
> function, trimmed appropriately.
>
> You might be right that I could study more modern Fortran but so
> far f90 has served me well. As for online fora, this is what they
> are for, aren't they? You have solved my problem. If everyone
> knew everything, there would be no need for this ng.

I might add that f90 was a major step, generic intrinsics, whole array
operations, self defined types and precisions. It simplified my
programming.

However, one more question. Your suggestions worked and I implemented
them for the actual long C++ function that is the object of all this.
I had given up on the original declarations of long double because
Fortran didn't seem to want to know it, and reduced the C++ code to
plain double, stating (c_double) in the Fortran calling program.
How do I specify, in the Fortran code, long double? It would be
equivalent to quad precision which I can ask for, 30 digits.

--
Dieter Britz

On Monday, October 2, 2023 at 2:53:14 AM UTC-7, db wrote:

(snip)

> However, one more question. Your suggestions worked and I implemented
> them for the actual long C++ function that is the object of all this.
> I had given up on the original declarations of long double because
> Fortran didn't seem to want to know it, and reduced the C++ code to
> plain double, stating (c_double) in the Fortran calling program.
> How do I specify, in the Fortran code, long double? It would be
> equivalent to quad precision which I can ask for, 30 digits.
C allows for long double to be the same as long.

Not much hardware supports a 30 digit floating point type.

(IBM successors to S/360, including z/architecture,
VAX H_float, IBM POWER9, support it in hardware.)

The Fortran compiler should have the constant C_LONG_DOUBLE,
but it will be a negative value is the companion C processor
doesn't support it. I think that means if isn't more than double.

You can:

PRINT *, C_LONG_DOUBLE

Some compilers support 30 digits in software emulation.

On Monday, October 2, 2023 at 5:53:14 AM UTC-4, db wrote:

> ..
> How do I specify, in the Fortran code, long double? It would be
> equivalent to quad precision which I can ask for, 30 digits. ..

@db,

Since you appear to be using the GCC/gfortran system, refer to their documentation - see a couple of links below, especially the last one:

https://gcc.gnu.org/onlinedocs/gfortran/index.html#SEC_Contents
https://gcc.gnu.org/onlinedocs/gfortran/index.html#toc-Mixed-Language-Programming-1
https://gcc.gnu.org/onlinedocs/gfortran/ISO_005fC_005fBINDING.html

So with the last link, you will notice GCC/gfortran processor provides you with at least two higher precision options: one toward `C long double` and another for `C _Float128`.

Then you can evaluate these two options in terms of precision as follows:

--- begin console output ---
C:\temp>type p.f
use, intrinsic :: iso_c_binding, only : LD => c_long_double, F128 => c_float128
print *, "Precision with C long double: ", precision(1.0_ld)
print *, "Precision with C _Float128: ", precision(1.0_f128)
end

C:\temp>gfortran -ffree-form p.f -o p.exe

C:\temp>l.exe
Precision with C long double: 18
Precision with C _Float128: 33
--- end console output ---

Which then informs you the `C long double`, as implemented in the GCC/gfortran, will yield a precision of 18 digits whereas `C _Float128` can give you 33. Note both are likely to be software emulations given no native hardware support for higher floating points types such as 128-bit - as pointed out to you by @gah4.

On 02.10.2023 22.30, FortranFan wrote:
> On Monday, October 2, 2023 at 5:53:14 AM UTC-4, db wrote:
>
>> ..
>> How do I specify, in the Fortran code, long double? It would be
>> equivalent to quad precision which I can ask for, 30 digits. ..
>
> @db,
>
> Since you appear to be using the GCC/gfortran system, refer to their documentation - see a couple of links below, especially the last one:
>
> https://gcc.gnu.org/onlinedocs/gfortran/index.html#SEC_Contents
> https://gcc.gnu.org/onlinedocs/gfortran/index.html#toc-Mixed-Language-Programming-1
> https://gcc.gnu.org/onlinedocs/gfortran/ISO_005fC_005fBINDING.html
>
> So with the last link, you will notice GCC/gfortran processor provides you with at least two higher precision options: one toward `C long double` and another for `C _Float128`.
>
> Then you can evaluate these two options in terms of precision as follows:
>
> --- begin console output ---
> C:\temp>type p.f
> use, intrinsic :: iso_c_binding, only : LD => c_long_double, F128 => c_float128
> print *, "Precision with C long double: ", precision(1.0_ld)
> print *, "Precision with C _Float128: ", precision(1.0_f128)
> end
>
> C:\temp>gfortran -ffree-form p.f -o p.exe
>
> C:\temp>l.exe
> Precision with C long double: 18
> Precision with C _Float128: 33
> --- end console output ---
>
> Which then informs you the `C long double`, as implemented in the GCC/gfortran, will yield a precision of 18 digits whereas `C _Float128` can give you 33. Note both are likely to be software emulations given no native hardware support for higher floating points types such as 128-bit - as pointed out to you by @gah4.

OK, thanks for clearing that up.
My friend, who wrote the C++ function I am calling from Fortran,
has now modified it so that it takes a plain double argument
and returns a plain double result, but internally uses long
double, thus preserving the original precision. This now
works, my Fortran function calls it succesfully.
Now I want to put it into the object library. Until now, I
have put functions and subroutines into it by first compiling
them using
gfortran -o x.o x.f90
and then using ar to stash x.o. Now I must compile both the
Fortran function and the C++ one it calls. I therefore tried
it with
> gfortran -o iband_double.o iband_double.cpp fortiband.f90

and got this error message

/usr/bin/ld:
/usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o: in
function `_start':
(.text+0x1b): undefined reference to `main'
collect2: error: ld returned 1 exit status

It seems that the compiler expects a main program, rather than
the job to make an object file. How do I convince it to do that?

--
Dieter Britz

db schrieb am Mittwoch, 4. Oktober 2023 um 13:55:45 UTC+2:
> On 02.10.2023 22.30, FortranFan wrote:
> > On Monday, October 2, 2023 at 5:53:14 AM UTC-4, db wrote:
> >
> >> ..
> >> How do I specify, in the Fortran code, long double? It would be
> >> equivalent to quad precision which I can ask for, 30 digits. ..
> >
> > @db,
> >

> it with
> > gfortran -o iband_double.o iband_double.cpp fortiband.f90
>
> and got this error message
>
> /usr/bin/ld:
> /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o: in
> function `_start':
> (.text+0x1b): undefined reference to `main'
> collect2: error: ld returned 1 exit status
>
> It seems that the compiler expects a main program, rather than
> the job to make an object file. How do I convince it to do that?
>
>
> --

There are several aspects here: you cannot compile both a C++ and a Fortran file at the same time,
you have to compile them separately with the C++ and Fortran, correspondingly. And then you link
them together, either into a shared library or an executable. For this is I usually take the C or C++
compiler (resp. its corresponding linker). Or you link the object files from C++ and Fortran code together
into a shared library. Alternatively you can use, as you mentioned, ar to create a static library.

On 04.10.2023 14.39, feanor wrote:
> db schrieb am Mittwoch, 4. Oktober 2023 um 13:55:45 UTC+2:
>> On 02.10.2023 22.30, FortranFan wrote:
>>> On Monday, October 2, 2023 at 5:53:14 AM UTC-4, db wrote:
>>>
>>>> ..
>>>> How do I specify, in the Fortran code, long double? It would be
>>>> equivalent to quad precision which I can ask for, 30 digits. ..
>>>
>>> @db,
>>>
>
>> it with
>>> gfortran -o iband_double.o iband_double.cpp fortiband.f90
>>
>> and got this error message
>>
>> /usr/bin/ld:
>> /usr/lib/gcc/x86_64-linux-gnu/11/../../../x86_64-linux-gnu/Scrt1.o: in
>> function `_start':
>> (.text+0x1b): undefined reference to `main'
>> collect2: error: ld returned 1 exit status
>>
>> It seems that the compiler expects a main program, rather than
>> the job to make an object file. How do I convince it to do that?
>>
>>
>> --
>
> There are several aspects here: you cannot compile both a C++ and a Fortran file at the same time,
> you have to compile them separately with the C++ and Fortran, correspondingly. And then you link
> them together, either into a shared library or an executable. For this is I usually take the C or C++
> compiler (resp. its corresponding linker). Or you link the object files from C++ and Fortran code together
> into a shared library. Alternatively you can use, as you mentioned, ar to create a static library.
>
>

Yeah, sorry, I realised that and they work now. Thank you all for your
patience and help.
--
Dieter Britz

On Wednesday, October 4, 2023 at 5:56:22 AM UTC-7, db wrote:

(snip)

> Yeah, sorry, I realised that and they work now. Thank you all for your
> patience and help.

Most important, you need the -c option.

Otherwise, it tries to compile and link the program.

And, confusingly, will name the result what you put in the -o option.

On Mon, 02 Oct 2023 13:30:26 -0700, FortranFan wrote:

>
> C:\temp>gfortran -ffree-form p.f -o p.exe
>
> C:\temp>l.exe
> Precision with C long double: 18
> Precision with C _Float128: 33
> --- end console output ---
>
> Which then informs you the `C long double`, as implemented in
> the GCC/gfortran, will yield a precision of 18 digits whereas
> `C _Float128` can give you 33. Note both are likely to be
> software emulations given no native hardware support for
> higher floating points types such as 128-bit - as pointed
> out to you by @gah4.

Wrong. If you have a c_long_double that return 18 as
in the above, then it is using Intel 80-bit extended
double. The gcc backend will use whatever hardward on
the CPU If you hardware supports 128-bit floating point,
then gcc/gfortran will use the hard support. On Intel
class hardware, there isn't 128-bit FPU support, so it
is emulated.

% cat a.f90
function foo(x)
use iso_c_binding, only : fp => c_long_double
real(fp) foo
real(fp), value :: x
foo = x + x
end function foo

% gfcx -S -O3 -march=native -mtune=native a.f90
% cat a.s
.file "a.f90"
.text
.p2align 5
.globl foo_
.type foo_, @function
foo_:
..LFB0:
.cfi_startproc
pushq %rbp
.cfi_def_cfa_offset 16
.cfi_offset 6, -16
movq %rsp, %rbp
.cfi_def_cfa_register 6
fldt 16(%rbp)
popq %rbp
.cfi_def_cfa 7, 8
fadd %st(0), %st
ret
.cfi_endproc
..LFE0:
.size foo_, .-foo_
.ident "GCC: (GNU) 14.0.0 20230812 (experimental)"
.section .note.GNU-stack,"",@progbits

HTH

--
steve