Introduction to Computational Linguistics

More documents

Recommendations

Info

4. Function Definitions 12 Indeed, to know the value of f (0) = 0 + y you just look up y. The value of f (n + 1) := (s(n)) + y is defined using the value f (n) = n + y. Just take that value and add 1 (that is, form the successor). The principle of recursion is widespread and can be used in other circumstances as well. For example, a function can be defined over strings by recursion. What you have to do is the following: you say what the value is of the empty string, and then you say what the value is of f (⃗x ⌢ a) on the basis of f (⃗x), where ⃗x is a string variable and a a letter. Likewise, functions on lists can be defined by recursion. Now, in OCaML there is no type of natural numbers, just that of integers. Still, definitions by recursion are very important. In defining a function by recursion you have to tell OCaML that you intend such a definition rather than a direct definition. For a definition by recursion means that the function calls itself during evaluation. For example, if you want to define exponentiation for numbers, you can do the following: (31) let rec expt n x if x = 0 then 1 else n * (expt n (x-1));; Type this and then say expt 2 4 and OCaML replies: (32) - : int = 16 As usual, recursions need to be grounded, otherwise the program keeps calling itself over and over again. If the definition was just given for natural numbers, there would be no problem. But as we have said, there is no such type, just the type of integeres. This lets you evaluate the function on arguments where it is not grounded. In the present example negative numbers let the recursion loop forever. This is why the above definition is not good. Negative arguments are accepted, but never terminate (because the value on which the recursion is based is further removed from the base, here 0). The evaluation of expt 2 -3 never terminates. Here is what happens: (33) # expt 2 (-3);; Stack overflow during evaluation (looping recursion?) One way to prevent this is to check whether the second argument is negative, and then rejecting the input. It is however good style to add a diagnostic so that you
5. Modules 13 can find out why the program rejects the input. To do this, OCaML lets you define so–called exceptions. This is done as follows. (34) exception Input_is_negative;; Exceptions always succeed, and they succeed by OCaML typing their name. So, we improve our definition as follows. (35) let rec expt n x if x < 0 then raise Input_is_negative else if x = 0 then 1 else n * (expt n (x-1)) ;; Now look at the following dialog: (36) # expt 2 (-3) Exception: Input_is_negative Thus, OCaML quits the computation and raises the exception that you have defined (there are also inbuilt exceptions). In this way you can make every definition total. Recursive definitions of functions on strings or lists are automatically grounded if you include a basic clause for the value on the empty string or the empty list, respectively. It is a common source of error to omit such a clause. Beware! However, recursion can be done in many different ways. For strings, for example, it does not need to be character by character. You can define a function that takes away two characters at a time, or even more. However, you do need to make sure that the recursion ends somewhere. Otherwise you will not get a reply. 5 Modules Modules are basically convenient ways to package the programs. When the program gets larger and larger, it is sometimes difficult to keep track of all the names and identifiers. Moreover, one may want to identify parts of the programs that
Page 1 and 2: Introduction to Computational Lingu
Page 3 and 4: 2. Practical Remarks Concerning OCa
Page 5 and 6: 3. Welcome To The Typed Universe 5
Page 11: 4. Function Definitions 11 4 Functi
Page 15 and 16: 5. Modules 15 let length l = length
Page 17 and 18: 6. Sets and Functors 17 write it do
Page 19 and 20: 7. Hash Tables 19 to actually see t
Page 21 and 22: 8. Combinators 21 can be used on an
Page 23 and 24: 9. Objects and Methods 23 of type
Page 25 and 26: 10. Characters, Strings and Regular
Page 31 and 32: 11. Interlude: Regular Expressions
Page 37 and 38: 12. Finite State Automata 37 Suppos
Page 39 and 40: 12. Finite State Automata 39 There
Page 41 and 42: 12. Finite State Automata 41 The pr
Page 43 and 44: 12. Finite State Automata 43 Proof.
Page 45 and 46: 13. Complexity and Minimal Automata
Page 51 and 52: 14. Digression: Time Complexity 51
Page 53 and 54: 14. Digression: Time Complexity 53
Page 55 and 56: 15. Finite State Transducers 55 Con
Page 57 and 58: 15. Finite State Transducers 57 And
Page 59 and 60: 16. Finite State Morphology 59 Then
Page 61 and 62: 17. Using Finite State Transducers
Page 63 and 64:
17. Using Finite State Transducers
Page 65 and 66:
17. Using Finite State Transducers
Page 67 and 68:
18. Context Free Grammars 67 18 Con
Page 69 and 70:
18. Context Free Grammars 69 symbol
Page 71 and 72:
18. Context Free Grammars 71 which
Page 73 and 74:
19. Parsing and Recognition 73 Z
Page 75 and 76:
19. Parsing and Recognition 75 numb
Page 77 and 78:
20. Greibach Normal Form 77 The red
Page 79 and 80:
20. Greibach Normal Form 79 Definit
Page 81 and 82:
20. Greibach Normal Form 81 Proposi
Page 83 and 84:
20. Greibach Normal Form 83 nonterm
Page 85 and 86:
21. Pushdown Automata 85 pushdown.
Page 87 and 88:
21. Pushdown Automata 87 machine is
Page 89 and 90:
22. Shift-Reduce-Parsing 89 differe
Page 91 and 92:
23. Some Metatheorems 91 If the loo
Page 93 and 94:
23. Some Metatheorems 93 This proof
Page 95 and 96:
23. Some Metatheorems 95 a decompos
show all

Introduction to Computational Linguistics

Create successful ePaper yourself

Delete template?

Save as template?