ArcNem

File:Arcnem1nap.jpg
$$u\!+\!\mathrm i v=\mathrm{ArcNem}_1(x\!+\!\mathrm i y)$$ $$y\!=\!\mathrm{ArcNem}_{q}(x)$$ versus $$x$$ for various $$q$$

ArcNem is one of inverse functions of the Nemtsov function,

$$\mathrm{Nem}_q(z)=z+z^3+qz^4$$

where $$q$$ is positive parameter. It can be indicated as subscript.

ArcNem is characterises with positions of the cut lines; they go from the branch points to $$\mathrm i \infty$$ in the upper part of the complex plane and to $$-\mathrm i \infty$$ in the lower part.

For case $$q\!=\!1$$, the complex map of function ArcNem is shown in figure.

Description

Function ArcNem is implemented in order to extend the range of holomorphism of the abelfunction Nemtsov function.

The naive inverse function, that grows from zero to infinity along the positive part of the real axis can be generated tithe mathematica code

Solve[ f+f^3+q f^4=z, f]

This code returns 4 solutions. The 3d solution is denoted with Ar3Nem. It grows from zero to infinity along the positive part of the real axis, following the intuitive expectation about it. However, the cut lines limit the range of holomorphism of the resulting abelfunction.

So, the 3 modifications are implemented: ArcNem, ArkNem and ArqNem.

each of them happen to be better than its precedent in the sense of range of holomorphism of the resulting abelfunction. The last one, ArqNem, is used for the implementation of function AuNem.

For positive values $$x$$ of the argument, these four functions coincide:

ArcNem$$_q(x)=$$ Ar3Nem$$_q(x)=$$ ArkNem$$_q(x)=$$ ArqNem$$_q(x)$$

Explicit plot of this function is shown in figure for various values of $$q$$.

Function ArcNem$$_q(z)$$ has 3 branchponts. one of them is at the negative part of the real axis; two other are expressed through function Nembran:

$$z=\pm$$ NemBran$$(q)$$

From these two points, at the complex plane, the cut lines go vertically to $$\pm \mathrm i \infty$$. These cut lines divide the complex plane to two part, connected only by "bridge" between points $$\pm$$ NemBran$$(q)$$

This behaviour is not so good for testing of the implementation of iterates of the Nemtsov function; so, functions ArkNem and ArqNem are also implemanated.

C++ implementation

// The code below uses the routine nembran.cin to evaluate the branch point NemBran of the ArcNem at given value of parameter $$q$$. Value or the branch point is stored in global variables tr, ti.

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#define DB double
#define DO(x,y) for(x=0;x<y;x++)
#include <complex>
typedef std::complex<double> z_type;
#define Re(x) x.real()
#define Im(x) x.imag()
#define I z_type(0.,1.)
#include "conto.cin"
DB Q=1.; //WARNING! GLOBAL VARIABLE! Set it value if not unity.
z_type nem(z_type z){ return z*(1.+z*z*(1.+z*Q)); }
z_type nem1(z_type z){ return 1.+z*z*(3.+z*(4.*Q)); } // WARNING: Q is global!
#include"nembran.cin"
z_type NemZo=nembra(Q);
z_type ANemZo=nem(NemZo);
DB tr=Re(ANemZo);
DB ti=Im(ANemZo);

//#include"nembran.cin"

z_type arnemU(z_type z){ DB q=Q; DB q2=q*q; DB q3=q2*q;
z_type a=q-z; z_type b=1.+4.*q*z; z_type r=81.*(a*a)+12.*(b*b*b);
z_type R=-I*sqrt(-r);
z_type s=27.*a + 3.*R; z_type S=pow(s,1./3.);
z_type B=(0.26456684199469993*S)/q - (1.2599210498948732*b)/(q*S);
z_type h=0.25/q2 + B;
z_type H=I*sqrt(-h);
z_type g=0.5/q2 - B + (.25+2.*q2)/(q3*H);
z_type G=I*sqrt(-g);
return - 0.25/q - 0.5*H + 0.5*G ;}

z_type arnemD(z_type z){ DB q=Q; DB q2=q*q; DB q3=q2*q;
z_type a=q-z; z_type b=1.+4.*q*z; z_type r=81.*(a*a)+12.*(b*b*b);
z_type R=I*sqrt(-r);
z_type s=27.*a + 3.*R; z_type S=pow(s,1./3.);
z_type B=(0.26456684199469993*S)/q - (1.2599210498948732*b)/(q*S);
z_type h=0.25/q2 + B;
z_type H=-I*sqrt(-h);
z_type g=0.5/q2 - B + (.25+2.*q2)/(q3*H);
z_type G=-I*sqrt(-g);
return - 0.25/q - 0.5*H + 0.5*G ;}

z_type arnemR(z_type z){ DB q=Q; DB q2=q*q; DB q3=q2*q;
z_type a=q-z; z_type b=1.+4.*q*z; z_type r=81.*(a*a)+12.*(b*b*b);
z_type R=sqrt(r); z_type s=27.*a + 3.*R;
z_type S=pow(s,1./3.);
z_type B=(0.26456684199469993*S)/q - (1.2599210498948732*b)/(q*S);
z_type h=0.25/q2 + B;
z_type H=sqrt(h);
z_type g=0.5/q2 - B + (.25+2.*q2)/(q3*H);
z_type G=sqrt(g);
return - 0.25/q - 0.5*H + 0.5*G ;}

z_type arnemL(z_type z){ DB q=Q; DB q2=q*q; DB q3=q2*q;
z_type a=q-z; z_type b=1.+4.*q*z; z_type r=81.*(a*a)+12.*(b*b*b);
z_type R=-sqrt(r);
z_type s=27.*a + 3.*R;
z_type S=pow(s,1./3.);
z_type B=(0.26456684199469993*S)/q - (1.2599210498948732*b)/(q*S);
z_type h=0.25/q2 + B;
z_type H=sqrt(h);
z_type g=0.5/q2 - B + (.25+2.*q2)/(q3*H);
z_type G=sqrt(g);
return - 0.25/q - 0.5*H + 0.5*G ;}

z_type arqnem(z_type z){ DB x,y; x=Re(z);y=Im(z);
if( y>ti || (x<0 && y>=0)) return arnemU(z);
//if(y<0) return conj(arnemU(conj(z)));
if(y<-ti || (x<0 && y<=0)) return arnemD(z);
if(x*ti>fabs(y)*tr) return arnemR(z);
return arnemL(z);}

z_type arcnem(z_type z){ DB x,y; x=Re(z);y=Im(z);
if( y>ti && x>tr ) return arnemU(z);
//if(y<0) return conj(arnemU(conj(z)));
if(y<-ti && x>tr ) return arnemD(z);
//if(x*ti>fabs(y)*tr)
return arnemR(z);
//return arnemL(z);
}

/* Function ArcNem above is evaluated by one of very similar routines, arnemU, arnemD, arnemR, arnemL; they differ only in the way variable $$H$$ is expressed through variable $$h$$ and variable $$R$$ is expressed through variable $$r$$

$$H=\sqrt{h}$$, $$H=-\sqrt{h}$$, $$H=\mathrm i \sqrt{-h}$$, or $$H=-\mathrm i \sqrt{-h}$$, and the same about relation between variables R,r and G,g; dependently on value of the argument, the coresponding branch of function sqrt is used, in order to provide the desirable position of the cut lines. */