An Extended Histogram Program

Problem Statement

Suppose there are n score values x₁, x₂, ..., x_n. We want to know extend the previous by (1) making the range as an input, and (2) printing a vertical bar type histogram.

Since the range may be different from examination to examination, treating it as an input would make our program more flexible. The following is a typical input format:

15
78  95  68  85  55
88  82  75  63  90
85  76  82  40  68
 4
60  70  80  90

The first set of input values consists of 15 (the number of scores) followed by fifteen scores. Then, the next value 4 gives the number of range division points followed the actual values. In the above, there are five ranges [0,59], [60,69], [70,79], [80,89], [90,100].

The bar of the generated histogram should be printed vertically. In the above score values, there are 2 scores in [0,59], 3 in [60,69], 3 in [70,79], 5 in [80,89] and 2 in [90,100]. Therefore, the histogram should look like the following:

 +---+---+---+---+---+
 |            ***    |
 |            ***    |
 |    *** *** ***    |
 |*** *** *** *** ***|
 |*** *** *** *** ***|
 +---+---+---+---+---+

Solution

Here is the module for counting and histogram printing:

! --------------------------------------------------------------------
! MODULE  Histogram_and_Count:
!    This module implements the counting and histogram printing.  Note
! that for the counting part, handled by subroutine Distribute(), two
! more arguments for the range array and its number of entries.  The
! Plot() subroutine now prints a vertical bar histogram.
! --------------------------------------------------------------------

MODULE  Histogram_and_Count
   IMPLICIT  NONE

CONTAINS

! --------------------------------------------------------------------
! SUBROUTINE  Distribute() :
!    This subroutine receives a score array and a range array, counts
! the number of each scores in each range, and calls Plot() to print
! a histogram.
! --------------------------------------------------------------------

   SUBROUTINE  Distribute(X, N, Range, M)
      IMPLICIT NONE
      INTEGER, DIMENSION(1:), INTENT(IN) :: X     ! input score
      INTEGER, INTENT(IN)                :: N     ! # of scores
      INTEGER, DIMENSION(1:), INTENT(IN) :: Range ! range array
      INTEGER, INTENT(IN)                :: M     ! # of ranges
      INTEGER                            :: i, j  
      INTEGER, DIMENSION(1:M+1)          :: Bucket! counting bucket

      DO i = 1, M+1                     ! clear buckets
         Bucket(i) = 0
      END DO

      DO i = 1, N                       ! for each input score
         DO j = 1, M                    ! determine the bucket
            IF (X(i) < Range(j)) THEN
               Bucket(j) = Bucket(j) + 1
               EXIT
            END IF               
         END DO                         ! don't forget the last bucket
         IF (X(i) >= Range(M))  Bucket(M+1) = Bucket(M+1)+1
      END DO
      CALL  Plot(Bucket, M+1)           ! print a histogram
   END SUBROUTINE  Distribute

! --------------------------------------------------------------------
! SUBROUTINE  Plot() :
!    This subroutine receives a counting array and prints a vertical
! bar histogram.
! --------------------------------------------------------------------

   SUBROUTINE  Plot(Count, K)
      IMPLICIT NONE
      INTEGER, DIMENSION(1:), INTENT(IN) :: Count
      INTEGER, INTENT(IN)                :: K
      CHARACTER(LEN=4), DIMENSION(1:K)   :: Line
      CHARACTER(LEN=4), PARAMETER        :: Division  = "---+"
      CHARACTER(LEN=4), PARAMETER        :: Empty     = "    "
      CHARACTER(LEN=4), PARAMETER        :: EmptyLast = "   |"
      CHARACTER(LEN=4), PARAMETER        :: Data      = "*** "
      CHARACTER(LEN=4), PARAMETER        :: DataLast  = "***|"
      INTEGER                            :: i, j, Maximum

      Maximum = Count(1)                ! find the maximum of the count
      Line(1) = Division                ! clear the print line
      DO i = 2, K
         Line(i) = Division
         IF (Maximum < Count(i))  Maximum = Count(i)
      END DO

      WRITE(*,*) "Histogram:"
      WRITE(*,*)
      WRITE(*,*) "+", (Line(j), j=1,K)  ! print the top border
      DO i = Maximum, 1, -1             ! print from the top
         DO j = 1, K                    ! for each count value
            IF (Count(j) >= i) THEN     !   if >= current value, show ***
               IF (j == K) THEN         !     if this is the last bar
                  Line(j) = DataLast    !       use "***|"
               ELSE                     !     otherwise
                  Line(j) = Data        !       use "*** "
               END IF
            ELSE                        !   if < current value , don't show
               IF (j == K) THEN         !     if this is the last bar
                  Line(j) = EmptyLast   !       use "   |"
               ELSE                     !     otherwise
                  Line(j) = Empty       !       use "    "
               END IF
            END IF
         END DO
         WRITE(*,*) "|", (Line(j), j=1,K)    ! all done.  display this line
      END DO

      DO j = 1, K                       ! prepare and display the lower border
         Line(j) = Division
      END DO
      WRITE(*,*) "+", (Line(j), j=1,K)
   END SUBROUTINE  Plot

END MODULE  Histogram_and_Count

Click here to download this module.

Here is a simple main program:

! --------------------------------------------------------------------
! PROGRAM  Score_Distribution:
!    Give a set of scores, this program plots a histogram showing the
! number of score in the range of [0,59], [60,69], [70,79], [80,89]
! and [90,100].  The range values (i.e., 60, 70, 80 and 90) are read
! in as input data.  The counting and printing subroutines are moved
! to module Histogram_and_Count in file histo-2m.f90.
! --------------------------------------------------------------------

PROGRAM  Score_Distribution
   USE  Histogram_and_Count
   IMPLICIT   NONE
   INTEGER, PARAMETER         :: SIZE = 20   ! array size
   INTEGER, DIMENSION(1:SIZE) :: Score       ! array containing scores
   INTEGER                    :: ActualSize  ! the # of scores read in
   INTEGER, PARAMETER         :: RANGE_SIZE = 10  ! score range size
   INTEGER, DIMENSION(1:RANGE_SIZE) :: Range ! range of scores
   INTEGER                    :: ActualRange
   INTEGER                    :: i

   READ(*,*)  ActualSize, (Score(i), i = 1, ActualSize)
   WRITE(*,*) "Input Scores:"
   WRITE(*,*) (Score(i), i = 1, ActualSize)
   WRITE(*,*)

   READ(*,*)  ActualRange, (Range(i), i = 1, ActualRange)
   WRITE(*,*) "Input Range:"
   WRITE(*,*) (Range(i), i = 1, ActualRange)
   WRITE(*,*)

   CALL  Distribute(Score, ActualSize, Range, ActualRange)

END PROGRAM  Score_Distribution

Click here to download this program.

Program Input and Output

If the input data consist of the following:

15
78  95  68  85  55
88  82  75  63  90
85  76  82  40  68
 4
60  70  80  90

The output of the program is:

 Input Scores:
 78,  95,  68,  85,  55,  88,  82,  75,  63,  90,  85,  76,  82,  40,  68

 Input Range:
 60,  70,  80,  90

 Histogram:

 +---+---+---+---+---+
 |            ***    |
 |            ***    |
 |    *** *** ***    |
 |*** *** *** *** ***|
 |*** *** *** *** ***|
 +---+---+---+---+---+

Discussion

The main program is simple and does not require further explanation.
In subroutine Distribute() (in module Histogram_and_Count), the count in each range is stored in a local array Bucket():
```
INTEGER, DIMENSION(1:M+1) :: Bucket
```
Here, M is the number of range division points. But, the number of ranges should be one higher than the number of division points. This is why Bucket() has an extent 1:M+1 rather than 1:M.
Each score value X(i) is compared with the range division points (i.e., Range(1), ..., Range(M)). If X(i) is less than Range(j), then one is added to Bucket(j). However, we need to to do one more step. Since X(i) could be larger than all range division points, in this case, Bucket(M+1) should be increased by one and this is the job of the last IF statement in subroutine Distribute().
After counting is completed, Plot() is called to print a histogram. Note that M+1 is passed to Plot(), since M+1 is the actual number of elements in array Bucket().
Subroutine Plot() is rather complicated. Note that array Count() is associated with array Bucket() of subroutine Distribute() and K is associated with M+1.
This subroutine has a local array Line(), which is a CHARACTER array of K entries and each entry can hold a string of length 4. This array is used for composing a line before it is printed.
The top and bottom border lines are simple. They are composed from a sequence of "---+". Therefore, we make this constant string a PARAMETER with name Division.
On each line, a position of a vertical bar is either " " or a "*** ". They are give PARAMETER names Empty and Data, respectively. Note that there is a space between two vertical bar and this is why Empty and Data are ended with a space. However, the last bar is different. It is ended with a "|". Thus, we define " |" and "***|" to be PARAMETER with names EmptyLast and DataLast.
The program logic of Plot() is actually simple. We intend to print the vertical bars from top to bottom. For each line, we need to know if a particular bar should be printed. If a bar is higher than the current line, then Data is printed; otherwise, Empty is printed. Of course, we have to be careful when printing the last bar. We shall return to this later on. To print vertical bars this way, we need to know the maximum of the counts. This is the job of the first DO. After this DO completes, Maximum holds the maximum count and, as a byproduct, Line contains the top border line.
After printing the top border line, we use a count-down DO so that the successive values of i are Maximum, Maximum-1, 4, 3, 2, and 1. Therefore, the value of i is the height of the current vertical bar.
Now, when the value of i is fixed, if a counting value is larger than or equal to i, that means the vertical of for this count is taller than i and hence a Data should be printed; otherwise, a Empty is required. However, we do not print the bar directly. Instead, these marks are stored into the CHARACTER array so that the complete line can be printed after the line is completely constructed.
Before we can put Data or Empty into the position of Line(), we need to know if this is the last bar (i.e., j is equal to k). If this is the last bar, then we should use DataLast and EmptyLast rather than Data and Empty.
After a line is constructed completely (i.e., all bar elements are in their places), it is printed. The last DO is for constructing and printing the bottom border line.