https://DevOpsCloud.io -- Cloud Monk Losang Jinpa

Return to Teach Yourself COBOL in 24 Hours, COBOL bibliography, COBOL, COBOL DevOps, Awesome COBOL, Awesome IBM Mainframe, IBM Mainframe development, IBM Mainframe bibliography, Fortran

“ (TYCb24H 1998)

Hour 9 The Evaluate Statement

In computer programs, it is often necessary to determine which action to take based on a complex set of conditions. You may end up coding a significant number of If statements to handle these decisions. As you nest the If statements deeper and deeper, the code can become very confusing. If you have to come back later and change the program, you may find yourself spending a lot of time just trying to figure out what you were attempting to do with all those If statements.

COBOL comes equipped with a very versatile statement as an alternative to using complex, highly nested If statements. This statement is the Evaluate statement.

When to Use Evaluate After analyzing the decisions you need to make in your program, you will probably find that some conditions are very simple and can be handled with a single If statement. Others will be more complex. Evaluate is ideal for circumstances in which you want to execute different statements based on the value of a single data item. When more than two values are possible, you may find yourself coding multiple If statements or creating highly nested If structures.

You can use Evaluate to simplify the coding and to help keep your code clear and concise. Imagine that some of the consignment dealers in your antique store pay you a percentage of their sales. The percentage may vary from dealer to dealer, but you have instituted four commission plans. The first plan pays you 10% of every sale. The second pays you 20%, the third pays you 25%, and the final plan pays you nothing. For each sale, you must determine the plan being used and pay yourself the proper commission. Using If statements is one way to write the necessary code:

000040 If Commission-Plan = “A” 000041 Move 10 To Commission-Percent 000042 Else 000043 If Commission-Plan = “B” 000044 Move 20 To Commission-Percent 000045 Else 000046 If Commission-Plan = “C” 000047 Move 25 To Commission-Percent 000048 Else 000049 Move Zero To Commission-Percent 000050 End-If 000051 End-If 000052 End-If Another option is to code individual If statements for each commission plan, but that approach makes the last plan harder to test:

000053 If Commission-Plan = “A” 000054 Move 10 To Commission-Percent 000055 End-If 000056 If Commission-Plan = “B” 000057 Move 20 To Commission-Percent 000058 End-If 000059 If Commission-Plan = “C” 000060 Move 25 To Commission-Percent 000061 End-If 000062 If Commission-Plan Not = “A” And 000063 Commission-Plan Not = “B” And 000064 Commission-Plan Not = “C” 000065 Move Zeros To Commission-Percent 000066 End-If The Evaluate statement makes this situation much easier to write and understand:

000067 Evaluate Commission-Plan 000068 When “A” 000069 Move 10 To Commission-Percent 000070 When “B” 000071 Move 20 To Commission-Percent 000072 When “C” 000073 Move 25 To Commission-Percent 000074 When Other 000075 Move Zero To Commission-Percent 000076 End-Evaluate The Evaluate statement has only one basic format, but that format has many variations. The preceding code illustrates the simplest format, but conditions that are more complex can benefit from the use of the Evaluate statement as well.

Simple Evaluate Statements The code that immediately follows the word Evaluate defines what you are testing, or evaluating. You may evaluate an expression, a literal, or a data item, for a true condition, or for a false condition.

The code that follows the word When within the Evaluate statement does two things. First, it defines the circumstances under which the statements that follow are to be executed. Second, the statements after the When are those that are executed when the circumstances described by the evaluation of code after the word Evaluate, in conjunction with the code after the When, are evaluated against each other.

The text that follows the word Evaluate is defined as the selection subject. The text that follows the word When is defined as the selection object. As the Evaluate statement is executed, each selection object is evaluated against each selection subject. When the result of this evaluation is true, the statements after the When are executed. The evaluations occur in the order of the coded When items. After a subject and object are evaluated to be true, the statements after the When are executed and the processing of the Evaluate statement ends. Statements after the selection object are executed until the next selection object (When), End-Evaluate, or period, is encountered.

Image

A common mistake in using the Evaluate statement is to assume that once the statements coded after one When are executed, the other When statements continue to be evaluated. That is not so. After a When selection object is evaluated with the selection subject and the evaluation is determined to be true, no further selection objects are evaluated.

The extreme versatility of the Evaluate statement can lead to some confusion. Examine this example of two different ways to code an Evaluate that do the same thing. When the condition Data-Item-A = Data-Item-B is true, one thing is to be displayed, but when it’s not true, different text is to be displayed.

000061 Evaluate Data-Item-A = Data-Item-B 000062 When True 000063 Display “Items are Equal” 000064 When False 000065 Display “Items are not equal” 000066 End-Evaluate 000067 Evaluate True 000068 When Data-Item-A = Data-Item-B 000069 Display “Items are Equal” 000070 When Data-Item-A not = Data-Item-B 000071 Display “Items are not equal” 000072 End-Evaluate Note the use of the explicit scope terminator, End-Evaluate. I recommend that you always use this feature of the statement. The first of these statements uses the condition Data-Item-A = Data-Item-B as its subject. When such a condition is used as a selection subject, the only selection objects that make sense are True and False. This statement is equivalent to coding an If statement with an Else clause.

The second Evaluate uses True as its selection subject. The condition to be tested is then coded as a selection object. The second selection object is the opposite condition. The output of these two statements is the same.

Evaluate also offers a catchall selection object that is coded after the other selection objects. The statements that follow are always executed when no other selection objects are evaluated to be true with the selection subject. This is the selection object Other. In the preceding example, the second Evaluate could have used this selection object as follows:

000067 Evaluate True 000068 When Data-Item-A = Data-Item-B 000069 Display “Items are Equal” 000070 When Other 000071 Display “Items are not equal” 000072 End-Evaluate Other examples might be helpful in understanding how the Evaluate statement works. If you have a numeric data item and you want to perform different actions based on its value, using the Evaluate statement is an excellent choice. For example, you might pay a different commission based on the price of an item. The more expensive items in your store might pay a higher commission percentage.

000160 Evaluate Sale-Price 000161 When 1000 Thru 10000 000162 Move 50 To Commission-Percent 000163 When 500 Thru 1000 000164 Move 25 To Commission-Percent 000165 When 250 Thru 500 000166 Move 10 To Commission-Percent 000167 When Other 000168 Move 5 To Commission-Percent 000169 End-Evaluate There are several important considerations in how this Evaluate is coded. First, notice the order of the selection objects. If the sale price is $1,000, it seems as if the second selection object should be executed. It is not. The reason is that the first selection object is true for a sale price of $1,000, so the commission is moved, and no further selection objects are evaluated. Next, consider the size of the sale price field. The high range of $10,000 is chosen because the field is hypothetically defined as Pic 9(4)v99. If the field were larger, you would need a larger value in the first Thru. If the sale price field had a larger definition and a sale price greater than $10,000 is encountered, the commission would be paid at 5%. The logic flow within this Evaluate falls into the Other selection object.

Another method of coding this Evaluate statement follows. This method makes use of the True selection subject.

000160 Evaluate True 000161 When Sale-Price >= 1000 000162 Move 50 To Commission-Percent 000163 When Sale-Price >= 500 000164 Move 25 To Commission-Percent 000165 When Sale-Price >= 250 000166 Move 10 To Commission-Percent 000167 When Other 000168 Move 5 To Commission-Percent 000169 End-Evaluate In this second example, the order of the selection objects is very important. For example, if the >= 500 is coded first, the $1,000 items fall under that condition. Remember that the selection objects are evaluated against the selection subject one at a time, from the top of the Evaluate down.

More than one statement may be executed as part of the When. You might want to move the commission percentage to a display field and Compute the actual commission.

000170 Evaluate True 000171 When Sale-Price >= 1000 000172 Move 50 To Commission-Percent 000173 Compute Commission Rounded = Sale-Price * .5 000174 When Sale-Price >= 500 000175 Move 25 To Commission-Percent 000176 Compute Commission Rounded = Sale-Price * .25 000177 When Sale-Price >= 250 000178 Move 10 To Commission-Percent 000179 Compute Commission Rounded = Sale-Price * .1 000180 When Other 000181 Move 5 To Commission-Percent 000182 Compute Commission Rounded = Sale-Price * .05 000183 End-Evaluate This statement is the same as the prior example, with only the added computation.

Another situation in which you can use Evaluate is in separating names into groups based on the first letter of the last name. You might want to divide a mailing into three groups. Assume that you want last names starting with A through F in one group, G through N in the second, and the remaining letters in the third group.

000184 Evaluate Last-Name (1:1) 000185 When “A” Thru “F” 000186 Move 1 To Group-Id 000187 When “G” Thru “N” 000188 Move 2 To Group-Id 000189 When Other 000190 Move 3 To Group-Id 000191 End-Evaluate The use of the Other selection object is very important in this case. If the third selection object were coded as When “O” Thru “Z” instead and the first character of the name happened to contain invalid data, such as a number or a space, then no group would be assigned.

What about the circumstance when a range will not do? What if you wanted to group the last names based on the first letters, but not in consecutive groups? Perhaps the last names starting with vowels belong in one group, then those starting with B through J in the second, and the remaining names in the third group.

You may stack selection objects. If no statements follow the selection object, it is treated as part of the next selection object. Therefore, if any selection object evaluates with the selection subject to be true, the statements after the final stacked selection object are executed.

000192 Evaluate Last-Name (1:1) 000193 When “A” 000194 When “E” 000195 When “I” 000196 When “O” 000197 When “U” 000198 Move 1 To Group-Id 000199 When “B” Thru “J” 000200 Move 2 To Group-Id 000201 When Other 000202 Move 3 To Group-ID 000203 End-Evaluate In this example, any last name that starts with A, E, I, O, or U will be assigned a group of 1.

More Complex Evaluate Usage Like If statements, you may nest Evaluate statements. Subsequent Evaluate statements may be coded in the statements that appear after the selection objects. Consider the previous example in which the names were grouped based on the first letter of the last name. You might further subdivide the names based on the first letter of the first name. Consider this example, which divides the names into nine groups.

000204 Evaluate Last-Name (1:1) 000205 When “A” Thru “F” 000206 Evaluate First-Name (1:1) 000207 When “A” Thru “F” 000208 Move 1 To Group-Id 000209 When “G” Thru “N” 000210 Move 2 To Group-Id 000211 When Other 000212 Move 3 To Group-Id 000213 End-Evaluate 000214 When “G” Thru “N” 000215 Evaluate First-Name (1:1) 000216 When “A” Thru “F” 000217 Move 4 To Group-Id 000218 When “G” Thru “N” 000219 Move 5 To Group-Id 000220 When Other 000221 Move 6 To Group-Id 000222 End-Evaluate 000223 When Other 000224 Evaluate First-Name (1:1) 000225 When “A” Thru “F” 000226 Move 7 To Group-Id 000227 When “G” Thru “N” 000228 Move 8 To Group-Id 000229 When Other 000230 Move 9 To Group-Id 000231 End-Evaluate 000232 End-Evaluate The Evaluate statement can create complex decision-making structures. More than one selection subject may be used. If multiple selection subjects are used, the same number of items must be specified on the selection object (When) lines of the Evaluate statement.

This type of structure gives the Evaluate tremendous power. Multiple selection subjects and objects are separated with the word Also. Another possible value that can be checked as a selection object is Any. Any means that the evaluation evaluates to be true no matter what the value of the selection object. Consider another solution to coding the previous example.

000233 Evaluate Last-Name (1:1) Also First-Name (1:1) 000234 When “A” Thru “F” Also “A” Thru “F” 000235 Move 1 To Group-Id 000236 When “A” Thru “F” Also “G” Thru “N” 000237 Move 2 To Group-Id 000238 When “A” Thru “F” Also Any 000239 Move 3 To Group-Id 000240 When “G” Thru “N” Also “A” Thru “F” 000241 Move 4 To Group-Id 000242 When “G” Thru “N” Also “G” Thru “N” 000243 Move 5 To Group-Id 000244 When “G” Thru “N” Also Any 000245 Move 6 To Group-Id 000246 When Any Also “A” Thru “F” 000247 Move 7 To Group-Id 000248 When Any Also “G” Thru “N” 000249 Move 8 To Group-Id 000250 When Other 000251 Move 9 To Group-Id 000252 End-Evaluate Image

When creating complex Evaluate statements using multiple selection subjects, remember that Other is a catchall. You cannot code Other with any other selection object. Instead of using Other for an individual item when Also is used, the word Any is provided.

Try to follow the tests that are given in this example. For each selection object, both subjects must be evaluated with the selection objects. If all the different conditions evaluate to true, then the statements after the selection object line are executed.

Notice that the Other selection object is different from the other selection objects. In the other selection objects, the number of objects matches the number of selection subjects coded after the Evaluate statement.

Consider another example. In this example, a commission is calculated based on the price of the item sold. However, if the commission is less than $1, the commission is made $1 unless the sale amount is less than $1, in which case the commission is 75% of the total sale price. Under certain circumstances, the commission is limited to a maximum value.

These rules might seem complex, but this situation is typical in programming. The following Evaluate statement handles these conditions.

These are the rules:

• Items $1,000 and over earn a commission of 50%.

• Items $500 and over, but less than $1,000, earn a commission of 25%.

• Items $250 and over, but less than $500, earn a commission of 10%.

• Items less than $250 earn a commission of 5%.

• If the commission is less than $1, it is adjusted up to $1 unless the sale price is less than $1, in which case the commission is 75% of the sale price.

• For the items with the 50% commission, the maximum commission is $750.

• For the items with the 25% commission, the maximum commission is $150.

• For the items with the 10% commission, the maximum commission is $30.

• For the items with the 5% commission, there is no maximum commission.

First, try to find some conditions that can be isolated. The first is which of the four regular percentages to test for. Next, you need to know whether the commission is too high. The minimum $1 commission can occur only with the 5% rate plan, so a separate selection subject is not required. Instead, code an If statement under the appropriate selection object.

000160 Evaluate True Also True 000161 When Sale-Price >= 1000 Also Sale-Price * .5 > 750.00 000162 Move 750.00 To Commission-Amount 000163 When Sale-Price >= 1000 Also Any 000164 Compute Commission-Amount = Sale-Price * .5 000165 When Sale-Price >= 500 Also Sale-Price * .25 > 150.00 000166 Move 150.00 To Commission-Amount 000167 When Sale-Price >= 500 Also Any 000168 Compute Commission-Amount = Sale-Price * .25 000169 When Sale-Price >= 250 Also Sale-Price * .10 > 30.00 000170 Move 30.00 To Commission-Amount 000171 When Sale-Price >= 250 Also Any 000172 Compute Commission-Amount = Sale-Price * .10 000173 When Other 000174 Compute Commission-Amount = Sale-Price * .05 000175 If Commission-Amount < 1.00 000176 Move 1.00 To Commission-Amount 000177 End-If 000178 If Commission-Amount > Sale-Price 000179 Compute Commission-Amount = Sale-Price * .75 000180 End-If 000181 End-Evaluate The complex business rules for this example boil down to a straightforward and easy-to-follow Evaluate statement. Note how the test for each of the first three commission plans is repeated in the Evaluate. This approach allows the maximum to be checked in the first portion of the selection object, and the rest of the values to fall through the second selection object for each rate.

The two If statements under the Other selection object handle the problem of the minimum commission. The first makes sure that the minimum is applied, and the second makes sure that the commission does not exceed the sale price of the item. Note also how the mathematical expressions and condition tests are used. The Evaluate statement is checking two conditions for truth. The content of those conditions can easily be another condition or arithmetic statement.

One more example demonstrates how an Evaluate statement can simplify coding. Your store divides merchandise into categories. You have agreements with your vendors to put some items, but not all, within certain categories on sale during certain times of the year. The percentage off depends on that time of year. Some sale items are on sale at all times. The categories are

• ANTI - Antiques

• CRAF - Crafts

• HOLI - Holiday Items

• JEWL - Jewelry

• MISC - Miscellaneous

• XMAS - Christmas Items

Other categories do not have special time frames for their sales. They are discounted year-round if marked as sale items. The rules for the discount are

• Item must be a sale item.

• During January, February, and March, antiques, jewelry, and miscellaneous sale items are discounted 50%.

• During January, February, and March, Christmas and craft items are discounted 75%. All other sale items receive a 10% discount.

• During April, May, and June, Christmas and craft items are discounted 50%.

• During April, May, and June, antiques, jewelry, and miscellaneous sale items are discounted 25%. All other sale items receive a 10% discount.

• During July, August, and September, all items are discounted at 25%.

• During October, November, and December, antiques are discounted 50%, and all other items receive a 10% discount.

First, examine the code necessary to use nested If logic. Check this code carefully and follow it through different possible conditions. The columns are aligned for easier reading.

000160 If Sale-Item 000161 If Month-Of-Sale = 01 Or 02 Or 03 000162 If Category-Of-Sale = “ANTI” Or “JEWL” Or “MISC” 000163 Move 50 To Discount-Percent 000164 Compute Sale-Price = Full-Price * .5 000165 Else 000166 If Category-Of-Sale = “XMAS” Or “CRAF” 000167 Move 75 To Discount-Percent 000168 Compute Sale-Price = Full-Price * .25 000169 Else 000170 Move 10 To Discount-Percent 000171 Compute Sale-Price = Full-Price * .90 000172 End-If 000173 End-If 000174 Else 000175 If Month-Of-Sale = 04 Or 05 Or 06 000176 If Category-Of-Sale = “XMAS” Or “CRAF” 000177 Move 50 To Discount-Percent 000178 Compute Sale-Price = Full-Price * .5 000179 Else 000180 If Category-Of-Sale = “ANTI” Or “JEWL” Or “MISC” 000181 Move 25 To Discount-Percent 000182 Compute Sale-Price = Full-Price * .75 000183 Else 000184 Move 10 To Discount-Percent 000185 Compute Sale-Price = Full-Price * .90 000186 End-If 000187 End-If 000188 Else 000189 If Month-Of-Sale = 07 Or 08 Or 09 000190 Move 25 To Discount-Percent 000191 Compute Sale-Price = Full-Price * .75 000192 Else 000193 If Category-Of-Sale = “ANTI” 000194 Move 50 To Discount-Percent 000195 Compute Sale-Price = Full-Price * .5 000196 Else 000197 Move 10 To Discount-Percent 000198 Compute Sale-Price = Full-Price * .9 000199 End-If 000200 End-If 000201 End-If 000202 End-If 000203 Else 000204 Move Full-Price To Sale-Price 000205 End-If As you can see, this code accomplishes the task but is hard to read and follow. What if you had to add another condition later? What would you code to add a new set of months and a new discount type? Maintaining this program would be difficult.

Now examine the same problem solved with the Evaluate statement:

000208 Evaluate Sale-Item Also Month-Of-Sale Also Category-Of-Sale 000209 When True Also 1 Thru 3 Also “ANTI” 000210 When True Also 1 Thru 3 Also “JEWL” 000211 When True Also 1 Thru 3 Also “MISC” 000212 Move 50 To Discount-Percent 000213 Compute Sale-Price = Full-Price * .5 000214 When True Also 1 Thru 3 Also “XMAS” 000215 When True Also 1 Thru 3 Also “CRAF” 000216 Move 75 To Discount-Percent 000217 Compute Sale-Price = Full-Price * .25 000218 When True Also 1 Thru 3 Also Any 000219 Move 10 To Discount-Percent 000220 Compute Sale-Price = Full-Price * .9 000221 When True Also 4 Thru 6 Also “XMAS” 000222 When True Also 4 Thru 6 Also “CRAF” 000223 Move 50 To discount-Percent 000224 Compute Sale-Price = Full-Price * .5 000225 When True Also 4 Thru 6 Also “ANTI” 000226 When True Also 4 Thru 6 Also “JEWL” 000227 When True Also 4 Thru 6 Also “MISC” 000228 Move 25 To Discount-Percent 000229 Compute Sale-Price = Full-Price * .75 000230 When True Also 4 Thru 6 Also Any 000231 Move 10 To Discount-Percent 000232 Compute Sale-Price = Full-Price * .90 000233 When True Also 6 Thru 9 Also Any 000234 Move 25 To Discount-Percent 000235 Compute Sale-Price = Full-Price * .75 000236 When True Also 10 Thru 12 Also “ANTI” 000237 Move 50 To Discount-Percent 000238 Compute Sale-Price = Full-Price * .5 000239 When True Also 10 Thru 12 Also Any 000240 Move 10 To Discount-Percent 000241 Compute Sale-Price = Full-Price * .9 000242 When Other 000243 Move Full-Price To Sale-Price 000244 End-Evaluate The Evaluate statement coded here is much easier to follow than the earlier example but accomplishes the same task. It would be much easier to add a new set of months or a new category. In addition to those benefits, you can easily see where you have redundant code: 50%, 25%, and 10% discounts are applied in several places. You can easily reposition your When lines and reduce the code further.

000249 Evaluate Sale-Item Also Month-Of-Sale Also Category-Of-Sale 000250 When True Also 1 Thru 3 Also “ANTI” 000251 When True Also 1 Thru 3 Also “JEWL” 000252 When True Also 1 Thru 3 Also “MISC” 000253 When True Also 4 Thru 6 Also “XMAS” 000254 When True Also 4 Thru 6 Also “CRAF” 000255 When True Also 10 Thru 12 Also “ANTI” 000256 Move 50 To Discount-Percent 000257 Compute Sale-Price = Full-Price * .5 000258 When True Also 1 Thru 3 Also “XMAS” 000259 When True Also 1 Thru 3 Also “CRAF” 000260 Move 75 To Discount-Percent 000261 Compute Sale-Price = Full-Price * .25 000262 When True Also 4 Thru 6 Also “ANTI” 000263 When True Also 4 Thru 6 Also “JEWL” 000264 When True Also 4 Thru 6 Also “MISC” 000265 When True Also 6 Thru 9 Also Any 000266 Move 25 To Discount-Percent 000267 Compute Sale-Price = Full-Price * .75 000268 When True Also 1 Thru 3 Also Any 000269 When True Also 4 Thru 6 Also Any 000270 When True Also 10 Thru 12 Also Any 000271 Move 10 To Discount-Percent 000272 Compute Sale-Price = Full-Price * .9 000273 When Other 000274 Move Full-Price To Sale-Price 000275 End-Evaluate As you can see, the complex set of rules required to figure out the discounted price has become a fairly simple Evaluate statement.

Image

When you rearrange your selection objects (When lines) within an Evaluate statement, you must watch for Any clauses because they will always be evaluated to true. The Any items must appear after all prior selection objects have been tested. In the preceding example, notice where the 10% discount selection objects were moved.

Summary In this hour, you learned the following:

• The Evaluate statement can simplify and clarify the conditional logic of your program.

• The code immediately following the word Evaluate is the selection subject.

• The code following the When is the selection object.

• Only one set of statements is executed from within an Evaluate. After a selection object is evaluated with a selection subject and found true, the subsequent statements are executed. After that, processing of the Evaluate statement ends.

• Selection objects may be stacked so that if any one of them evaluates to true, the programming statements after the last stacked object are executed.

• Evaluate statements may be nested.

• Complex Evaluate statements may be used like decision tables for solving complex conditions. The word Also adds multiple selection subjects and selection objects.

• Evaluate statements, because of their simplicity and easy-to-read format, should be used instead of complex nested If statements.

Q&A Q What is one condition in which an Evaluate statement is a better choice than an If statement?

A When a data item is being tested for more than two possible values. For example, a State field could cause different actions in your program for every state. The nested If to handle this condition would be very deep and complex. Evaluate is a better choice.

Q If I want to execute some statements for more than one evaluated condition, do I have to code the statements over and over?

A No. You may stack your selection objects, and when any one of them is true, the statements after the last stacked object are executed.

Q Can I test several data items for different values in a single Evaluate statement?

A Yes. You have to make sure that the number of selection objects on each When line matches the number of selection subjects on the Evaluate line. The Other selection object is the only line in which this rule does not apply.

Q Can I nest Evaluate statements?

A Yes. Under a selection object, you may code another Evaluate statement.

Workshop To help reinforce your understanding of the material presented in this hour, refer to the section “Quiz and Exercise Questions and Answers” that can be found on the CD. This section contains quiz questions and exercises for you to complete, as well as the corresponding answers.

Fair Use Sources:

• B001FWIJGE (TYCb24H 1998)