Specifically, notice the symbol prefixing the actual parameter J (the function whose derivative we want to 100, 0.0000001) 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 =

$define variables gnu octave$

* 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.

Define variables gnu octave