This may be a dumb question but what is "best practice" when coding
whole numbers in real (kind specified) formulas. I am looking for
accuracy, consistancy and prortability reagardless of what value dp
has below. Many of my calcs have numerical cancellations or accuracy
checks as per the error function below. What are the pitfalls?

for example:

integer, parameter :: dp = selected_real_kind(15, 307)

real(dp) :: x,xnew

real(dp), parameter :: one = 1.0_dp
real(dp), parameter :: onend = 1_dp
real(dp), parameter :: onenk = 1.0
real(dp), parameter :: onei = 1

! which should I use ?

10 error = one-xnew/x
20 error = onend-xnew/x
30 error = onenk-xnew/x
40 error = onei-xnew/x

! or the more ledgable ?

50 error = 1-xnew/x

dancerchris@earthlink.net wrote:

This form is hazardous, because 1_dp is an integer number with kind DP,
which may or may not be a proper integer kind.

On Jul 21, 2:20 pm, Craig Powers wrote:

Yes, thanks for reminding me, I have run into that issue already.

I still would like to understand what the best practice is. writing
global constants for whole numbers like 1 seems redundant.

dancerchris@earthlink.net wrote:

On Jul 21, 2:30 pm, Dick Hendrickson att.net> wrote:

On Jul 21, 2:49 pm, dancerch...@earthlink.net wrote:

It pretty much is. You will have no precision loss from expressing whole
numbers of "reasonable" magnitude in any actual compiler. It doesn't
matter whether you express it as a real or an integer, and it doesn't
matter what kind.

There are two cases where it does matter.

1. When you start doing operations. There is a big difference between
1/3.0 and 1/3.0d0. There is an even bigger difference between these and
1/3.

2. In procedure arguments, you must have the type and kind correct.
That's pretty much all there is to say about that. There is no single
type and kind that is always the best one. You just have to use the
correct one for the particular procedure in question.

dancerchris@earthlink.net wrote:
(snip)

On Jul 21, 3:27 pm, nos...@see.signature (Richard Maine) wrote:

Thanks RM. I do understand that a parameter has a constant value. My
question was the relationship of inline usage of a number like label
50 of my original post. Do compilers use the same value for multiple
use of an integer in an equation of specified kind

for example if I specify a constant:

real(dp), parameter :: one = 1.0_dp
real(dp) :: x,xnew,error

100 error = one-xnew/x+one
200 error = 1.0_dp-xnew/x+1.0_dp
300 error = 1-xnew/x+1