25
$\begingroup$

The following function is defined for Real input:

FFc = Compile[{{x, _Real}, {EF, _Real}},If[x > EF, 0., If[x == EF, 0.5, 1.]]]

FFc is now used in the function called foo:

EBoundary = 6.5;
foo[Ef_?NumericQ] := NIntegrate[FFc[x, Ef] , {x, -EBoundary, EBoundary}]

When I call foo like

foo[3.2]

I get an error message:

CompiledFunction::cfsa: "Argument x at position 1 should be a machine-size real number.

Since I'm using real numbers I have no idea why I get this message. What is the problem? Is it because If[] can return 0?

$\endgroup$

2 Answers 2

20
$\begingroup$

It's because FFc is being passed x and Ef symbolically, at first. To cure the problem, add an intermediate function between FFc and NIntegrate, such as

f[x_?NumericQ, Ef_?NumericQ] := FFc[x,Ef]

then

foo[Ef_?NumericQ] := NIntegrate[f[x, Ef] , {x, -EBoundary, EBoundary}]
$\endgroup$
10
  • 4
    $\begingroup$ Do you perhaps know why adding "RuntimeOptions" -> {"EvaluateSymbolically" -> False} to FFc does not cure the problem? $\endgroup$
    – Ajasja
    Jan 18, 2013 at 9:40
  • 2
    $\begingroup$ @Ajasja Seems related to why FFc[-x,0.] gives error while FFc[x,0.] doesn't. I wonder why NIntegrate passes -x as argument to the function. (This comment is assuming {"EvaluateSymbolically" -> False}) $\endgroup$
    – ssch
    Jan 18, 2013 at 12:20
  • $\begingroup$ @Ajasja Seems if the integration region is {x,-a,a} it doesn't work, while it is unsymmetric like {x,-a-0.00001,a} it does $\endgroup$
    – ssch
    Jan 18, 2013 at 12:26
  • $\begingroup$ @Ajasja no idea. Compile is not my strong suit. $\endgroup$
    – rcollyer
    Jan 18, 2013 at 13:14
  • $\begingroup$ Thanks. Perhaps @OleksandR will see this:) $\endgroup$
    – Ajasja
    Jan 18, 2013 at 13:47
11
$\begingroup$

This answer addresses Ajasja's question in rcollyer's answer:

Do you perhaps know why adding "RuntimeOptions" -> {"EvaluateSymbolically" -> False} to FFc does not cure the problem?

This is due to the fact that the methods inside NIntegrate[] (attempt to) perform a preliminary symbolic analysis, which can be helpful for integrands composed of built-in mathematical functions, but not terribly useful for compiled functions. Thus, one has to turn it off in this case, in addition to enabling the compilation options mentioned by Ajasja.

Here is a quick demonstration:

FFc = Compile[{{x, _Real}, {EF, _Real}}, 
              If[x > EF, 0., If[x == EF, 0.5, 1.]], 
              "RuntimeOptions" -> {"EvaluateSymbolically" -> False}];

With the default setting, we get this (Mathematica 10.4):

NIntegrate[FFc[x, 3.2], {x, -6.5, 6.5}]
CompiledFunction::cfsa: Argument -x at position 1 should be a machine-size real number.
CompiledFunction::cfsa: Argument -x at position 1 should be a machine-size real number.
NIntegrate::slwcon: Numerical integration converging too slowly; suspect one of the
following: singularity, value of the integration is 0, highly oscillatory integrand, or
WorkingPrecision too small.
NIntegrate::ncvb: NIntegrate failed to converge to prescribed accuracy after 9
recursive bisections in x near {x} = {3.22441}. NIntegrate obtained 9.699759342263453`
and 0.0005405922634428764` for the integral and error estimates.

before 9.69976 is returned. In contrast, if we disable symbolic processing like so:

NIntegrate[FFc[x, 3.2], {x, -6.5, 6.5}, Method -> {Automatic, "SymbolicProcessing" -> 0}]
NIntegrate::slwcon: Numerical integration converging too slowly; suspect one of the
following: singularity, value of the integration is 0, highly oscillatory integrand, or
WorkingPrecision too small.
NIntegrate::ncvb: NIntegrate failed to converge to prescribed accuracy after 9
recursive bisections in x near {x} = {3.22441}. NIntegrate obtained 9.699759342263453`
and 0.0005405922634428764` for the integral and error estimates.

we no longer get the CompiledFunction::cfsa message.

$\endgroup$
6
  • $\begingroup$ Nice find and explanation. $\endgroup$
    – rcollyer
    Mar 30, 2016 at 12:43
  • $\begingroup$ @rcollyer, I think this was asked during one of my hiatuses, so I had missed it until Jason linked to it in another question. :) $\endgroup$ Mar 30, 2016 at 13:10
  • 1
    $\begingroup$ For some reason it does not work in M11.1 or 11.2 $\endgroup$
    – user40532
    Oct 5, 2017 at 5:35
  • 1
    $\begingroup$ Using f1p11 = Compile[{{p, _Real, 1}, {pq, _Real, 1}, {pqq, _Real, 1}}, E^-(#.# &[p + pq/2 - pqq/2]), CompilationTarget -> "C", RuntimeOptions -> {"Speed", "EvaluateSymbolically" -> False}] and NIntegrate[ f1p11[{px, py}, {1, 1}, {2, 2}], {px, py} \[Element] BoundaryDiscretizeRegion[Disk[{1, 1}/2 - {2, 2}/2, 3]], Method -> {"MonteCarlo", "SymbolicProcessing" -> 0, Method -> {"MonteCarloRule", "Points" -> 500}}, PrecisionGoal -> 3] <br/> I get CompiledFunction::cfta: Argument {px,py}... $\endgroup$
    – user40532
    Oct 5, 2017 at 5:44
  • $\begingroup$ @luu, I don't have a C compiler to verify your observations; 2. IIRC special handling is done for geometric integrals (i.e. those involving regions). This answer is mostly intended to explain the univariate case. Consider asking a new question if this is still troubling you. $\endgroup$ Oct 13, 2017 at 4:44

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.