recursie met de datastep

1
recursie met de datastep

• jeroen j van beele
• 1(1) april 2005

2

• kun je een programma schrijven dat zichzelf als
  output heeft?
• of in welke taal kun je dat doen?
• of waar moet een taal aan voldoen om zo'n
  programma in te kunnen schrijven?

3

• dat kun je leuk combineren met recursie een
  programma dat zichzelf schrijft en vervolgens ook
  inleest en uitvoert
• dan moeten we de omgeving van die programmeertaal
  een beetje schetsen
• denk aan de sas-program editor van waaruit je
  schrijft naar en leest van externe bestanden

4

• het kan bijvoorbeeld als de taal beschikt over de
  volgende twee opdrachten
• lees(ltbestandgt)
• schrijf(argument,ltbestandgt)
• waar schrijf is
• herhaalt zichzelf
• schrijft het argument naar ltbestandgt
• het programma zou er dan alsvolgt uitzien
• schrijf(lees(pgm),pgm))
• lees(pgm)

5

• kan dit in de datastep?
• dus kun je een datastep schrijven die zichzelf
  schrijft? en dan natuurlijk includen

6

1. filename rc000000 catalog "work.recurse.rc00000.so
   urce"
2. data _null_
3. file rc000000
4. / wat moet hier komen te staan? /
5. run
6. include rc000000

7

• weten jullie nog andere richtingen?
• het is een beetje ook de keuze die ik maak in de
  vraagstelling
• programma schrijft zichzelf, helemaal in de
  datastep, dus geen scl of macro's

8

1. filename rc000000 catalog "work.recurse.rc00000.so
   urce"
2. data _null_
3. file rc000000
4. put "filename rc000000 catalog
   ""work.recurse.rc00000.source"""
5. put "data _null_"
6. put "file recurs"
7. put "run"
8. put "include rc000000"
9. run
10. include rc000000

9

• dit houdt op, 2 ideeen
• put(quote)
• do-loop
• (3e toevalstreffer) schrijf in code eerst de stap
  die het einde wegschrijft en daarna het begin
• ik vind het moeilijk om uit te leggen waarom dit
  werkt

10

• het conceptuele schema is alsvolgt
• begincode
• put "begincode"
• deze code heeft als resultaat
• begincode
• maar
• put "begincode"
• mist in de uitvoer
• en put "begincode" kun je niet aan het argument
  begincode toevoegen want dan zit je conceptueel
  in een loop

11

• wat wel kan is put aan begincode toevoegen
• begincode
• put "begincode put"
• dan is het resultaat
• begincode
• put
• merk op dat dit resultaat het argument is van de
  put

12

• als we nu alleen maar het argument herhalen
  hebben we de hele code gereproduceerd
• begincode
• regel"begincode regel"
• put regel
• put quote(regel)
• resultaat
• 1e put schrijft regel weg, resultaat
• begincode
• regel
• 2e put voert quote(regel) uit, resultaat
• "begincode regel"
• samen is het resultaat
• begincode
• regel"begincode regel"

13

• dan hebben we die twee putstatements natuurlijk
  nog, maar die zijn aanzienlijk minder ingewikkeld
  dan die hele begincode
• en toen kwam de grote truc (het omdraaien van de
  schrijfvolgorde in de code) die ik bij toeval
  ontdekte en niet kan uitleggen (een beetje kan ik
  hem wel uitleggen de clou is dat je door het
  verwisselen niet in je eigen staart bijt)

14

1. filename rc000000 catalog "work.recurse.rc00000.so
   urce"
2. data _null_
3. file rc000000
4. do level0 to 1
5. if level then do
6. regel"lteindgt"
7. put regel
8. end
9. else do
10. regel"ltbegingt"
11. put regel
12. regelquote(trim(regel))
13. put regel
14. end
15. end
16. run
17. include rc000000

15

• begin loopt van het begin tot aan de beginquote
  van "ltbegingt"
• eind loopt van na de eindquote van "ltbegingt" tot
  het eind
• LET OP EERST moet je lteindgt substitueren en
  DAARNA ltbegingt
• de truc zit hem in de laatste (geschreven) put
  (die als middelste uitgevoerd wordt)
• als de datastep runt schrijft de middelste
  (geschreven) put eerst ltbegingt naar rc000000
• daarna schrijft de laatste put ltbegingt nog eens
  op maar dan als argument van de regel zodat de
  code t/m
• regel"ltbegingt"
• klaar is, op de na!
• die stoppen we dan aan het begin van lteindgt
• en dan zie je ook waarom de omwisseltruc werkt,
  want met die truc kunnen we lteindgt in zijn geheel
  in ltbegingt opnemen (als je EERST lteindgt
  substitueert en DAARNA ltbegingt)

16

• dan kom je in een oneindige loop,
• hoe kom je daar weer uit?
• de antwoorden vind je hieronder

17

1. filename rc000000 catalog "work.recurse.rc00000.so
   urce" lrecl1000
2. data _null_
3. length regel 1000
4. include_level1
5. put include_level
6. if include_level30 then put "stop"
7. else do put_level0 to 1
8. if put_level then do
9. regel"lteindgt"
10. put regel
11. end
12. else do
13. file rc000000
14. regel"ltbegingt"
15. put regel
16. regel"ltmiddengt"
17. put regel
18. regelquote(trim(regel))
19. put regel

18

• hoe diep kan sas includes nesten?
• om deze vraag te beantwoorden moet je de 30
  aanpassen in de code (of documentatie raadplegen
  natuurlijk)
• de eerste twee 30's doen niet terzake, die kun je
  weghalen (zie hieronder), de laatste is degene
  waar het om gaat
• die heb ik vervangen door een macrovariabele, dus

19

1. options noquotelenmax nosource nosource2 nonotes
2. let diepte30
3. filename rc000000 catalog "work.recurse.rc00000.so
   urce" lrecl1000
4. data _null_
5. length regel 1000
6. include_level1
7. put include_level
8. do put_level0 to 1
9. if put_level then do
10. regel"
11. put regel
12. regelquote(trim(regel))
13. put regel
14. end
15. end
16. run
17. include rc"put(include_level,z6.)""
18. put regel
19. end

20

1. data _null_
2. length regel 1000
3. include_level"put(include_level1,6.)"
4. put include_level
5. do put_level0 to 1
6. if put_level then do
7. regel""
8. put regel
9. regelquote(trim(regel))
10. put regel
11. end
12. end
13. run
14. include rc""put(include_level,z6.)""""
15. put regel
16. end
17. else do
18. file rc"put(include_level,z6.)""
19. put regel

21

1. data _null_
2. length regel 1000
3. include_level""put(include_level1,6.)""
4. put include_level
5. if include_leveldiepte then put
   """"stop""""
6. else do put_level0 to 1
7. if put_level then do
8. regel""""
9. put regel
10. regelquote(trim(regel))
11. put regel
12. end
13. end
14. run
15. include rc""""put(include_level,z6.)""""""""
    
16. put regel
17. end
18. else do
19. file rc""put(include_level,z6.)""""
    

22

• options noquotelenmax nosource nosource2 nonotes
• let diepte30
• filename rc000000 catalog "work.recurse.rc00000.so
  urce" lrecl1000
• data _null_
• length regel 1000
• include_level1
• put include_level
• do put_level0 to 1
• if put_level then do
• regel"
• put regel
• regelquote(trim(regel))
• put regel
• end
• end
• run
• include rc"put(include_level,z6.)""
• put regel
• end

• options noquotelenmax nosource nosource2 nonotes
• let diepte30
• filename rc000000 catalog "work.recurse.rc00000.so
  urce" lrecl1000
• data _null_
• length regel 1000
• include_level1
• put include_level
• do put_level0 to 1
• if put_level then do
• regel"
• put regel
• regelquote(trim(regel))
• put regel
• end
• end
• run
• include rc"put(include_level,z6.)""
• put regel
• end