CODEWITHSUNDEEP
loopsintegerjulia
Jim Maas
Jim Maas

Reputation: 1729

Julia, use of map to run a function multiple times,

I have some code that runs fine and does what I want, although there may be a simpler more elegant solution, this works :

round(Int16, floor(rand(TruncatedNormal(150,20,50,250))))

However when I try to execute it multiple times, using map, it throws an error saying it doesn't like the Int16 specification, so this:

map(round(Int16, floor(rand(TruncatedNormal(150,20,50,250)))), 1:2)

throws this error

ERROR: MethodError: objects of type Int16 are not callable

I just want to run it twice (in this case) and sum the results. Why is it unhappy? Thx. J

Upvotes: 3

Views: 475

Answers (2)

call me Steve
call me Steve

Reputation: 1727

Adding on the answer from @darsnack. If you want to run it multiple times in order to keep the results (it wasn't clear from the question). Then you could also ask rand to produce a vector by doing the following (and also making the type conversion through the floor call).

Moving from:

map(round(Int16, floor(rand(TruncatedNormal(150,20,50,250)))), 1:2)

to:

floor.(Int16, rand(TruncatedNormal(150,20,50,250), 2))

The documentation is here.

Upvotes: 4

darsnack
darsnack

Reputation: 925

The first argument to map is a function. So, with your code, Julia is trying to make a function call:

round(Int16, floor(rand(TruncatedNormal(150,20,50,250))))()

But the output of round(Int16, ...) isn't a function, it's a number, so you cannot call it. That's why the error says "objects of type Int16 are not callable." You could fix this by using an anonymous function:

map(() -> round(Int16, floor(rand(TruncatedNormal(150,20,50,250)))), 1:2)

But the "Julian" way to do this is to use a comprehension:

[round(Int16, floor(rand(TruncatedNormal(150,20,50,250)))) for _ in 1:2]

EDIT:

If you are going to sum the results, then you can use something that looks like a comprehension but is called a generator expression. This is basically everything above with the [ ] around the expression. A generator expression can be used directly in functions like sum or mean, etc.

sum(round(Int16, floor(rand(TruncatedNormal(150,20,50,250)))) for _ in 1:2)

The advantage to generator expressions is that they don't allocate the memory for the full array. So, if you did this 100 times and used the sum approach above, you wouldn't need to allocate space for 100 numbers.

This goes beyond the original question, but OP wanted to use the sum expression where the 2 in 1:2 is a 1-element vector. Of course, if the input is always a 1-element vector, then I recommend first(x) like the comments. But this is a nice opportunity to show the importance of breaking things down into functions frequently in Julia. For example, you could take the entire sum expression and define a function

generatenumbers(n::Integer) = sum(... for _ in 1:n)

where n is a scalar. Then if you have some odd array expression for n (1-element vector, many such ns in a multi-dim array, etc.), you can just do:

generatenumbers.(ns)
# will apply to each element and return same shape as ns

If the de-sugaring logic is more complex than applying element-wise, you can even define:

generatenumbers(ns::AbstractArray) = # ... something more complex

The point is to define an "atomic" function that expresses the statement or task you want clearly, then use dispatch to apply it to more complicated data-structures that appear in practical code. This is a common design pattern in Julia (not the only option, but an effective one).

Upvotes: 5

Related Questions