So a PURE example would start: pure function double_it(x)

Correct!

I'm excited to try this elemental feature. Could be handy. Thank you.

I'll look for the PURE and ELEMENTAL designations but if you have the time, could you please point me in the direction to look for them.

There's a simple writeup of elemental functions here.  Essentially, the function accepts and returns a scalar value, but, since it is marked elemental, you can just pass an array to the function, and the function will be called on each element of said array, returning another array where every value is the return value from the function for its corresponding input element. 

For example, we can write a trivial elemental function that doubles a number:

elemental function double_it(x)
implicit none

    real::double_it
    real, intent(in)::x
    
    double_it = 2.0*x
    
end function double_it

Now, in our calling routine, we could have this:

    real, dimension(4)::x
    real, dimension(4)::doubled_x
    
    x = (/ 1.0, 2.0, 3.0, 4.0 /)
    
    doubled_x = double_it(x)
    
    print *, doubled_x

The output would be:

   2.00000000       4.00000000       6.00000000       8.00000000

Even though my function only accepts a scalar, the elemental modifier means that it will call it for each and every array element if I pass it an array.

We removed the option entirely since Apple decided to change how it reports the name of their chips, which wasn't compatible with our compiler at this time.  You shouldn't need to access that option any longer.  I believe the latest build also disables the option when creating the makefile as a safety precaution.

I'll look for the PURE and ELEMENTAL designations but if you have the time, could you please point me in the direction to look for them. Before this last update, for another problem, you had me change a compiler setting from Native to Generic.

I don't see that compiler setting (Native vs Generic) in the latest Apple Silcone release (Version 3.41, Build 4440).

Fortran doesn't have a general way to force a function to be inlined, though.  However, if you mark your function as PURE in Fortran, it can improve the optimizations that the compiler can perform.  The PURE modifier basically tells the compiler that your function takes exactly the inputs provided and outputs exactly one value without any side effects (like printing or changing an input).

If you have an array of values to convert, you can even mark your function as ELEMENTAL and pass the entire array at once, allowing the compiler to further optimize the procedure and calling it however it would like.

Basically, though, I would keep the conversion in a function.  The cost of one call, even one million times, just isn't measurable.

I don't know what the compiler does with that. By calling the function, I'm adding overhead. But making the functional "tool" makes the program more tidy.  If we are talking about and execution difference in seconds or a minute for the whole loop to process the function call, I can live with that and a "cleaner" program. But if it adds 10 minutes, I'd leave the code in the main area.