Richard Maine wrote:
>
> [log in to unmask] writes:
>  > What I would really like is a way to point a complex array at real and
>  > imaginary components, and vice-versa.  That would eliminate all data
>  > motion.  That was the game we could play in F77.  A real array with
>  > size 2*N could be passed to a subroutine and received as a complex
>  > array of size N.
>  >
>  > I cannot think of any legal way to do this in F90, but I wish it were
>  > possible.
>
> I cannot find anything in the f77 standard that allowed this.  In
> 15.6.2.3 of the f77 standard, I see
>
>   "The actual arguments in a subroutine reference must agree in order,
>    number, and type with the corresponding dummy arguments..."
>
> I can't see anywhere that an exception to this is mentioned.  You
> could presumably equivalence the real to a complex array (assuming
> that the real wasn't a dummy - because you can't equivalence to
> dummies) and then pass that real array, but I don't see anything that
> allows you to directly pass a real to a complex or vice versa.
> What you might have been able to get by with in many compilers is
> another question, but anything in this area that was legal in f77
> remains legal in f90.


Isn't there an "inconsistency" here ? I mean that on the one hand the standard requires a strict conformance between dummy and actual arguments, but on the other hand it ensures for example that a COMPLEX is made exactly of a sequence of 2 REALs (real/imaginary parts). So associating a actual REAL of size 2*N with a dummy COMPLEX of size N should be ensured to always work correctly (unless the compiler catch it), even if it violates the point 15.6.2.3, which is IMHO too restrictive.

Anyway, many of us were doing that in F77, and continue to do that in F90... Even if we have today large memories, the last thing we want to do with a 200MB REAL array (for example) is to duplicate it just to cast it to the COMPLEX type. Unfortunately, the f90 interfaces force us to do such copies.


I really thing that we need more intrinsics to handle at the langage level the REAL<->COMPLEX correspondance:

-- For data transfer, I pointed out that a single statement which would replace the two steps assignement (r(1::2)=Re(c(:)) ; r(2::2)=Aimag(c(:)) would be useful

-- For accessing the real and imaginary components:

The pointer solution re=>x(1::2) ; im=>x(2::2) can be useful in some situations, but it is very limitative:
* if performance is an issue, using pointers may be a problem
* It works only for a REAL target array (x), not for a COMPLEX one

It would be nice for example to be able to assign separately the real and imaginary components of a complex array  (something like c%Re(:) = ...)

-- But IMO the best solution would be to relax the standard and authorise the association between REAL and COMPLEX in the subroutine arguments (under of course some constraints).




Regards,


Pierre






--
-----------------------------------------------------------------------
Pierre Hugonnet          R&D Data Processing
COMPAGNIE GENERALE DE GEOPHYSIQUE - Paris Processing Centre
1, rue Leon Migaux / 91341 MASSY cedex / FRANCE
phone:(33) 164 47 45 59   fax:(33) 164 47 32 49
email:phugonnet(at)cgg.com  (replace (at) by @)
-----------------------------------------------------------------------
The opinions expressed in this message are not necessarily
those of CGG or of Jacques Chirac
-----------------------------------------------------------------------