{"id":537,"date":"2018-11-20T09:41:42","date_gmt":"2018-11-20T09:41:42","guid":{"rendered":"https:\/\/books.compclassnotes.com\/elementarycomputing\/?page_id=537"},"modified":"2018-11-20T09:42:10","modified_gmt":"2018-11-20T09:42:10","slug":"using-conditionals-in-functions","status":"publish","type":"page","link":"https:\/\/books.compclassnotes.com\/elementarycomputing\/using-conditionals-in-functions\/","title":{"rendered":"Using Conditionals In Functions"},"content":{"rendered":"

We can use\u00a0IF<\/strong> to make decisions in our programs. Here we display either “pass” or “fail” depending on the grade that is passed to this function;<\/p>\n

(define pass?\r\n    (lambda (x)\r\n       (if (> = x 40) \"pass\" \"fail\")\r\n    )\r\n)\r\n<\/pre>\n
Notice the indentation of the brackets. This doesn’t change the functionality, but it makes it easier to read — another example of syntax versus semantics.\u00a0pass?<\/strong> takes one parameters and, if it is greater than or equal to 40, returns the word “pass”.<\/p>\n
Here’s a similar function. This one only returns\u00a0#t<\/strong> or\u00a0#f<\/strong>:<\/p>\n
(define pass2?\r\n    (lambda (x)\r\n       (if (> = x 40) #t #f)\r\n    )\r\n)\r\n\r\n> (pass? 30)\r\n\"fail\"\r\n> (pass2? 30)\r\n#f<\/pre>\n
Although it may seem like\u00a0pass?<\/strong> is more useful as it returns something readable by us humans, it turns out that it is actually\u00a0less<\/em> useful because of this.\u00a0pass2?\u00a0<\/strong>is what is known as\u00a0tightly coupled<\/em>, that is, all the instructions in it are related to one single task, in this case, testing the value passed in and returning\u00a0#t\u00a0<\/strong>or\u00a0#f<\/strong>. It is also\u00a0reusable<\/em>, which makes it a lot more useful than\u00a0pass2?<\/strong>. In fact, most of the functions we’ve looked at throughout this course, such as\u00a0sqr<\/strong>,\u00a0sqrt<\/strong>, etc. are tightly coupled and reusable. Remember how back in the section on lifetime diagrams<\/a> we said that defined variables and functions became part of the language? The reason that some of these are so useful is because they are reusable.<\/p>\n
There’s also a second problem with\u00a0pass?<\/strong>. Consider<\/p>\n
(if\r\n    (and (pass? 25) (pass? 60))\r\n       \"passed both\" \r\n       \"didn't pass both\")\r\n    )\r\n)\r\n<\/pre>\n
When we evaluate the calls to\u00a0pass?<\/strong> the\u00a0and<\/strong> part becomes:<\/p>\n
(and “fail” “pass”)<\/strong><\/p>\n
This is where we have a problem, because, as we saw in the previous section, all strings are considered true, and remember,\u00a0and<\/strong> returns the last true value it is given, otherwise it returns false. This means that it returns\u00a0“pass”<\/strong>, which is wrong. Look at this example; here everything works as we would expect, because\u00a0pass2?<\/strong> returns a Boolean value.<\/p>\n
(define passBoth\r\n    (lambda (x y)\r\n        (if \r\n           (and (pass2? x) (pass2? y)) \r\n           \"passed both\" \r\n           \"didn't pass both\")\r\n    )\r\n)\r\n<\/pre>\n
 <\/p>\n
Here’s the AST for this function. Notice how we have two @ nodes inside the predicate where we’re testing the conditions; this is because this is a function we wrote ourselves rather than a built in function.<\/p>\n
\"\"
Using pass2? inside another function<\/p><\/div>\n
Let’s look at another example:<\/p>\n
(define scrape\r\n    (lambda (x)\r\n        (if \r\n           (and (< x 45) (pass2? x)) \r\n           #t \r\n           #f)\r\n    )\r\n)\r\n<\/pre>\n
Here we reuse\u00a0pass2?<\/strong> again, combining with another test inside the body of the function to see if the grade was just barely a pass. Notice the difference in the AST — we still have @ for\u00a0pass2?<\/strong>, but not for the (< x 45)<\/strong> test.<\/p>\n
\"\"
Mixing built-in and user defined tests in the predicate<\/p><\/div>\n
 <\/p>\n
Here’s one more version of a function that tests if a grade is a pass. This one also returns a Boolean value but doesn’t even have an\u00a0IF<\/strong><\/p>\n
(define pass3?\r\n    (lambda (x)\r\n       (> = x 40) \r\n    )\r\n)\r\n\r\n<\/pre>\n
How does this one work? It evaluates\u00a0(>= x 40)<\/strong> which gives a Boolean, and simply returns that, so it’s much more efficient.<\/p>\n
Let’s look at one final example. We want to write a function called\u00a0high-odd<\/strong>, which returns true if a number is greater than 100 and is also odd.<\/p>\n
We could all this in one function, but let’s spread it out across two to make it easier to read. We’ll first check if the number is odd, and to do this we’ll use a built in Racket function called\u00a0integer?<\/strong> which returns\u00a0#t<\/strong> if its argument is an integer (a whole number with no decimal point) and returns\u00a0#f<\/strong> otherwise. Here’s our odd\u00a0<\/strong>function:<\/p>\n
(define odd\r\n  (lambda (x)\r\n    (not (integer? (\/ x 2)))\r\n    )\r\n  )\r\n<\/pre>\n
Satisfy yourself that you understand how it works. It divides the parameter (x<\/strong>) by 2 and, if x<\/strong> is odd then\u00a0integer?<\/strong> would return false (because odd numbers divided by two will have a decimal point), so we return the opposite of that using\u00a0not<\/strong> because our test should return true if\u00a0x<\/strong> is an odd number.<\/p>\n
(define high-odd\r\n  (lambda (x)\r\n    (and (> x 100) (odd x))\r\n    )\r\n  )\r\n\r\n(define high-odd2\r\n  (lambda (x)\r\n    (if (> x 100) (odd x) #f)\r\n    )\r\n  )\r\n<\/pre>\n
high-odd<\/strong> needs to do two tests; the first checks if\u00a0x<\/strong> is above 100 and the second that it is\u00a0an odd number. In fact, we’ve given two versions. The only difference is that\u00a0high-odd2<\/strong> will only call\u00a0odd<\/strong> if it actually needs to. Intuitively, this seems like a more efficient piece of code, after all, it seems like there will be less code executed, right? Actually, it turns out that\u00a0high-odd<\/strong> is more efficient, why? Remember how\u00a0and<\/strong> works — if it encounters a false value, it stops evaluating and returns that value, so if\u00a0x<\/strong> isn’t greater than 100, it doesn’t check if\u00a0x\u00a0<\/strong>is odd or not, because it doesn’t matter.<\/p>\n
However, if\u00a0x<\/strong> is greater than 100,\u00a0high-odd2<\/strong> makes another function call. This is a problem because it incurs\u00a0function overhead,\u00a0<\/em>that is, it takes time to set up its local variable, so it is slightly slower. This make very little difference when we’re only calling the function once, but if we were to call it a billion times, this would all add up.<\/p>\n
In the next section, when we create functions that will be called hundreds of times, we’ll see up close and personal just how much of a difference these extra function calls can have.<\/p>\n","protected":false},"excerpt":{"rendered":"
We can use\u00a0IF to make decisions in our programs. Here we display either “pass” or “fail” depending on the grade that is passed to this function; (define pass? (lambda (x) (if (> = x 40) “pass” “fail”) ) ) Notice Continue Reading<\/a><\/span><\/p>\n","protected":false},"author":4,"featured_media":0,"parent":0,"menu_order":0,"comment_status":"closed","ping_status":"closed","template":"","meta":{"footnotes":""},"class_list":["post-537","page","type-page","status-publish","hentry"],"_links":{"self":[{"href":"https:\/\/books.compclassnotes.com\/elementarycomputing\/wp-json\/wp\/v2\/pages\/537","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/books.compclassnotes.com\/elementarycomputing\/wp-json\/wp\/v2\/pages"}],"about":[{"href":"https:\/\/books.compclassnotes.com\/elementarycomputing\/wp-json\/wp\/v2\/types\/page"}],"author":[{"embeddable":true,"href":"https:\/\/books.compclassnotes.com\/elementarycomputing\/wp-json\/wp\/v2\/users\/4"}],"replies":[{"embeddable":true,"href":"https:\/\/books.compclassnotes.com\/elementarycomputing\/wp-json\/wp\/v2\/comments?post=537"}],"version-history":[{"count":5,"href":"https:\/\/books.compclassnotes.com\/elementarycomputing\/wp-json\/wp\/v2\/pages\/537\/revisions"}],"predecessor-version":[{"id":545,"href":"https:\/\/books.compclassnotes.com\/elementarycomputing\/wp-json\/wp\/v2\/pages\/537\/revisions\/545"}],"wp:attachment":[{"href":"https:\/\/books.compclassnotes.com\/elementarycomputing\/wp-json\/wp\/v2\/media?parent=537"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}