rnorm crashes when generating a single sample

[ellis]

This is using version 1.0.76 installed from npm today.
When getting a single sample from the normal distribution, an error is thrown:

const libR = require('lib-r-math.js');
libR.Normal().rnorm();

TypeError: r_func_1.seq(...)(...)(...).map is not a function
    at Object.rnorm (./node_modules/lib-r-math.js/dist/lib/libR.js:3905:41)
    at Object.rnorm (./node_modules/lib-r-math.js/dist/lib/libR.js:7503:54)
    at repl:1:15
    at ContextifyScript.Script.runInThisContext (vm.js:44:33)
    at REPLServer.defaultEval (repl.js:239:29)
    at bound (domain.js:301:14)
    at REPLServer.runBound [as eval] (domain.js:314:12)
    at REPLServer.onLine (repl.js:440:10)
    at emitOne (events.js:120:20)
    at REPLServer.emit (events.js:210:7)

In contrast, libR.Normal().rnorm(2) works.

Would you consider changing the functions to always return number[] instead of number | number[]? The fact that the return type isn't known ahead of time will require a lot of extra coding and surely lead to a lot more run-time errors. More convenient yet would be to have two functions: one that returns number and one that returns number[].

[jacobbogers]

Thanks for finding the issue,
To facilitate porting code to JS, the function works exactly like in R, If any of the functions return a single it will not be wrapped in an array. This is to make is a lot easier to port R code.

I will export a function I wrote for a situation like this forceToArray

I will release it with the fix to rnorm

[jacobbogers]

Fixed, pushed a new version 1.0.77 (use npm upgrade or git pull)

const libR = require('lib-r-math.js');
libR.Normal().rnorm();
//1.2629542848807933

Always force return array regardless

const libR = require('lib-r-math.js');
const { R: { asArray }, Normal } = libR;
const { rnorm } = Normal();

const rn = asArray( rnorm );
rn()
//[ 1.2629542848807933 ]
rn()
//[ -0.3262333607056494 ]
rn(5)
/*
[ 
  1.3297992629225006,
  1.2724293214294047,
  0.4146414344564082,
  -1.5399500419037095,
  -0.9285670347135381
]*/

[ellis]

Thanks a ton, Jason. I'm quite excited about the possibilities that your library opens up. I do most of my coding in R and javascript, and this could definitely simplify some things a lot.

[ellis]

Regarding your comment:

To facilitate porting code to JS, the function works exactly like in R, If any of the functions return a single it will not be wrapped in an array. This is to make is a lot easier to port R code.

Aren't single numbers and strings always 1-arrays in R?:

> 1
[1] 1
> class(1)
[1] "numeric"
> length(1)
[1] 1
> 1[0]
numeric(0)
> 1[1]
[1] 1
> 1[2]
[1] NA
> sapply(1, function(n) 2*n)
[1] 2

So shouldn't returning vectors actually make porting easier?

[jacobbogers]

for R arrays or scalars are interchangeable, same type

> typeof(as.array(1,2))
[1] "double"
> typeof(1)
[1] "double"

You make a good point, certainly something to consider. It would be a breaking change though, but the library is still "young", ..,need to think about it

[mmaechler]

thumbs up for @ellis here {but then I'm an R corer, not a JS programmer at all}.

[jacobbogers]

What about this edge case, if the function returns no data it will not be an empty array but "null"
R example,

> f = function(a) { }
> f(1)
NULL

[ellis]

Thanks for taking it into consideration, @jacobbogers. For what it's worth, it would fit my expectations much better and avoid tricky type checking of return values.

Could you explain what you mean about NULL being an edge case? When the type is known, then R functions tend to return something empty, instead of NULL. For example:

> rnorm(0)
numeric(0)
> data.frame()
data frame with 0 columns and 0 rows

@mmaechler Nice to see you on here - I did my doctoral work at ETH in the department of bioscience and often saw your name, though we never met.

[jacobbogers]

Returning an "undefined" or "null" would make this code in JS look more intuitive

if ( !rnorm(0)){ // null or undefined, = no data returned
 ...
}

instead of

if ( !rnorm(0).length ){ // no data returned,   an empty array
...
}

[ellis]

That's really unsafe, though, because the function could return 0, leading to a run-time error. So you would actually need to check whether the result is a number/array anyway before checking whether it's null-ish. Checking .length would then be much more concise.

In the example below, we see how much extra code is required if rnorm doesn't return number[], but instead returns null | number | number[].

/** sum up `n` random variables */
function fn(n: number): number {
  const x = rnorm(n);
  if (x == null) {
    return 0;
  } else if (Array.isArray(x)) {
    return x.reduce((acc, x) => acc+x, 0);
  } else {
    return x;
  }
}

versus when rnorm always returns an array of numbers:

function fn(n: number): number {
  return rnorm(n).reduce((acc, x) => acc+x, 0);
}

So I'd guess from the point of view of both R-porting and JavaScript-programming, it would seem safer and more consistent to return [] when R returns numeric(0), and allow for null only for the R-functions that actually return NULL. In fact, with TypeScript, some NULL cases could simply be eliminated by using void and generic types.

[jacobbogers]

No, because if an actual value is returned it is wrapped in an array (aka [0]) and an array [0] is never equal to the scalar 0. Hence if (!rnorm(x)) will always work correctly because scalar 0 is never returned.

the context is always returning an array like you requested, and in the edge case of an empty array "undefined" or "null" ( mutually exclusive).

Just use the wrapper rnorm2 = asArray(rnorm) and you will be ok.
There is also a sum function (see the README section "helper function" ) that does exactly what you want

sum([1,2,3,4]) you get the idea,

Your code above would look like

const rnorm2 = asArray(rnorm);
const data = sum(rnorm2(5));

[jacobbogers]

Just wanted to add,
I think i understand what you are trying to do.

Not sure why you are writing your own functions,

If you want to sum the number of runif it works straight out of the box with the helper functions, (that is why I added helpers)

So just use sum(rnorm(15)) (example) directly.

sum (and other helpers) work like lodash/fp, you can give it either a scalar or an array and it will work.

There are lots of helpers that make you write nice short code.. check them out, if you think a usefull helper is missing let me know I can add it.

[jacobbogers]

Also check out map, each, multiplex (README)
As a general rule try to use more functional style programming,
These oneliners do the same your code.

Array.isArray(x) && x.reduce((s,v)=>s+x,0)
if you dont want to do the test
sum = ( x || [0]).reduce((s,v)=>s+x,0) //always works regardless if x

But I suggest you use the sum (see README) helper function.
https://www.npmjs.com/package/lib-r-math.js#sum