Creating a multidimensional array with Compile

Question

For one of my programs I need to preallocate a multidimensional list/array. For performance reasons I want to do this within Compile and compile my program to C-code.

Now I made the following observation for the following minimal working example:

cf = Compile[{}, Block[{list},
    list = Table[{0., 1.}, {1}, {1}];
    list[[1, 1, 2]]], CompilationTarget :> "MVM"];

with CompilationTarget :> "MVM" this function works just fine. When I call cf[] I obtain the expected result 1.. Now if I change CompilationTarget->"C", I receive the following error message when I define the function cf in MMA

CCompilerDriver`CreateLibrary::cmperr: Compile error: C:\Users\AppData\Roaming\Mathematica\ApplicationData\CCompilerDriver\BuildFolder\compiledFunction100.c(152) : error C2440: 'function' : cannot convert from 'mreal' to 'MTensor *' >>
Compile::nogen: A library could not be generated from the compiled function. >>

Note that for both CompilationTargets CompilePrint shows that the code just compiles nicely.

If I keep the code to be compiled to C but change the dimensionality of the list the error message disappears

(*Compiled function*)
cf = Compile[{}, Block[{list},
    list = Table[{0., 1.}, {1}];
    list[[1, 1]]], CompilationTarget :> "C"];

Any clue how this behaviour comes about? I guess the C-compiler cannot handle these kind of Tables where I give a List of rank 1 as a first argument and only accepts arguments of rank 0. However, since the error message only appears when I define the function but not when I call it, is it safe to use anyway? (since CompilePrint shows no call to MainEvaluate).

Answer 1

…since the error message only appears when I define the function but not when I call it, is it safe to use anyway?

This depends on how you define safe. A CompiledFunction that's compiled to C succesfully owns a LibraryFunction as its last argument:

Compile[{}, 1, CompilationTarget -> C] // InputForm

CompiledFunction[……,LibraryFunction[……]]

This is what makes the CompiledFunction faster (in some cases). So, the cf will still give you the correct output, but it loses the blessing of C.

Finally, a possible workaround:

cffixed = Unevaluated@Compile[{}, Block[{list = {{{}}}}, list = Table[{0., 1.}, {1}, {1}];
     list[[1, 1, 2]]], CompilationTarget -> C] /. Part -> Compile`GetElement

The keypoint is list = {{{}}} i.e. initializing list with an empty list with correct dimension. Part -> Compile`GetElement isn't necessary but it speeds up the code.