Not very efficient as O(n^2) but

points_relative = [[0,0],[10,0],[5,10],[-5,10],[-10,0],[-5,-10]];

function sum_points(list, i) = i >= 0 ? list[i] + sum_points(list, i - 1) :
[0, 0];

function rel_to_abs(list) = [
for(i = [0 : len(list) - 1]) sum_points(list, i)
];

points_absolute = rel_to_abs(points_relative);
echo(points_absolute);

polygon(points_absolute);

On 24 May 2016 at 13:08, droftarts ginjaian@hotmail.com wrote:

nophead wrote

Yeah, summing up things with OpenSCAD is not real fun.

--
View this message in context: http://forum.openscad.org/Polygon-using-relative-points-rather-than-absolute-tp17414p17417.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

Here is a better version that should be O(n) and tail recursive, I think.
Perhaps easier to understand as well as it is more like a procedural loop.

points_relative = [[0,0],[10,0],[5,10],[-5,10],[-10,0],[-5,-10]];

function rel_to_abs(list, i = 0, sum = [0,0], result = []) =
i == len(list) ? result : rel_to_abs(list, i + 1, sum + list[i],
concat(result, [sum + list[i]]));

points_absolute = rel_to_abs(points_relative);
echo(points_absolute);

polygon(points_absolute);

On 24 May 2016 at 14:35, Parkinbot rudolf@parkinbot.com wrote:

@nophead
The original problem is O(n^2). There are n*(n+1)/2 sums to be done, where n
is the size of the array of points. So there is no O(n) algorithm for it.
Your first solution is better because it is clearer. To avoid recursion, you
may consider:

which is very general and applies to list of numbers, vectors, matrices,
etc.
But that is a question of taste. :)

--
View this message in context: http://forum.openscad.org/Polygon-using-relative-points-rather-than-absolute-tp17414p17419.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

However, rel_to_abs may be defined with less parameters:

--
View this message in context: http://forum.openscad.org/Polygon-using-relative-points-rather-than-absolute-tp17414p17421.html
Sent from the OpenSCAD mailing list archive at Nabble.com.

That is an interesting way of summing a vector by using a dot product with
a vector of ones.

I think the tail recursive version will be the fastest because my
understanding is OpenScad will optimise it into a loop. It is equivalent to

i = 0;
sum = [0, 0];
result = [];
while(i < len(list))  {
result = concat(result, sum + list[i]);
sum = sum + list([i]);
i = i + 1;
}

Yes you can use less parameters but it makes it less readable and less
efficient. Is there any advantage?

On 24 May 2016 at 17:55, Ronaldo rcmpersiano@gmail.com wrote: