3
$\begingroup$

I have a simple function that I've written as both a pure function and a compiled pure function, but the compiled version produces different results, suggesting either I don't know how to get it to work with Compile or that Compile has some limitations I didn't know about. I intend to give the function two arguments, the first is a single real number, and the second is a list of integers.

fun = Apply[Times, #1 - Range[#2], {1}] &;

fc = Compile[
      {{value, _Real}, 
       {counts, _Integer, 1}},
      Apply[Times, #1 - Range[#2], {1}] &[value, counts]
     ];

fun[5, {1, 2, 3}]
fc[5, {1, 2, 3}]

The results I obtain are

{4, 12, 24}

{4., 3., 2.}

The results I want to obtain are those produced by the non-compiled function.

I know I could rewrite the function as follows to produce the results that I want (thanks, @glS).

fcV2 = Compile[
       {{value, _Real}, 
        {counts, _Integer, 1}}, 
       Apply[Times, value - Range@# ] & /@ counts 
       ];

Why doesn't my first attempt at a compiled function work as expected? Is there a way to fix it without explicit mapping?

Improve this question
$\endgroup$
1
  • 2
    $\begingroup$ (1) You won't be able to do it because Range[{1,2,3}] (uncompiled) does not produce a rectangular array. (2) Inside Compile[], Range[{1,2,3}] produces {1,2,3}. $\endgroup$
    – Michael E2
    Commented Jul 20, 2017 at 21:08

1 Answer 1

Reset to default
4
$\begingroup$

Compare:

Range[{1, 2, 3}]

Compile[{{c, _Integer, 1}}, Range[c]][{1, 2, 3}]

{{1}, {1, 2}, {1, 2, 3}}

{1, 2, 3}

This is related to the fact that Compile does not work with ragged arrays, which is what Range[{1,2,3}] returns.

Improve this answer
$\endgroup$
3
  • 3
    $\begingroup$ Do you know why Range[{1,2,3}] produces {1,2,3} instead of, say, a call to MainEvaluate? It seems odd that it produces a different result in the two contexts. $\endgroup$
    – Michael E2
    Commented Jul 20, 2017 at 21:09
  • 1
    $\begingroup$ I think it's worth reporting to Wolfram. $\endgroup$
    – Carl Woll
    Commented Jul 20, 2017 at 21:11
  • 1
    $\begingroup$ I reported it to Wolfram Technical Support, asking whether "such behavior is intentional, or whether Wolfram would prefer to modify [it]." The response I received is: "I would say that this is peculiar, but not entirely unexpected behavior on the part of Compile; as you have said yourself, compiled functions are not able to take in, deal with, or produce ragged arrays. Therefore, if you expect that your uncompiled code would generate ragged arrays in the course of its evaluation, some modification will be needed if you want to write a compiled version of it." $\endgroup$
    – FalafelPita
    Commented Aug 7, 2017 at 19:34

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service and acknowledge you have read our privacy policy.

Not the answer you're looking for? Browse other questions tagged or ask your own question.