# Hell Oh Entropy!

Life, Code and everything in between
Posted: Jun 10, 2012, 10:01

The Structure and Interpretation of Computer Programs course has a class on higher order functions, which is the ability of a function to accept a function and/or returns another function that uses the input function. The C programming language has very limit capability to do this and it is limited to being able to accept function pointers or return function pointers. I wanted to explore this limitation further to figure out exactly how far I can stretch this, so I wrote a small C program that tries to emulate this concept. This is just random tinkering, so if the reader is looking for a specific lesson, then let me clarify that there is none.

I wrote a program to get square roots using the Newton-Raphson method – the same one that was used in the course with an attempt to keep the structure as close as possible to the scheme example in the class video. The Lisp-based listing for the course can be found on the internet and here is what I wrote:

```#include <stdio.h>
#include <stdlib.h>
typedef double (*generic_func_t) (double);
#define dx 0.000001
#define absolute(n) ((n) < 0 ? -(n) : (n))
generic_func_t deriv(generic_func_t f)
{
double deriv_func(double x)
{
return (f(x + dx) - f(x)) / dx;
}
return deriv_func;
}
double fixed_point(generic_func_t f, double x)
{
while (absolute(f(x) - x) > dx)
x = f(x);
return f(x);
}
double newton(generic_func_t f, double guess)
{
double newton_func(double y)
{
generic_func_t df = deriv(f);
return (y - f(y) / df (y));
}
return fixed_point(newton_func, guess);
}
double sqrt(double x)
{
double sqrt_func(double y)
{
return (x - y*y);
}
return newton(sqrt_func, 1);
}
int main(int argc, char **argv)
{
if (argc < 2) {
printf(“Usage: %s <number>\n”, argv);
exit (1);
}
printf (“%lf\n”, sqrt(strtod(argv, NULL)));
return 0;
}```
The first thing that is evident in the above is that the syntax is non-standard. I have declared some functions within another function and that is not allowed by the C standard. GCC however implements this concept of nested functions as an extension, so this compiled cleanly for me. Running this however is a completely different thing.

Executing the above program for any argument results in segfaults and analysis of the program under gdb shows that the generated code is quite ridiculous. This is expected however, since we have pushed the gcc nested function support too far. The nested functions within gcc are OK as long as they remain within the following limits:

1. They are only used within the function that nests them, either directly or indirectly via some function calls. Essentially, control from the nested function should return before it’s nesting function returns.
2. If they’re used outside the nesting function and called after the nesting function returns, then they don’t use any local variables or arguments of the nesting function
Of course, if (2) is true then the function need not have been nested in the first place. Looking at the listing above, the functions sqrt_func, newton_func and deriv_func are the nested functions. Of these however, only deriv_func is actually returned as a function to be used from within newton_func. This is wrong because it breaks (2). deriv_func uses the input argument f(x) which is essentially sqrt_func and is actually called after the deriv() function returns. Other than that however, all of our ‘functional-type’ code looks sane and within what is supported by gcc.

So I modified the deriv function and came up with the listing below:

```#include <stdio.h>
#include <stdlib.h>
typedef double (*generic_func_t) (double);
#define dx 0.000001
#define absolute(n) ((n) < 0 ? -(n) : (n))
double deriv(double x, generic_func_t f)
{
return (f(x + dx) - f(x)) / dx;
}
double fixed_point(generic_func_t f, double x)
{
while (absolute(f(x) - x) > dx)
x = f(x);
return f(x);
}
double newton(generic_func_t f, double guess)
{
double newton_func(double y)
{
double dy = deriv(y, f);
return (y - f(y) / dy);
}
return fixed_point(newton_func, guess);
}
double sqrt(double x)
{
double sqrt_func(double y)
{
return (x - y*y);
}
return newton(sqrt_func, 1);
}
int main(int argc, char **argv)
{
if (argc < 2) {
printf(“Usage: %s <number>\n”, argv);
exit (1);
}
printf (“%lf\n”, sqrt(strtod(argv, NULL)));
return 0;
}```
The only change above is that instead of accepting a function and returning another in deriv, I now accept a function and return the evaluation of the derived function for the specified value. This is highlighted in bold above. This program now builds with gcc and also runs correctly. It should similarly be possible to eliminate the other nested functions to get a much more compact and standards-compliant program.