numerics - Strategies to avoid LessEqual::nord in NMinimize?

When using NMinimize on functions with complex intermediate expressions (but a real end result), quite often one gets the error LessEqual::nord. Example:

NMinimize[Abs[(a+I b)^(3/2)],{a,b}]
(*
LessEqual::nord: Invalid comparison with 0.306069 + 0. I attempted.

LessEqual::nord: Invalid comparison with 0.306069 + 0. I attempted.

LessEqual::nord: Invalid comparison with 0.306069 + 0. I attempted.


General::stop: Further output of LessEqual::nord
     will be suppressed during this calculation.

Less::nord: Invalid comparison with -0.0745302 + 0. I attempted.

NMinimize::cvmit: 
   Failed to converge to the requested accuracy or precision within 100
     iterations.

{1.0635969220476164*^-12 + 0.*I, {a -> -8.71759358950322*^-9, b -> 5.707170335837908*^-9}}

*)

In some cases (not the one above; I didn't find a simple one where it happens) this also results in a clearly wrong result. Therefore it's desirable to remove the error messages.

Now the only way to get rid of this error is to change the expression in a way that it doesn't trigger the error. However the expressions are generally complicated enough that it's not feasible by hand. I've found that a combination of the following strategies works sometimes:

• Use ComplexExpand with the option TargetFunctions->{Re,Im}.


• Put the entire expression into an Abs or Re (despite it being known to be real from construction) and use Simplify or FullSimplify with appropriate constraints (and hope it finishes in reasonable time). (Abs of course only works if the result is also nonnegative)

However those strategies are not always sufficient. Therefore my question:

What are other good strategies to get the expression into a form suitable to NMinimize?

Answer

I think you have to do the same as in many such cases: protect your arguments to be strictly numerical:

f[a_?NumericQ, b_?NumericQ] := Abs[(a + I b)^(3/2)];

And then no problems:

NMinimize[f[a,b],{a,b}]

(*
 ==>  {1.11868*10^-26,{a->3.9489*10^-18,b->3.07007*10^-18}}
*)

Edit:

The following function automatically packs the expression into a function with _?NumericQ pattern arguments:

NOptimize[optfunc_,expr_,vars_,options___]:=
  Module[{f,
          varlist=If[ListQ[vars],vars,{vars}],
          expression=If[ListQ[expr],First@expr,expr],
          conditions=If[ListQ[expr],Rest@expr,{}]},
    Evaluate[f@@(Pattern[#,_?NumericQ]&/@varlist)]=expression;
    optfunc[{f@@varlist}~Join~conditions,vars,options]]

It can be used as follows:

NOptimize[NMinimize, a^2, a, AccuracyGoal->0.01]
(*
--> {2.39829*10^-33,{a->4.89724*10^-17}}
*)

or with constraints:

NOptimize[NMinimize, {a^2, a>3}, a, AccuracyGoal->0.01]
(*

--> {9.,{a->3.}}
*)

The following shows that it indeed solves the problem with LessEqual::Nord:

NOptimize[NMinimize,Abs[(a+I b)^(3/2)],{a,b}]
(*
--> {9.06219*10^-27,{a->4.31982*10^-18,b->4.8223*10^-19}}
*)