DO回路中的累加器

Question

我的目标是创建 10,000 个随机生成的 0 到 1 之间的数字，将它们组织成 0 到 1 之间均匀分布的十个箱，并计算每个箱的频率。这是我到目前为止的代码。

program listrand
implicit none
integer :: n,p
integer :: a,b,c,d,e,f,g,h,i,j = 0
real :: xran
!real, dimension(10,2) :: bin_and_freq -- list of bins and frequency
do n = 1,10000
    call random_number(xran)
            if (xran <  0.1) then
                a = a + 1
            elseif (xran>0.1 .and. xran<0.2) then
                b = b + 1
            elseif (xran>0.2 .and. xran<0.3) then
                c = c+1
            elseif (xran>0.3 .and. xran<0.4) then
                d = d+1
            elseif (xran>0.4 .and. xran<0.5) then
                e = e + 1
            elseif (xran>0.5 .and. xran<0.6) then
                f = f+1
            elseif (xran>0.6 .and. xran<0.7) then
                g = g+1
            elseif (xran>0.7 .and. xran<0.8) then
                h=h+1
            elseif (xran>0.8 .and. xran<0.9) then
                i=i+1
            else
                j = j+1
            endif
enddo
print *, a,b,c,d,e,f,g,h,i,j
end program listrand

我得到一个意外的输出： 988 1036 133225987 1004 934 986 1040 33770 1406729616 1052。

为什么c，h和i这么大？另外，有没有比使用我拥有的笨拙的 IF/ELSEIF 块更有效的方法？

Answer 1

在你的长

integer :: a,b,c,d,e,f,g,h,i,j = 0

您只是将j初始化为 0，所有其他数字中都有随机数。如果添加

a = 0
b = 0
c = 0
d = 0
e = 0
f = 0
g = 0
h = 0
i = 0
j = 0

在您的循环之前，一切正常。

至于如何简化：

这是我的程序版本：

program listrand
implicit none
integer, parameter :: nbins = 10
integer :: n, bin
integer :: bin_hits(nbins)   ! Number of bin hits
real :: xran
real :: bin_lower(nbins)     ! Lower edge of bins
                             ! bin_lower(1) == 0.0
bin_hits = 0
! Set up equidistant bins
bin_lower = [ (real(n-1) / nbins, n = 1, size(bin_lower)) ]
do n = 1,10000
    call random_number(xran)
    bin = count(bin_lower <= xran) 
    bin_hits(bin) = bin_hits(bin)+1
enddo
do n = 1, nbins-1
    print '(2(F6.2), I6)' bin_lower(n), bin_lower(n+1), bin_hits(n)
end do
print '(2(F6.2), I6)' bin_lower(nbins), 1.0, bin_hits(nbins)
end program listrand

对于要递增的bin_hits元素的索引，我正在计算bin_lower中实际上低于 xran 的值的数量。

编辑

我还想指出下面 High Performance Mark 的答案，他不是为每个值单独调用 RANDOM_NUMBER 来生成整个随机数数组。

此外，他利用箱是固定且等距的事实直接从随机值计算箱数，而不是像我的版本那样将其与每个箱进行比较。

这两者都使程序更快。

Answer 2

如果执行速度是一个人的主要关注点，并且如果一个人愿意用空间换取时间，这可能会吸引人：

PROGRAM listrand
  IMPLICIT NONE
  INTEGER, PARAMETER :: nbins = 10
  INTEGER, PARAMETER :: nsamples = 10**4
  INTEGER :: bin_hits(0:nbins-1)
  REAL :: xran(nsamples)
  INTEGER :: binned_rn(nsamples), n
  bin_hits = 0
  CALL RANDOM_NUMBER(xran)
  binned_rn = INT(nbins*xran)
  DO n = 1, nsamples
    bin_hits(binned_rn(n)) = bin_hits(binned_rn(n)) +1
  END DO
  WRITE(*,*) bin_hits
END PROGRAM listrand

在有限数量的测试中，此版本的速度是@chw21版本的3-4倍。