Compiling a function that takes lots of optional arguments

Question

I have a function that takes lots of optional arguments (basically some design parameters, about 10 of them) and performs some basic algebraic calculations involving complex numbers with the options. The function generally evaluates to a complex number. For example, I have something like:

Options[myfunc] = {param1 -> 1.0, param2 -> 2.0, param3 -> 3.0, etc.};
myfunc[x, opts: OptionsPattern[]] := 
    Module[
      {var1,var2,  etc.},
      var1 = OptionValue[param1]; etc.
      I*x*var1 + var2 + 1/(var3 + I var4)*... etc.
    ]

The function is listable in x and I want to evaluate it as fast as possible for different x's.

I need to use this function in lots of plotting, solving and optimization procedures as part of a Manipulate GUI. The problem is that such procedures takes significant amount of time (~ 10s) which renders the Manipulate GUI unusable.

My question is if I can compile myfunc somehow to speed up the rest of the processing? If not, is there an alternative way to define a function with Options (or optional arguments) to make it compilable? Can I compile the entire Manipulate GUI? If compilation is not possible, any hints about how to define such function in an efficient way?

Answer 1

Without a more complete example of your function all I can offer are bare guidelines to (hopefully) point you in the right direction.

• The first level is merely syntactical; you would use OptionsPattern, OptionValue etc., in a high level function simply for convenience, but pass all arguments as machine types to an inner compiled function.

• A second level is to use the high-level function as a selector for multiple compiled functions. Most simply this might be illustrated with a "Method" option which while having a human-readable value name would be used only to choose the appropriate compiled function to which the other arguments are passed.

• A different level is compilation at the time the high-level function is called based on the option values and other parameters. Possibly memoization would be used to prevent re-compiling the same thing multiple times. One may also want to modularize the code and use CompilationOptions -> {"InlineCompiledFunctions" -> True} as part of this process.