cppds/pretext/Recursion/Glossary.ptx at b95fa78497dc24b705270447b9d9cc34dcb3c781 · pearcej/cppds · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
<section xml:id="recursion_glossary">
        <title>Glossary</title>
        <glossary sorted="False">

                <gi>
                    <title>base case</title>

                        <p>A branch of the conditional statement in a recursive function that does
                            not give rise to further recursive calls.</p>

                </gi>
                <gi>
                    <title>data structure</title>

                        <p>An organization of data for the purpose of making it easier to use.</p>

                </gi>
                <gi>
                    <title>dynamic programming</title>

                        <p>a way to solve complex problems by breaking it up, solving the smaller
                            portions, and storing the results to avoid re-calculating them.</p>

                </gi>
                <gi>
                    <title>exception</title>

                        <p>An error that occurs at runtime.</p>

                </gi>
                <gi>
                    <title>handle an exception</title>

                        <p>To prevent an exception from terminating a program by wrapping
                            the block of code in a <c>try</c> / <c>except</c> construct.</p>

                </gi>
                <gi>
                    <title>immutable data type</title>

                        <p>A data type which cannot be modified.  Assignments to elements or
                            slices of immutable types cause a runtime error.</p>

                </gi>
                <gi>
                    <title>infinite recursion</title>

                        <p>A function that calls itself recursively without ever reaching the base
                            case. Eventually, an infinite recursion causes a runtime error.</p>

                </gi>
                <gi>
                    <title>mutable data type</title>

                        <p>A data type which can be modified. All mutable types are compound
                            types.  Lists and dictionaries (see next chapter) are mutable data
                            types; strings and tuples are not.</p>

                </gi>
                <gi>
                    <title>raise</title>

                        <p>To cause an exception by using the <c>raise</c> statement.</p>

                </gi>
                <gi>
                    <title>recursion</title>

                        <p>The process of calling the function that is already executing.</p>

                </gi>
                <gi>
                    <title>recursive call</title>

                        <p>The statement that calls an already executing function.  Recursion can
                            even be indirect <mdash/> function <em>f</em> can call <em>g</em> which calls <em>h</em>,
                            and <em>h</em> could make a call back to <em>f</em>.</p>

                </gi>
                <gi>
                    <title>recursive definition</title>

                        <p>A definition which defines something in terms of itself. To be useful
                            it must include <em>base cases</em> which are not recursive. In this way it
                            differs from a <em>circular definition</em>.  Recursive definitions often
                            provide an elegant way to express complex data structures.</p>

                </gi>
                <gi>
                    <title>stack frame</title>

                        <p>a stack that contains a <q>frame</q> or group of data. For a call stack, this
                            would be a function and its arguments.</p>

                </gi>
                <gi>
                    <title>tuple</title>

                        <p>A data type that contains a sequence of elements of any type, like a
                            list, but is immutable. Tuples can be used wherever an immutable type
                            is required, such as a key in a dictionary (see next chapter).</p>

                </gi>
                <gi>
                    <title>tuple assignment</title>

                        <p>An assignment to all of the elements in a tuple using a single
                            assignment statement. Tuple assignment occurs in parallel rather than
                            in sequence, making it useful for swapping values.</p>

                </gi>

        </glossary>
        <conclusion><p>
            <!-- extra space before the progress bar -->
        </p></conclusion>
    </section>