Re: Back with recursion in COBOL again!

Hello Roman,

                pain of giving such an elaborate solution.
                It really worked!

                Thanks for the Enlightenment!
Regards,
s.chand

---------------------------------------------------------------------------------------------------
------------------------------------------------------------------------------------------------------

Here is better example for factorial, more likely to factorial's pseudo(python)code

# factorial
def factorial(n):

 if n == 0:
   result = 1
 else:
   result = n * factorial(n-1)
 return result

I coded it in COBOL as follows

      IDENTIFICATION DIVISION.
      PROGRAM-ID. FACTORIAL RECURSIVE.
      ENVIRONMENT DIVISION.
      CONFIGURATION SECTION.
      SOURCE-COMPUTER. IBM-AS400.
      OBJECT-COMPUTER. IBM-AS400.
      DATA DIVISION.
      WORKING-STORAGE SECTION.
      01 RESULT       PIC 9(20).
      01 CALL-RESULT  PIC 9(20).
      01 N-MINUS-1    PIC 9(4).
      LINKAGE SECTION.
      01 N            PIC 9(4).

      PROCEDURE DIVISION USING BY VALUE N RETURNING RESULT.
          IF N = 0
             COMPUTE RESULT = 1
          ELSE
             COMPUTE N-MINUS-1 = N - 1
             CALL PROCEDURE 'FACTORIAL'
                  USING BY VALUE N-MINUS-1
                  RETURNING INTO CALL-RESULT
             COMPUTE  RESULT = N * CALL-RESULT
          END-IF.
          GOBACK.

note that I'm using calling by value n

the caller program is here

      IDENTIFICATION DIVISION.
      PROGRAM-ID. RECURTEST.
      ENVIRONMENT DIVISION.
      CONFIGURATION SECTION.
      SOURCE-COMPUTER. IBM-AS400.
      OBJECT-COMPUTER. IBM-AS400.
      SPECIAL-NAMES.
      DATA DIVISION.
      WORKING-STORAGE SECTION.
      01 N           PIC 9(4).
      01 RESULT      PIC 9(20).
      LINKAGE SECTION.
      PROCEDURE DIVISION.
          PERFORM VARYING N FROM 0 BY 1 UNTIL N = 21
            CALL PROCEDURE 'FACTORIAL'
                 USING BY VALUE N
                 RETURNING INTO RESULT
            DISPLAY N "! = " RESULT
          END-PERFORM.
      GOBACK.


now compile the FACTORIAL module, e.g.:
CRTCBLMOD MODULE(EBKPGMP/FACTORIAL) SRCFILE(RM/CBLJAVASRC)
SRCMBR(FACTORIAL)
DBGVIEW(*SOURCE)

create service program TMPPROC, e.g.:
CRTSRVPGM SRVPGM(EBKPGMP/TMPPROC) MODULE(EBKPGMP/FACTORIAL)
EXPORT(*ALL)

compile the RECURTEST module, e.g:
CRTCBLMOD MODULE(EBKPGMP/RECURTEST) SRCFILE(RM/CBLJAVASRC)
SRCMBR(RECURTEST)
DBGVIEW(*SOURCE)

and create the program RECURTEST with entry module RECURTEST linking it
with the saervice program TMPPROC, e.g:
CRTPGM PGM(EBKPGMP/RECURTEST)
ENTMOD(EBKPGMP/RECURTEST) BNDSRVPGM(EBKPGMP/TMPPROC)

Finally by calling that program CALL RECURTEST you will obtain these
results:

    0000! = 00000000000000000001
    0001! = 00000000000000000001
    0002! = 00000000000000000002
    0003! = 00000000000000000006
    0004! = 00000000000000000024
    0005! = 00000000000000000120
    0006! = 00000000000000000720
    0007! = 00000000000000005040
    0008! = 00000000000000040320
    0009! = 00000000000000362880
    0010! = 00000000000003628800
    0011! = 00000000000039916800
    0012! = 00000000000479001600
    0013! = 00000000006227020800
    0014! = 00000000087178291200
    0015! = 00000001307674368000
    0016! = 00000020922789888000
    0017! = 00000355687428096000
    0018! = 00006402373705728000
    0019! = 00121645100408832000
    0020! = 02432902008176640000

So, from the above example it follows, that using modules and service programs the recursion in ILE COBOL is possible in the similar manner as in the other languages.

Roman

_________________________________________________________________