Dear Forum

Since long I am fixing some issues in my 3D models.
I created a second order filter function that smooths the angles between
lines of points stored in an array. It works well in Excel and now I
want to implement it in Openscad.

The basic array is created with a function:
 x_rooftop = [ for (n = [0:1:i_in_window_tip]) uncurved_top(n_to_z(n)) ];

Now I want to proces this array through a second order filter.
The problem is that each value n depends on the generated value for n-1.

The function for a first order is Output(n) = Output(n-1) + Constant1 *
(input (n) - Output(n-1))
And for a second order it is Output(n) = Output(n-1) + Constant1 *
(input (n) - Output(n-1)) + Constant2 * (input (n) - Output(n-1))
*(input (n) - Output(n-1))

I cannot figure out how to put that Output(n-1) in a function.

/kind regards //
Johan Jonker/

You need to write it as a recursive function that steps through the array.

Like Leonard, I don't know how you want to "prime" your function, so I
can't give you a specific answer.

But here's a general-purpose function that I just threw together that
will walk through an array, and for each element in the array it will
call a user-provided function.  It will pass  to that function the
element from the array, plus an array that the previous call returned. 
The user-provided function is to take those two arguments and return an
array where the first element is the value to put into the resulting
array, and any subsequent elements are whatever it finds useful.

function map(f, a, prev=undef, i=0) =
    i >= len(a)
    ? []
    : let (tmp = f(a[i], prev))
        concat(tmp[0], map(f, a, tmp, i+1));

sumf = function (v, prev)
    is_undef(prev)
    ? [ v ]
    : [ prev[0] + v ];

echo(map(sumf, [1,2,3,4]));

yields

ECHO: [1, 3, 6, 10]

Note that sumf takes two arguments.  v is the value from the array, and
prev is the array returned by the previous call to sumf, or undef on the
first call.  It returns an array with a single element, the running sum
of the array so far.  As it happens, sumf doesn't need any additional
data, but it could have put more data into the array for use by
subsequent calls.

Or here's a  function that will tell you the difference between
successive pairs of entries in the array.  (The first element of the
resulting array will be undef, because there's one fewer difference than
there are entries in the original.)

diff = function (v, prev)
    is_undef(prev)
    ? [ undef, v ]
    : [ v - prev[1], v ];

echo(map(diff, [4, 2, 76, 12]));

yields

ECHO: [undef, -2, 74, -64]