# [erlang-questions] Erlang arithmetics

Sun Oct 31 05:22:16 CET 2010

```Hi, Dmitry. Your code in JavaScript with Node.js is not equivalent to
the Erlang one. You could take some operation-equivalent program:
for example, I modified your JavaScript code, and make it follow fashion

// ==================================
// Modified Erlang code

test() ->
Now = now(),
seq(1, 1000),
timer:now_diff(now(), Now).

seq(M, N) ->
L = lists:seq(M, N),
[{X0,Y0}|Ps] =
[ {random:uniform(1000),random:uniform(1000)} || _ <- L ],
{Total,_} =
lists:foldr(fun move_to/2, {0, {X0,Y0}}, Ps),
Total.

move_to({X, Y}, {Sum, {X0, Y0}}) ->
{Sum + math:sqrt((X - X0) * (X - X0) + (Y - Y0) * (Y - Y0)), {X, Y}}.

// ====================================
// Modified JavaScript code with Node.js,
// following Erlang fashion

function move_to(xy, sum, xy0) {
var result = [];
result = {};
result = sum +
Math.sqrt(
(xy-xy0)*(xy-xy0)
+ (xy-xy0)*(xy-xy0)
);
result = {};
result = xy;
return result;
}

function fold(f, base, xy0, list) {
if (list.length == 0) {
var result = [];
result = {};
result = base;
result = {};
result = xy0;
return result;
}
var p = list[list.length-1];
list.length = list.length-1;
var sum_xy = move_to(p, base, xy0);
return fold(f, sum_xy, sum_xy, list);
}

function list_seq(m, n) {
var result = [];
var i;
for (i=m; i<=n; i++) {
result[i-m] = {};
result[i-m] = m;
}
return result;
}

function list_rand(seq) {
var result = [];
for (var i in seq) {
result[i] = {};
result[i] = [];
result[i] = Math.floor(Math.random() * 1000 + 1);
result[i] = Math.floor(Math.random() * 1000 + 1);
}
return result;
}

function seq(m, n) {
var list = list_seq(m, n);
var list1 = list_rand(list);
list1.length--;
var result = fold(move_to, 0, head, list1);
return result;
}

var start = (new Date()).valueOf();
console.log(seq(1,1000));
var end = (new Date()).valueOf();
console.log(end-start);
// ===============================

In my computer with Ubuntu 10.10, the JavaScript program performed in 24~25
milliseconds, and the Erlang one performs about 8.5 milliseconds. Result is
meaningful.
The JavaScript one used some functions, but no recursive functions. Almost
the same
operations were performed, and the Erlang works fine. It may be persuasive.

--

Best Regards,

--- Y-H. H.

On Sat, Oct 30, 2010 at 4:03 PM, Dmitry Demeshchuk < >wrote:

> Greetings.
>
> I'm writing an article comparing Erlang and Node.js and I stumbled
> upon the performance question.
>
> My initial goal was to compare some basic arithmetics speed, like the
> total distance between randomly distributed points. So, I have written
> the following code for Erlang:
>
<cut />

> and the following code for Node.js:
>
> ======================================================
>
> var a = [];
> for(var i = 0; i < 1000000; i++) {
>    a[i] = {};
>    a[i].x = Math.floor(Math.random() * 1000);
>    a[i].y = Math.floor(Math.random() * 1000);
> }
>
> var sum = 0;
>
> var start = (new Date()).valueOf();
>
> for(var i = 1; i < 1000000; i++) {
>    var prev = a[i-1];
>    sum += Math.sqrt((a[i].x - prev.x) * (a[i].x - prev.x) + (a[i].y -
> prev.y) * (a[i].y - prev.y));
> }
>
> var end = (new Date()).valueOf();
>
> console.log(end - start);
>
> ============================================
>
>
```