We are passing a lambda expression to gradient, which requires a function handle as actual parameter.
From that point on, Octave sees k as a function handle and passes it accordingly. What is happening here is that, unlike the previous example, the operator is applied to the function expression before binding it to k. As a result, we do not need to prefix it with when passing it to the gradient function. The gradient function requires its first actual argument to be a function handle. If a function expects one of its formal parameters to be a function, then the actual invocation needs to pass a function handle. In this other case, we apply the operator on the function expression itself before binding it/assigning it to a variable, in this case k. In the previous case, we applied the to the function name J when passed as an argument to the gradient function. Now, before we proceed, play close attention to this important subtlety. Here is where Octave’s documentation is a bit tricky to delve into (if it is anywhere in the Octave docs, I have not found it explicitly).Ĭonsider the case when you want to compute the gradient to a lambda bound to a variable name.
So, do we use the like that all the time? Not really. But, on the application of the function, on the actual call, we need to get a handle to a function before passing it around as a parameter value. In this case, we use Octave’s (function handle) operator.Īn algorithm can be defined so that it takes a function as an argument, and uses it without any syntactic quirk. What’s going on here? Well, in Octave, when we APPLY the gradient function with actual parameters, we need to get a reference to the target function. Specifically, notice the symbol prefixing the actual parameter J (the function whose derivative we want to 100, 0.0000001)
Define variables gnu octave code#
So far so good, but notice in the Octave code snippet below what happens when you call it with actual parameters. # using a lambda expression bound to a variable/symbol
# similar to the ones in the Scala example. # and now, some applications of the gradient function # and the function whose slope we want to approximate when x=100 Retval = (J(theta+epsilon) - J(theta-epsilon))/(2*epsilon) Don’t let that syntax quirk throw you off.įunction retval = gradient(J,theta,epsilon) In Octave, a function declaration includes a named return value (in this case retval). By being able to treat functions as first-class types, we can pass them around as arguments (as well as create function literals.) Now, Onto OctaveĪ similar base implementation of our gradient approximating function could be created in Octave. Simple functional programming bread-and-butter. * (which is 8 * x) when x = 100 (whose value is 80) * let's try to approximate the derivative of 2 * x^4 + 2 Implicit def extDouble(d:Double) = new ExtDouble(d)ĭef gradient(f: (Double)=>Double, epsilon: Double) : (Double) => Double = * we use these two lines to add an implicit exponentiation shortcutĬlass ExtDouble(d:Double) The function that does the grading approximation receives another function as a first-class parameter: Here is one way to do it in Scala using functional programming concepts. We can do so by simply implementing the general formula for a derivative: Let’s consider we want to implement a function that approximates the derivative of any arbitrary differentiable function. What better way to illustrate the basic similarities (and differences) between Scala and Octave than with an example. Using that synergy I was able to delve into Octave’s basic syntax for functional programming. Given my unfamiliarity with Octave, I ended up prototyping and verifying my algorithms in Scala and then porting them into Octave. The Machine Language course used GNU Octave, a Matlab-like language for statistical and numerical computation. I did get a lot of learning done with the Scala and Machine Learning courses. Time to catch up and move on to the next plate challenge thingie. The parallel programming course is already a week in progress. In addition to that, two courses I’ve been waiting for a while (the U-Illinois’ Heterogeneous Parallel Programming and Stanford’s Algorithms 2 courses) have already started.
0 kommentar(er)
