Services & ResourcesWolfram ForumsMathGroup Archive

[Date Index] [Thread Index] [Author Index]

Re: NMinimize problem: fct minimized uses FindRoot

• To: mathgroup at smc.vnet.net
• Subject: [mg123709] Re: NMinimize problem: fct minimized uses FindRoot
• From: "Oleksandr Rasputinov" <oleksandr_rasputinov at hmamail.com>
• Date: Fri, 16 Dec 2011 05:47:51 -0500 (EST)
• Delivered-to: l-mathgroup@mail-archive0.wolfram.com
• References: <201112141102.GAA10218@smc.vnet.net> <jccgq9$ml4$1@smc.vnet.net>

On Thu, 15 Dec 2011 10:06:01 -0000, Oliver Ruebenkoenig  
<ruebenko at wolfram.com> wrote:

>
> Just for comepletness sake:
>
> this does work
>
> cf = Compile[{{n, _Integer}},
>    Module[{res = 0}, Do[res += i; If[res > 10, Throw[0, cfe]], {i, n}];
>      res]]
>
> Catch[cf[111], cfe]
>
>
> Related:
> http://stackoverflow.com/questions/8184548/do-return-behave-differently-in-compile-why/8194565#8194565
>
> Oliver
>

Well, sort of.

cf // InputForm

reveals the MainEvaluate call (opcode 46):

CompiledFunction[{8, 8., 5468}, {_Integer}, {{2, 0, 0}, {2, 0, 2}}, {{0,  
{2, 0, 1}}, {10, {2, 0, 5}}}, {1, 7, 0, 0, 0},
{{6, 1, 2}, {6, 0, 3}, {6, 1, 4}, {3, 7}, {12, 2, 4, 6}, {6, 6, 2}, {25,  
5, 2, 0}, {2, 0, 3},
{46, Function[{n}, Throw[0, cfe]], {i, 2, 0, 4, Block}, 2, 0, 0, 6, 0,  
17}, {3, 1}, {4, 4, 3, -6}, {1}},
Function[{n}, Module[{res = 0}, Do[res += i; If[res > 10, Throw[0, cfe]],  
{i, n}]; res]], Evaluate]

so the advantage of the two-argument Throw in this case appears limited  
versus, say,

cf = Compile[{{n, _Integer}},
  Catch@Module[{res = 0},
   Do[res += i; If[res > 10, Throw[0]], {i, n}];
   res
  ]
]

which does the same thing without requiring any MainEvaluate calls.

Also:

cf2 = Compile[{{n, _Integer}},
   Catch[
    Module[{res = 0},
     Do[res += i; If[res > 10, Throw[0, cfe]], {i, n}];
     res
    ], cfe
   ]
  ]

Catch::argx: Catch called with 2 arguments; 1 argument is expected.

cf2 // InputForm

CompiledFunction[{8, 8., 5468}, {_Integer}, {{2, 0, 0}, {3, 0, 0}}, {},  
{0, 1, 1, 0, 0},
{{46, Function[{n}, Catch[Module[{res = 0}, Do[res += i; If[res > 10,  
Throw[0, cfe]], {i, n}]; res], cfe]], 2, 0, 0, 3, 0, 0}, {1}},
Function[{n}, Catch[Module[{res = 0}, Do[res += i; If[res > 10, Throw[0,  
cfe]], {i, n}]; res], cfe]], Evaluate]

which is not compiled at all. So neither Throw/Catch nor Return can accept  
two arguments when used in compiled code proper (i.e. not wrapped in  
MainEvaluate). The advantage of the latter, of course, is that the  
location it returns to is indicated by context without requiring a second  
argument to describe it, which is just as well since the locations Return  
will or will not return to appear to be somewhat arbitrary choices as you  
point out in your StackOverflow posting. I suppose one can use Label/Goto  
to replicate the behaviour of two-argument forms in compiled code if  
absolutely necessary, although this seems fairly anachronistic.

• Follow-Ups:
  • Re: NMinimize problem: fct minimized uses FindRoot
    • From: Oliver Ruebenkoenig <ruebenko@wolfram.com>

• References:
  • Re: NMinimize problem: fct minimized uses FindRoot
    • From: "Oleksandr Rasputinov" <oleksandr_rasputinov@hmamail.com>