By darrenjw
(This article was originally published at Darren Wilkinson’s research blog, and syndicated at StatsBlogs.)
Introduction
Functional programming (FP) is a programming style that emphasises the use of referentially transparent pure functions and immutable data structures. Higher order functions (HOFs) tend to be used extensively to enable a clean functional programming style. A HOF is just a function that either takes a function as an argument or returns a function. For example, the default List type in Scala is immutable. So, if one defines a list via
val l1 = List(1,2,3)
we add a new value to the front of the list by creating a new list from the old list and leaving the old list unchanged:
val l2 = 4 :: l1 // List(4, 1, 2, 3)
We can create a new list the same length as an existing list by applying the same function to each element of the list in turn using map:
val l3 = l2 map { x => x*x }
// List(16, 1, 4, 9)
We could write this slightly differently as
val l4 = l2.map(x => x*x)
which makes it clearer that map is a higher order function on lists. In fact, the presence of a map method on List[_] makes it a functor, but that is a topic for another post.
HOFs are ubiquitous in FP, and very powerful. But there are a few techniques for working with functions in Scala (and other FP languages) which make creating and using HOFs more convenient.
Plotting a function of one scalar variable
There are many, many reasons for using functions and HOFs in scientific and statistical computing (optimising, integrating, differentiating, or sampling, to name just a few). But the basic idea can be illustrated simply by considering the problem of plotting a function of one scalar variable.
All of the code associated with this post is available in the …read more
Source:: statsblogs.com