#lang eopl
(define (expo base n )
(cond( (or (= base 1) (= n 0) ) 1)
(else ( (* base (expo(base (- n 1))) ) ) )))
-> (enter! "expo.rkt")
"expo.rkt"> (expo (2 1) )
; application: not a procedure;
; expected a procedure that can be applied to arguments
; given: 2
; [,bt for context]
I am trying to create a simple recursive exponentiation, but I get the error above. Code is self-explanatory. I am a newbie in Racket programming. I have been reading the manuals, but can't find my error. Supposedly, it shows the error because my function returns a void and not a procedure, but I don't see why it would return void. I am returning 1 or a computation.
Help, please :/
You have several misplaced parentheses. This should solve the errors:
(define (expo base n)
(cond ((or (= base 1) (= n 0)) 1)
(else (* base (expo base (- n 1))))))
And this is how you call it:
(expo 2 3)
=> 8
For the record: in Scheme a pair of parentheses means function application, so when you write (2 3) the interpreter thinks that 2 is a function and 3 is its argument ... clearly that won't work.
So you'll have to be very careful where you put those (), they make all the difference in the world! To make things easier use a good IDE with bracket matching and nice syntax coloring, and be extra tidy with the indentation. As suggested by #dyoo in the comments, DrRacket is an excellent choice.
When you call the function, you want to write
(expo 2 1)
rather than
(expo (2 1))
Same in the definition of the recursive function's definition.
In addition, this part have double brackets, which is unnecessary.
( (* base (expo(base (- n 1))) )
The cond syntactic form is best used when a) you have more than two clauses or b) you have a sequence of commands/expressions to perform for one or more clauses. Those two cases don't apply to your code. Thus, you'd have clearer code (easier to understand; easier to get correct) using if as such:
(define (expo base n)
(if (or (= base 1) (= n 0))
1
(* base (expo base (- n 1)))))
Also, study the spacing and indentation of some 'good' code; it will help your understanding tremendously.
Related
I have a program that requires having a series of interchangeable functions.
In c++ I can do a simple typedef statement. Then I can call upon on a function in that list with function[variable]. How can I do this in Common Lisp?
In Common Lisp everything is a object value, functions included. (lambda (x) (* x x)) returns a function value. The value is the address where the function resides or something similar so just having it in a list, vector og hash you can fetch that value and call it. Here is an example using lists:
;; this creates a normal function in the function namespace in the current package
(defun sub (a b)
(- a b))
;; this creates a function object bound to a variable
(defparameter *hyp* (lambda (a b) (sqrt (+ (* a a) (* b b)))))
;; this creates a lookup list of functions to call
(defparameter *funs*
(list (function +) ; a standard function object can be fetched by name with function
#'sub ; same as function, just shorter syntax
*hyp*)) ; variable *hyp* evaluates to a function
;; call one of the functions (*hyp*)
(funcall (third *funs*)
3
4)
; ==> 5
;; map over all the functions in the list with `3` and `4` as arguments
(mapcar (lambda (fun)
(funcall fun 3 4))
*funs*)
; ==> (7 -1 5)
A vector of functions, where we take one and call it:
CL-USER 1 > (funcall (aref (vector (lambda (x) (+ x 42))
(lambda (x) (* x 42))
(lambda (x) (expt x 42)))
1)
24)
1008
The already given answers having provided plenty of code, I'd like to complement with a bit of theory. An important distinction among languages is whether or not they treat functions as first-class citizens. When they do, they are said to support first-class functions. Common Lisp does, C and C++ don't. Therefore, Common Lisp offers considerably greater latitude than C/C++ in the use of functions. In particular (see other answers for code), one creates arrays of functions in Common Lisp (through lambda-expressions) much in the same way as arrays of any other object. As for 'pointers' in Common Lisp, you may want to have a look here and here for a flavour of how things are done the Common Lisp way.
I am new to Racket and functional languages in general. For now I am just trying to prepend items to a list. The concepts are a bit confusing and not sure why my code isn't working.
I am trying to do dot product calculations.
I have a function called "dProduct" that takes 2 lists (A and B) and multiplies each corresponding element in them.
;function takes dot product
(define (dProduct A B)
(define C '()) ; define list to store the multiplied elements
;multiply ea lists elements
(for ([i A] [j B])
(display (* i j)) ;THIS WORKS
(cons (* i j) C) ;APPARENTLY DOESN'T WORK
)
;THIS FOR LOOP DISPLAYS NOTHING
;display the new list "C"
(for ([k C])
(display k)
)
)
I don't understand why I can't use cons to prepend the new multiplied elements to my new list "C". What am I missing? Everything compiles fine. Would like to figure this out so I can finish this function :) Any help would be great. Thanks!
Lists are immutable, and cons does not prepend an element to an existing list. Instead, it produces a new list with the element prepended:
> (define x '(2 3))
> (cons 1 x)
'(1 2 3)
> x
'(2 3)
Since your question is tagged functional-programming, I will assume that you probably want to know how to do this functionally, and functional programming generally discourages mutating values or bindings.
Instead of mutating a binding, you should build up a new structure functionally. The easiest way to do this is to change your use of for to for/list, which produces a list of return values:
(define C
(for/list ([i A] [j B])
(* i j)))
For this program, you could make it even simpler by using the higher-order function map, which acts like a “zip” when provided more than one list argument:
(define C (map * A B))
Since for always returns #<void>, it’s only useful for producing side-effects, and in functional programming, you generally try and keep side-effects to a minimum. For that reason, you will likely find that for/list and for/fold are actually much more commonly useful in idiomatic Racket than plain for is.
Current C list has to be given new value of (cons (* i j) C) and this can be done using set! :
(define (dProduct A B)
(define C '())
(for ([i A] [j B])
(displayln (* i j))
(set! C (cons (* i j) C))) ; NOTE set! HERE.
(for ([k C])
(displayln k)))
Note that the use of set! is strongly discouraged and for/list is much better way to achieve desired result here.
I'm having trouble incorporating a recursive function that squares a number.
Basically I am trying to write a function that keeps calling the Add function x number of times to square it. So if it is 7 it should call it seven times to get 49.
(define (Add a b)
(if (and (number? a) (number? b))
(+ a b)
(lambda (x)
(+ (a x) (b x)))))
(define i 0)
(define ans 0)
(define (Square a)
(when (> i a)
((Add a ans) (+ i 1 ))))
The main issue I'm running into is that the square function only goes through the loop once, I'm not sure why the condition won't update/keep going through the loop till it reaches that condition.
Writing square directly is a big pain. It's much easier to write a recursive multiply function and then just have your square function call multiply. Follow the design recipe for recursion on the natural numbers, as it appears in section 9.3 of HtDP.
By the way, if you haven't already written a bunch of recursive functions on more standard self-referential data definitions (e.g. lists), then, well, I claim that your instructor is doing in wrong.
You should make everything that changes parameters. Imagine you want to make the factorial then two values change. It's the result and the iteration of the number down to zero.
(define (factorial value)
(define (helper cur ans)
(if (zero? cur)
ans ; finished. return the answer
(helper (- cur 1) ; recur by updating n
(* cur ans)))) ; and update the answer
(helper value 1))
Again. It's exactly the same as my example in the comment except it does something else at each step. The basic building blocks are the same and something that would square the argument is very similar.
I am trying to implement tail call recursive factorial in Common Lisp, to try it and just experience it.
I copied some code and rewrote it in Common Lisp like so:
(defun tailrecsum (x &key (running-total 0 running-total-p))
(if (= x 0)
(if running-total-p running-total 0)
(tailrecsum (- x 1) (+ running-total x))))
However, I get first a warning:
SIMPLE-WARNING:
The function has an odd number of arguments in the keyword portion.
And when trying to run it, I get an error:
SIMPLE-PROGRAM-ERROR:
odd number of &KEY arguments
Why can't I have an odd number of keyword arguments? What's the problem with that and what can I do about it?
For example in Python I could write:
def func(a, b=10):
print([a, b])
So I would have an odd number, one, of keyword arguments. No issues there.
The error doesn't refer to the number of keyword parameters; rather it means the number of arguments you call the function with. Since keywords arguments by definition need to be in pairs (:KEYWORD VALUE), having odd number of arguments means you must be missing something.
In this case you're missing the keyword in
(tailrecsum (- x 1) (+ running-total x))
which should be
(tailrecsum (- x 1) :running-total (+ running-total x))
I'm studying Scheme language (by myself). Recently I've encountered this question:
There are two functions which compute the same value (compose function f - n times).
(define (repeated f n)
(lambda (x)
(if (= n 1)
(f x)
(f ((repeated f (- n 1)) x)))))
(define (repeated f n)
(if (= n 1)
f
(lambda (x)
(f ((repeated f (- n 1)) x)))))
As I understood these two are not recursive procedures but they return recursive procedures (lol). So what is the difference between these two? Is it possible that the first returns already computed procedure even before I give value to X? I'm so confused... Please help.
In fact both procedures are recursive, each one is calling itself at some point during the execution. Also, both are returning a lambda at some point - meaning: they're procedures that return procedures.
The first procedure always returns a lambda, whereas the second procedure short-circuits and returns f when n equals 1, but also returns a lambda for values of n greater than 1. So they're not different, except for the way the base case (n equals 1) is handled.
Wow that's so much simpler than mine, though mine is tail-recursive and works for (repeated fn 0) asuuming that running a function zero times on an argument is just that argument.
(define (repeated fn times)
(let loop (
(continuation (lambda (x) x))
(count-down times))
(if (not (> count-down 0))
(lambda (x) (continuation x))
(loop (lambda (x) (continuation (fn x))) (- count-down 1)))))
The difference between the two of yours is that the first returns a procedure right-away, and then calls itself as part of the procedure. The second returns a procedure only after it's fully calculated what that procedure will be.
Right so the first returns a recursive procedure, while the second used recursion to return a non-recursive procedure. Mine works more like the second, but can calculate repitition for very large numeric values while the two above will exceed the maximum recursion depth.
((repeated cdr 1000000) (iota 1000589))