5 Details der Implementierung

5.2 Quelltextdokumentation

5.2.1 Paketanfang

5.2.2 Interne Darstellung

(* Translate term to internal restricted function space *)

ToInternal[f_,x_]:=f/;FreeQ[f,x];
ToInternal[x_,x_]:=x;
ToInternal[g_*h_,x_]:=ToInternal[g,x]*ToInternal[h,x];
ToInternal[g_+h_,x_]:=ToInternal[g,x]+ToInternal[h,x];
ToInternal[Power[g_,c_],x_]:=
    power[ToInternal[g,x],ToInternal[c,x]]/;FreeQ[c,x];
ToInternal[Power[E,g_],x_]:=power[E,ToInternal[g,x]];
ToInternal[Power[f_,g_],x_]:=power[E,log[ToInternal[f,x]]*ToInternal[g,x]];
ToInternal[Log[g_],x_]:=log[ToInternal[g,x]];

ToInternal[Sin[f_],x_]:=sin[ToInternal[f,x]];
ToInternal[Cos[f_],x_]:=cos[ToInternal[f,x]];
ToInternal[Tan[f_],x_]:=tan[ToInternal[f,x]];
ToInternal[Sec[f_],x_]:=1/cos[ToInternal[f,x]];
ToInternal[Csc[f_],x_]:=1/sin[ToInternal[f,x]];
ToInternal[Cot[f_],x_]:=1/tan[ToInternal[f,x]];

ToInternal[ArcSin[f_],x_]:=arcsin[ToInternal[f,x]];
ToInternal[ArcCos[f_],x_]:=arccos[ToInternal[f,x]];
ToInternal[ArcTan[f_],x_]:=arctan[ToInternal[f,x]];
ToInternal[ArcSec[f_],x_]:=arccos[1/ToInternal[f,x]];
ToInternal[ArcCsc[f_],x_]:=arcsin[1/ToInternal[f,x]];
ToInternal[ArcCot[f_],x_]:=arctan[1/ToInternal[f,x]];

ToInternal[Gamma[f_],x_]:=gamma[ToInternal[f,x]];
ToInternal[LogGamma[f_],x_]:=loggamma[ToInternal[f,x]];
ToInternal[PolyGamma[n_,f_],x_]:=polygamma[n,ToInternal[f,x]];

(* Pass-through if already in internal form: *)
ToInternal[power[f_,g_],x_]:=power[ToInternal[f,x],ToInternal[g,x]];
ToInternal[log[f_],x_]:=log[ToInternal[f,x]];
ToInternal[sin[f_],x_]:=sin[ToInternal[f,x]];
ToInternal[cos[f_],x_]:=cos[ToInternal[f,x]];
ToInternal[tan[f_],x_]:=tan[ToInternal[f,x]];
ToInternal[arcsin[f_],x_]:=arcsin[ToInternal[f,x]];
ToInternal[arccos[f_],x_]:=arccos[ToInternal[f,x]];
ToInternal[arctan[f_],x_]:=arctan[ToInternal[f,x]];
ToInternal[gamma[f_],x_]:=gamma[ToInternal[f,x]];
ToInternal[loggamma[f_],x_]:=loggamma[ToInternal[f,x]];
ToInternal[polygamma[n_,f_],x_]:=polygamma[n,ToInternal[f,x]];

(* Catch all remaining: *)
ToInternal[f_,x_]:=(
      Message[MrvLimit::"UnsupportedFunction",f];
      HoldForm[ToInternal[f,x]]
);

(* Remove all internal stuff: *)
FromInternal[f_,x_]:=
    f/.{log→Log,power→Power,sin→Sin,cos→Cos,
        tan→Tan,arcsin→ArcSin,arccos→ArcCos,
        arctan→ArcTan,gamma→Gamma,loggamma→LogGamma,
        polygamma→PolyGamma
    };

(* Some very basic simplification rules *)
SimpleSimplifications={
      power[z_,0]→1,
      power[z_,1]→z,
      power[E,log[z_]]→z,
      log[power[E,z_]]→z,
      power[power[z_,e_],-1]→power[z,-e],
      power[-power[z_,e_],-1]→-power[z,-e]
};

(* Display internal functions like public functions *)

log/:MakeBoxes[log[x_],form_]:=MakeBoxes[Log[x],form];
power/:MakeBoxes[power[x_,y_],form_]:=MakeBoxes[Power[x,y],form];

Unprotect[Times];
Times/:MakeBoxes[HoldPattern[Times[t___]],form_]:=Module[{h,i},
        h=HoldComplete[MakeBoxes[Times[t],form]];
        Do[
          If[h[[1,1,i,0]]===power,
              h[[1,1,i,0]]=Power;
          ];(*end if*)
          (*do for*),
          {i,1,Length[{t}]}
        ];
        ReleaseHold[h]
]/;MemberQ[{t},power[___]];
Protect[Times];

sin/:MakeBoxes[sin[x_],form_]:=MakeBoxes[Sin[x],form];
cos/:MakeBoxes[cos[x_],form_]:=MakeBoxes[Cos[x],form];
tan/:MakeBoxes[tan[x_],form_]:=MakeBoxes[Tan[x],form];
arcsin/:MakeBoxes[arcsin[x_],form_]:=MakeBoxes[ArcSin[x],form];
arccos/:MakeBoxes[arccos[x_],form_]:=MakeBoxes[ArcCos[x],form];
arctan/:MakeBoxes[arctan[x_],form_]:=MakeBoxes[ArcTan[x],form];
gamma/:MakeBoxes[gamma[x_],form_]:=MakeBoxes[Gamma[x],form];
loggamma/:MakeBoxes[loggamma[x_],form_]:=MakeBoxes[LogGamma[x],form];
polygamma/:MakeBoxes[polygamma[n_,x_],form_]:=MakeBoxes[PolyGamma[n,x],form];

5.2.3 Tools

(* General Tools *)

(* Extract context part of module variables *)
GetSymbolModuleContext[a_Symbol]:=Module[{n,p},
      n=SymbolName[Unevaluated[a]];
      p=StringPosition[n,"$"];
      If[p=={},"",StringDrop[n,p[[1,1]]-1]]
];
SetAttributes[GetSymbolModuleContext,HoldFirst];

(* Extract variable part of module variables *)
GetSymbolModuleName[a_Symbol]:=Module[{n,p},
      n=StringJoin[Context[Unevaluated[a]],SymbolName[Unevaluated[a]]];
      p=StringPosition[n,"$"];
      If[p=={},n,StringTake[n,p[[1,1]]-1]]
];
SetAttributes[GetSymbolModuleName,HoldFirst];

(* Translate module symbol name to global symbol name *)
Public[a_Symbol]:=Symbol[GetSymbolModuleName[Unevaluated[a]]];
SetAttributes[Public,HoldFirst];

(* Change a symbol's module context to a different one *)
SetModuleContext[a_Symbol,context_]:=
  Symbol[StringJoin[GetSymbolModuleName[Unevaluated[a]],context]]
SetAttributes[SetModuleContext,HoldFirst];

(* Nicht Teil des Quelltextes! *)

         Module[{Local,Link},
             Local = "Modul 1";
             Link = GetSymbolModuleContext[Local];
             Module[{Local},
                 Local = "Modul 2";
                 Print[Local];
                 (* Gibt "Modul 2" aus *)
                 Print[SetModuleContext[Local, Link]];
                 (* Gibt "Modul 1" aus *)
             ];
         ];

(* Variable options handler *)
(* Handles optional parameters of name→value form *)
(* Example: *)
(* MyFunction::"UnknownOption"=                              *)
(*   "MyFunction does not support this option: `1`";         *)
(* Options[MyFunction]={Foo→True,Bar→False};                *)
(* MyFunction[Baz_,Options___] := Module[{MyFoo,MyBar},      *)
(*   ReadOptions[MyFunction,{Foo→MyFoo,Bar→MyBar},Options]; *)
(*   Print["Foo=",MyFoo," Bar=",MyBar];                      *)
(* ];                                                        *)

Clear[ReadOptions];
ReadOptions[Caller_,OptionList_,OptionSeq___]:=Module[{FullOptions,pos},
      (* List of Option,Destination,Default *)
      FullOptions=Map[{#[[1]],Null,#[[2]]}&,Options[Caller]];
      
      (* Add Destinations *)
      Map[
        (FullOptions[[Position[FullOptions,{#[[1]],_,_}][[1,1]],2]]=#[[2]])&
        ,OptionList
      ];
      
      (* Process sequence of options, replace defaults if found *)
      Map[
        (
          If[!MatchQ[#,_→_],
            Message[Caller::"UnknownOption",#];
            (*else*),
            pos=Position[FullOptions,{#[[1]],_,_}];
            If[Length[pos]==0,
              Message[Caller::"UnknownOption",#]
              (*else*),
              FullOptions[[pos[[1,1]],3]]=#[[2]]
            ];
          ];
        )&,
        {OptionSeq}
      ];
      
      (* Assign results *)
      Map[(Evaluate[#[[2]]]=#[[3]])&,
        Select[FullOptions,!MatchQ[#,{_,Null,_}]&]];
];

(* Remove some options from a sequence of options *)
Clear[DropOptions];
DropOptions[DropOpts_,Options___]:=Module[{opt,i},
      opt={Options};
      Do[
        opt=Select[opt,(!MatchQ[#,DropOpts[[i]]→_])&];
        (*do on*),
        {i,1,Length[DropOpts]}
      ];
      Apply[Sequence,opt]
];

(* Debug Print function *)
(* IndentPrint allows to indent print output *)

IndentPrint[Spacing_,Text__]:=
    Print[DisplayForm[AdjustmentBox[ToBoxes[SequenceForm[Text]],BoxMargins->
                 {{Spacing,0}, {0, 0}}]]];

(* Interface to set own debug printing routines *)

$DebugPrint=IndentPrint;

(* Interface to modify debug and message output *)

$OutputProcessor=Identity;

(* Global Zero Test code *)

MrvTestZero[term_,x_]:=Simplify[FromInternal[term,x]==0];

$MrvTestZero=MrvTestZero;
(* test if constant is 0 *)

MrvTestZeroInterval[term_,x_→∞]:=
    Simplify[FromInternal[term,x]==0];

$MrvTestZeroInterval=MrvTestZeroInterval;
(* test if function is identical 0 in interval (x0,∞) for some x0. *) 

(* Sorry, no idea how to check this properly. *)

5.2.4 MrvSet

5.2.5 MrvSeriesHead

(* Calculate head of power series of f, dominant variable ω, 
  secondary variable x. *)
(* logω is a replacement term for Log[ω] and can be substituted 
at any time *)

(* Returns {u,ex} if leading term is u*ωex *)
(* May return u=0 only if f is identical 0. *)

(* SeriesHead *)
(* Tries hard to interprete the output of the Series[] command. *)
(* Returns {c,e} for leading term c*xe *)

Clear[SeriesHead];
SeriesHead[HoldPattern[SeriesData[x_,0,c_List,nmin_,nmax_,den_]],x_]:=
    If[$MrvTestZero[c[[1]],x],
        SeriesHead[SeriesData[x,0,Drop[c,1],nmin+1,nmax,den]]
        (*else*),
        {c[[1]],nmin/den}
        (*undetermined*),
        {c[[1]],nmin/den}
    ]/;Length[c]>0;

SeriesHead[f_,x_]:={f,0}/;FreeQ[f,x];
SeriesHead[c_.*x_e_.,x_]:={c,e}/;FreeQ[c,x];&&FreeQ[e,x];

SeriesHead[f_*g_,x_]:=Module[{sf,sg},
      sf=SeriesHead[f,x];
      sg=SeriesHead[g,x];
      If[!FreeQ[sf,SeriesHead]||!FreeQ[sg,SeriesHead],
        Return[sf*sg]
      ];
      Return[{sf[[1]]*sg[[1]],sf[[2]]+sg[[2]]}];
];

SeriesHead[f_+g_]:=Module[{sf,sg},
      sf=SeriesHead[f,x];
      sg=SeriesHead[g,x];
      If[!FreeQ[sf,SeriesHead]||!FreeQ[sg,SeriesHead],
        Return[sf+sg]
      ];
      If[sf[[2]]<sg[[2]],Return[sf]];
      If[sf[[2]]>sg[[2]],Return[sg]];
      If[sf[[2]]==sg[[2]],Return[{sf[[1]]+sg[[1]],sf[[2]]}]];
      Return[sf+sg];
];

• f die zu untersuchende Funktion,
• x die Variable, die nur die niedrigeren Wachstumsklassen repräsentiert und im Sinne unserer Potenzreihenentwicklung nur logarithmische Singularitäten darstellt,
• ω die Variable, die die relevante Wachstumsordnung repräsentiert und in der die Potenzreihe ermittelt werden soll (in $\omega =0$ mit $\omega >0$),
• logω der Wert von $ln\omega$ als Term in x und
• dprint ein Verweis auf die Debugausgabe-Funktion von MrvLimit für Debugmeldungen.

Clear[MrvSeriesHead];
MrvSeriesHead[f_,x_,ω_,logω_,dprint_]:=
    Module[{ser,serh,i,u,ex},
      
      (* Define some local auto simplifications *)
      Unprotect[Log];Unprotect[Power];
      Log[ω]=FromInternal[logω,x];
      Log[1/ω]=-Log[ω];
      Power[E,Log[ω]]=ω;
      Power[E,Log[1/ω]]=1/ω;
      Protect[Log];Protect[Power];

      (* Call Series with increasing order to find terms *)
      (* Ugly, but not to avoid. *)
      Do[
        ser=Series[FromInternal[f,x],{ω,0,i}];
        serh=SeriesHead[ser,ω];
        
        (* check for series term that run out of precision *)
        If[FreeQ[serh,HoldPattern[SeriesData[_,_,{},_,_,_]]],
          (* No: done. *)
          Break[];
        ];
        
        (* Increase precision and continue *)
        
        (* do for *)
        ,{i,1,30}
      ]; (* end do *)

      
      (* Remove local auto simplifications *)
      Unprotect[Log];Unprotect[Power];
      Power[E,Log[ω]]=.;
      Power[E,Log[1/ω]]=.;
      Log[ω]=.;
      Log[1/ω]=.;
      Protect[Log];Protect[Power];
      
      dprint["Series expansion: ",$OutputProcessor[ser]];
      
      If[!FreeQ[serh,SeriesHead],
        (* SeriesHead could not interprete the result *)
        If[!FreeQ[serh,HoldPattern[SeriesData[_,_,{},_,_,_]]],
          (* No leading terms found *)
          Message[MrvLimit::"SeriesNoTerms",$OutputProcessor[f]];
          Return[Null];
        ];
        Message[MrvLimit::"SeriesFail",$OutputProcessor[f]];
        Return[Null];
      ]; (* end if *)

      {u,ex}=serh;
      
      (* Check if Series succeded in eliminating ω *)
      If[!FreeQ[u,ω],
        Message[MrvLimit::"SeriesFail",$OutputProcessor[f]];
        Return[Null];
      ];
      
      u=ToInternal[u,x];
      If[!FreeQ[u,ToInternal],
        Return[Null];
      ];
      ex=ToInternal[ex,x];
      If[!FreeQ[ex,ToInternal],
        Return[Null];
      ];
      {u,ex}
]; (* end MrvSeriesHead *)

$MrvSeriesHead=MrvSeriesHead;

5.2.6 MrvLimit Tools

(* Helper that interprets leading term results *)

MrvLimitLeadTermDominant[asympt_List]:=Module[{i},
      i=1;
      While[i≤Length[asympt] && asympt[[i,2]]==0,i++];
      If[i>Length[asympt],Return[Null]];
      Return[i];
];

Clear[MrvLimitOutput];
MrvLimitOutput[LeadTerm[const_,asympt_List],Output→Limit]:=
    Module[{i,ex},
      i=MrvLimitLeadTermDominant[asympt];
      
      If[i===Null,Return[const]]; (* All exponents are 0, 
        const is the result. *)
      ex=asympt[[i,2]]; (* Exponent of leading term *)
      If[ex>0,Return[0]];(* tends to 0 in all cases *)
      If[ex<0 ,
         (* limit result is +/- ∞ *)
        s=Sign[const];
        If[s===0,
          Message[MrvLimit::"ZeroFunction"];
          Return[Null];
        ];
        Return[s*∞]
      ]; (* end if ex < 0 *)
      Message[MrvLimit::"UnknownSign",ex];
]; (* end MrvLimitOutput *)

MrvLimitOutput[LeadTerm[const_,asympt_List],Output→LeadTerm]:=
    LeadTerm[const,asympt];

MrvLimitOutput[LeadTerm[const_,asympt_List],Output→SignedZero]:=
    Module[{l},
      l=MrvLimitOutput[LeadTerm[const,asympt],Output→Limit];
      If[l===0,Return[Sign[const]*Zero]];
      Return[l];
];

(* Mrv limit remember cache *)
MrvLimitClearCache[]:=Module[{},
      Clear[MrvLimitCache];
      MrvLimitCacheHits=0;
      MrvLimitCacheMisses=0;
];
MrvLimitClearCache[];
MrvLimitGetCacheStats[]:={CacheHits->MrvLimitCacheHits,
    CacheMisses->MrvLimitCacheMisses}

5.2.7 MrvLimitPreProcess

(* Pre-Processing: 
      Transform expression into processable form and check for limit fail 
conditions. *)

TestLimitArgQ[f_,x_,test_,Undetermined→undet_]:=Module[{ff},
      (* test if limit exists and matches a test criteria *)
      ff=MrvLimitInf[f,x];
      If[ff===Null,Return[False]];
      If[test[ff],
        (*then*)
        Return[True];
        ,(*else*)
        Return[False];
        ,(*undetermined*)
        If[undet===True,Return[True]];
        If[undet===False,Return[False]];
        Message[MrvLimit::"ConditionCheck",test[ff]];
        Return[False];
        ];
      ];
TestLimitArgQ[f_,x_,test_]:=TestLimitArgQ[f,x,test,Undetermined→-1];

Clear[MrvLimitPreProcess];
MrvLimitPreProcess[f_,x_]:=f/;FreeQ[f,x];
MrvLimitPreProcess[x_,x_]:=x;
MrvLimitPreProcess[g_*h_,x_]:=
    MrvLimitPreProcess[g,x]*MrvLimitPreProcess[h,x];
MrvLimitPreProcess[g_+h_,x_]:=
    MrvLimitPreProcess[g,x]+MrvLimitPreProcess[h,x];
MrvLimitPreProcess[power[g_,c_],x_]:=
    power[MrvLimitPreProcess[g,x],MrvLimitPreProcess[c,x]]/;FreeQ[c,x];
MrvLimitPreProcess[power[E,g_],x_]:=power[E,MrvLimitPreProcess[g,x]];
MrvLimitPreProcess[power[f_,g_],x_]:=
    power[E,log[MrvLimitPreProcess[f,x]]*MrvLimitPreProcess[g,x]];

MrvLimitPreProcess[log[f_],x_]:=log[MrvLimitPreProcess[f,x]];
MrvLimitPreProcess[sin[f_],x_]:=
    If[TestLimitArgQ[f,x,FreeQ[#,DirectedInfinity]&],
      sin[MrvLimitPreProcess[f,x]],
      Message[MrvLimit::"UnsupportedArgument",Sin[x],x→∞,
        Sin[f]];
      HoldForm[MrvLimitPreProcess[sin[f],x]]
    ];

MrvLimitPreProcess[cos[f_],x_]:=
    If[TestLimitArgQ[f,x,FreeQ[#,DirectedInfinity]&],
      cos[MrvLimitPreProcess[f,x]]
      (*else*),
      Message[MrvLimit::"UnsupportedArgument",Cos[x],x→∞,
        Cos[f]];
      HoldForm[MrvLimitPreProcess[cos[f],x]]
    ];
MrvLimitPreProcess[tan[f_],x_]:=
    If[TestLimitArgQ[f,x,FreeQ[#,DirectedInfinity]&],
      tan[MrvLimitPreProcess[f,x]]
      (*else*),
      Message[MrvLimit::"UnsupportedArgument",Tan[x],x→∞,
        Tan[f]];
      HoldForm[MrvLimitPreProcess[tan[f],x]]
    ];
MrvLimitPreProcess[arcsin[f_],x_]:=
    If[TestLimitArgQ[f,x,(Abs[#]≤1)&],
      arcsin[MrvLimitPreProcess[f,x]]
      (*else*),
      Message[MrvLimit::"UnsupportedArgument",ArcSin[x],x→∞,
        ArcSin[f]];
      HoldForm[MrvLimitPreProcess[arcsin[f],x]]
    ];
MrvLimitPreProcess[arccos[f_],x_]:=
    If[TestLimitArgQ[f,x,(Abs[#]≤1)&],
      arccos[MrvLimitPreProcess[f,x]]
      (*else*),
      Message[MrvLimit::"UnsupportedArgument",ArcCos[x],x→∞,
        ArcCos[f]];
      HoldForm[MrvLimitPreProcess[arccos[f],x]]
    ];
MrvLimitPreProcess[arctan[f_],x_]:=If[TestLimitArgQ[f,x,(True)&],
      arctan[MrvLimitPreProcess[f,x]]
      (*else*),
      Message[MrvLimit::"UnsupportedArgument",ArcTan[x],x,ArcTan[f]];
      HoldForm[MrvLimitPreProcess[arctan[f],x]]
    ];
MrvLimitPreProcess[gamma[f_],x_]:=
    If[TestLimitArgQ[f,x,FreeQ[#,DirectedInfinity]&],
      gamma[MrvLimitPreProcess[f,x]]
      (*else*),
      If[TestLimitArgQ[f,x,(#===∞)&],
        power[E,loggamma[MrvLimitPreProcess[f,x]]]
        (*else*),
        Message[MrvLimit::"UnsupportedArgument",Gamma[x],
          x→MrvLimitInf[f,x],Gamma[f]];
        HoldForm[MrvLimitPreProcess[gamma[f],x]]
      ]
    ];

MrvLimitPreProcess[loggamma[f_],x_]:=
    If[TestLimitArgQ[f,x,(0≤#≤∞)&],
      loggamma[MrvLimitPreProcess[f,x]]
      (*else*),
      Message[MrvLimit::"UnsupportedArgument",LogGamma[x],
        x→MrvLimitInf[f,x],LogGamma[f]];
      HoldForm[MrvLimitPreProcess[loggamma[f],x]]
    ];

MrvLimitPreProcess[polygamma[n_,f_],x_]:=Module[{},
      If[!IntegerQ[n]||n<0,
        Message[MrvLimit::"UnsupportedArgument",PolyGamma[k,x],k==n,
          PolyGamma[n,f]];
        Return[HoldForm[MrvLimitPreProcess[polygamma[n,f],x]]];
      ];
      If[TestLimitArgQ[f,x,(-∞<#≤∞)&],
        Return[polygamma[n,f]];
      ];
      Message[MrvLimit::"UnsupportedArgument",PolyGamma[n,x],
        x→MrvLimitInf[f,x],PolyGamma[n,f]];
      Return[HoldForm[MrvLimitPreProcess[polygamma[n,f],x]]];
    ];

(* catch all remaining *)
MrvLimitPreProcess[f_,x_]:=(
      Message[MrvLimit::"UnsupportedFunction",f];
      HoldForm[MrvLimitPreProcess[f,x]]
);

5.2.8 MrvLimitInf

(* MrvLimitInf: Main algorithm *)

(* Reset Context links *)
MrvLimitCurrentContext=Null;
Clear[MrvLimitRunningTasks];
MrvLimitDefaultDebugLevel=0;

Clear[MrvLimitInf];
Options[MrvLimitInf]={Output→Limit,Debug→Automatic};
MrvLimitInf[ff_,x_,Options___]:=Module[
      {Ω,dprint,f,scaleup,w,g,A,s,t,c,a,ex,asympt,i,LastContext,
        NestLevel,DebugLevel,output},
      
      ReadOptions[MrvLimitInf,{Output→output,Debug→DebugLevel},
        Options];
      
      If[!MemberQ[{Limit,LeadTerm,SignedZero},output],
        Message[MrvLimit::"UnknownOutput", output];
        output=Limit;
      ];

      (* Some quick exits for really simple terms *)
      If[FreeQ[ff,x],
        If[output===LeadTerm,Return[LeadTerm[ff,{}]]];
        Return[ff];
      ];

      (* Check if previous MrvLimit context is still alive *)
      If[MrvLimitCurrentContext=!=Null,
        If[!NameQ[
                StringJoin[GetSymbolModuleName[LastContext],
                  MrvLimitCurrentContext]],
            (* Last context died unexpected. *)
            Message[MrvLimit::"LostContext"];
            MrvLimitCurrentContext=Null;
            Clear[MrvLimitRunningTasks];
        ];
      ]; (* end if *)

      (* Connect to last context if present. *)
      (* From here on, clean exit code is requred. *)
      LastContext=MrvLimitCurrentContext;
      MrvLimitCurrentContext=GetSymbolModuleContext[LastContext];

      Catch[
          (* 
            Catch/Throw error handling from here. 
                Throw[] uses clean exit code. *)

          (* Get MrvLimit nest level *)
          
          NestLevel=
            If[LastContext===Null,1,
              SetModuleContext[NestLevel,LastContext]+1];
          
          (* Get Debug level *)
          If[DebugLevel===Automatic,
            
            DebugLevel=
                If[LastContext===Null,MrvLimitDefaultDebugLevel,
                  SetModuleContext[DebugLevel,LastContext]];
          ];

          (* Prepare dprint based on DebugLevel *)
          If[DebugLevel≥NestLevel
            (*then*),
            dprint[s__]:=$DebugPrint[NestLevel-1,s];
            
            dprint["Enter Level ",NestLevel,
              " Call ",$OutputProcessor[
                HoldForm[MrvLimitInf[ff,x,Options]]]];
            (*else*),
            dprint[s__]=Null;
          ];(*end if*)
          SetAttributes[dprint,HoldAll];

          
          (* Check for cached result *)
          asympt=MrvLimitCache[ff];
          If[Head[asympt]=!=MrvLimitCache,
            (*found in cache*)
            
            MrvLimitCacheHits++;
            dprint["Taking cached result"];
            
            Throw[MrvLimitOutput[asympt,Output→output]];
            
            (*else if Length[i]>0*),
            MrvLimitCacheMisses++;
          ]; (* end if Length[i]>0 *)
          
          (* Check for recursive calls *)
          If[MrvLimitRunningTasks[ff],
            Message[MrvLimit::"RecursiveCall",ff];
            Return[Null];
          ];
          
          (* Mark this task 'in progress' for recursive call checking *)
          MrvLimitRunningTasks[ff]=True;

          
          (*************************************)
          (* Ok, lets start with the real work *)
          (*************************************)
          
          f=ff;
          If[$MrvTestZeroInterval[f,x→∞],
            (* Function is identical 0 around ∞. 
                    Dont start to calculate crap with it... *)
            Throw[0];
          ];

          asympt={};
          (* Result is f*Apply[Times,asympt]/.pwr→Power , 
            while asympt is a dominance ordered list of pwr[w,ex], 
            w tends to 0 for x→0.
            *)

          While[!FreeQ[f,x],
            (* While f depends on x: Do Mrv limit calculation *)

            dprint["Calculating limit of ",$OutputProcessor[f]];
            
            (* First, do pre-processing for some functions *)
            f=MrvLimitPreProcess[f,x];
            If[!FreeQ[f,MrvLimitPreProcess],
              dprint["Pre Processing failed  :",$OutputProcessor[f]];
              Throw[Null];
            ];

5.2.9 MrvLimit

(* MrvLimit interface code *)

Clear[MrvLimit];
Options[MrvLimit]={Output→Limit,Debug→Automatic,
      Direction→Automatic,ClearCache→False};
MrvLimit[ff_,x_→lim_,Options___]:=
    Module[{Res,ResA,ResB,f,z,direction,lim1,ChildOptions,clearcache},
      ReadOptions[
        MrvLimit,{Direction→direction,ClearCache→clearcache},
        Options];
      
      (* Remove Direction→ and ClearCache→ options *)
      ChildOptions=DropOptions[{Direction,ClearCache},Options];

      
      If[clearcache,
        MrvLimitClearCache[];
      ];
      
      (* Delete lost contexts *)
      MrvLimitCurrentContext=Null;
      Clear[MrvLimitRunningTasks];

      f=ToInternal[ff,x];
      If[!FreeQ[f,ToInternal],
        Return[HoldForm[MrvLimit[ff,x→lim,Options]]];
      ];

      lim1=lim;
      If[direction===Automatic,
        (* Set auto direction *)
        Which[
            Head[lim]===Global`SuperPlus,(direction=-1;lim1=lim[[1]]),
            Head[lim]===Global`SuperMinus,(direction=1;lim1=lim[[1]]),
            (* 
              hell knows why I have to explicitly request global context. 
                  Wont work otherwise.*)
            lim===∞,direction=1,
            lim===-∞,direction=-1,
            True,direction=0
        ];
      ];