struct Complex(Re,Im)

Eps: real = 0.001;

fn Sign R =
(
     local A=1
     if R<0 then A=-1
     return A
)

fn CompNeg X = 

(
     local M=Complex -(X.Re) -(X.Im)
     return M
)

fn CompSum X Y = (Complex (X.Re+Y.Re) (X.Im+Y.Im))

fn CompSub X Y = (Complex (X.Re-Y.Re) (X.Im-Y.Im))

fn CompMul X Y = (Complex (X.Re*Y.Re-X.Im*Y.Im) (X.Re*Y.Im+Y.Re*X.Im))

fn CompDiv X Y &bum = 
(
      Success=TRUE
      if ((Sqr Y.Re)+(Sqr Y.Im))<0.001 then Success=FALSE
      local Q1=Double(X.Re)*Double(Y.Re)
      local Q2=Double(X.Im)*Double(Y.Im)
      local V1=Double(Q1+Q2)/Double(Sqr(Y.Re)+Sqr(Y.Im))
      local V2=Double(Y.Re*X.Im-X.Re*Y.Im)/Double(Sqr(Y.Re)+Sqr(Y.Im))
     bum = Complex V1 V2
     return Success
)

fn CompSqr X = (CompMul X X)

fn CompSqrt X =
(
     local A1=X.Re*X.Re
     local B1=X.Im*X.Im
     local C1=Sqrt (A1+B1)
     local D1=C1+X.Re
     local AU=D1/2
     AU=Sqrt AU
     local D1=(C1-X.Re)/2
     local BU=(Sign X.Im)*(Sqrt D1)
     M=Complex AU BU     
     Return M 
)

fn Diskr P1 P2 P3 P4 P5 P6 P7 P8 P9 =
(
     return P1*P5*P9+P4*P8*P3+P7*P2*P6-P7*P5*P3-P1*P8*P6-P4*P2*P9;
) -- Diskr

fn DiskrComp P1 P2 P3 P4 P5 P6 P7 P8 P9 =
(
     local S1 = CompMul P1 (CompMul P5 P9)
     local S2 = CompMul P4 (CompMul P8 P3)
     local S3 = CompMul P7 (CompMul P2 P6)
     local S4 = CompMul P7 (CompMul P5 P3)
     local S5 = CompMul P1 (CompMul P8 P6)
     local S6 = CompMul P4 (CompMul P2 P9)
     local D1 = CompSum S1 (CompSum S2 S3)
     local D2 = CompSum S4 (CompSum S5 S6)
     CompSub D1 D2
) -- DiskrComp

fn Sc X1 Y1 X2 Y2 &S1 &C1 &Dl =
(
     local Prizn=FALSE
     local Dx=X2-X1 
     local Dy=Y2-Y1 
     local Dll=Sqrt(Dx*Dx+Dy*Dy) 
     if Dll>0 then
     (
               local S1=Float(Dy)/Float(Dll)
               local C1=Float(Dx)/Float(Dll)
               local Prizn=TRUE
     )
     return Prizn
) -- Sc

fn ArcSin X =
(
     if (X>-1.) and (X<1.)  then local A=atan(X/Sqrt(1.-Sqr(X)))*Pi/180
     if (X>=1.-Sqr(Eps*Eps)) then A=PI/2;
     if (X<=-1.+Sqr(Eps*Eps)) then A=PI/2;
    return A
) -- ArcSin

fn ArcCos X =
(
     local A=Pi/2-ArcSin X
     return A
) -- ArcCos

fn Fi Sa Ca Sb Cb =
(
     Fi2=ArcSin(Sb)
     if (Sa>=0) and (Ca>=0) then Fi1=ArcSin(Sa)
     if (Sa>=0) and (Ca<0) then Fi1=Pi-ArcSin(Sa)
     if (Sa<0) and (Ca>=0) then Fi1=ArcSin(Sa)
     if (Sa<0) and (Ca<0) then Fi1=-Pi-ArcSin(Sa)
     if (Sb>=0) and (Cb>=0) then Fi2=ArcSin(Sb)
     if (Sb>=0) and (Cb<0) then Fi2=Pi-ArcSin(Sb)
     if (Sb<0) and (Cb>=0) then Fi2=ArcSin(Sb)
     if (Sb<0) and (Cb<0) then Fi2=-Pi-ArcSin(Sb)
     return Fi2-Fi1
) -- Fi

fn LinLin X1 Y1 X2 Y2 X3 Y3 X4 Y4 &XX &YY &ZZ =
(     
     Prizn=FALSE
     A1=Y1-Y2 
     B1=X2-X1
     A2=Y3-Y4 
     B2=X4-X3
     ZZ=A1*B2-B1*A2
     
     if Abs(ZZ)>1E-2 then
     (
          C1=X1*Y2-Y1*X2
          C2=X3*Y4-Y3*X4
          XX=Float(B1*C2-C1*B2)/Float(ZZ)
          YY=Float(C1*A2-A1*C2)/Float(ZZ)
          ZZ=1
          Prizn=TRUE
     )
    
     if (Abs(ZZ)<=1E-2) or (Abs(XX)>1000000000) or (Abs (YY)>1000000000) then
     (
          XX=B1
          YY=-A1
          ZZ=0
     )
     
     return Prizn
) -- LinLin

fn ProcA X1 Y1 X2 Y2 &Xt &Yt V &XD = 
(
     Result=FALSE
     Ldummy=SC X1 Y1 X2 Y2 &S &C &Dl  
     Df= Fi 0 1 S C 
     Dx=90.*Float(Pi/180.)+Df
     X3=Xt+200.*Cos(Dx/Pi*180) 
     Y3=Yt+200.*Sin(Dx/Pi*180) 
     X4=Xt-200.*Cos(Dx/Pi*180) 
     Y4=Yt-200.*Sin(Dx/Pi*180) 
     Prizn=LinLin X1 Y1 X2 Y2 X3 Y3 X4 Y4 &Xt1 &Yt1 &C
     A=Sqr(Xt-Xt1)
     B=Sqr(Yt-Yt1)
     XD=Sqrt(A+B)

     if XD< V then
     (
          Result=TRUE
          Xt=Xt1
          Yt=Yt1
     )
     return Result 
 ) -- ProcA

function LinLinComp X1 Y1 X2 Y2 X3 Y3 X4 Y4 &XXA &YYA &ZZA =
(
     Prizn=FALSE
     
     if (X1.Im==0.) and (X2.Im==0.) and (X3.Im==0.) and (X4.Im==0.) and (Y1.Im==0.) and (Y2.Im==0.) and (Y3.Im==0.) and (Y4.Im==0.) then
     (
          V=0.0001;
          BB=ProcA X1.Re Y1.Re X2.Re Y2.Re &X3.Re &Y3.Re V  &XD 
          BBB=ProcA X1.Re Y1.Re X2.Re Y2.Re &X4.Re &Y4.Re V  &XD
          if BB and BBB then
          (
               B1=CompSub X2 X1
               A1=CompSub Y1 Y2
               XXA=B1
               YYA=CompSub(Complex 0. 0.) A1
               ZZA=Complex 0. 0. 
               return Prizn
               Exit
          )
     )
     
     A1=CompSub Y1 Y2 
     B1=CompSub X2 X1
     A2=CompSub Y3 Y4 
     B2=CompSub X4 X3 
     ZZA=CompSub (CompMul A1 B2) (CompMul B1 A2)

     if (Abs(ZZA.Re)>1E-25) or (Abs(ZZA.Im)>1E-25) then
     (
          C1=CompSub(CompMul X1 Y2) (CompMul Y1 X2)
          C2=CompSub(CompMul X3 Y4) (CompMul Y3 X4)
           
          U1=CompMul B1 C2 
          U2=CompMul C1 B2 
          U3=CompSub U1 U2 
          B=CompDiv U3 ZZA &XXA
           
          U1=CompMul C1 A2 
          U2=CompMul A1 C2 
          U3=CompSub U1 U2 
          B=CompDiv U3 ZZA &YYA           
                            
         --  B=CompDiv(CompSub(CompMul B1 C2) (CompMul(C1 B2))) ZZ  &XX)
         --  B=CompDiv(CompSub(CompMul C1 A2) (CompMul(A1 C2))) ZZ &YY)
          ZZA=Complex 1. 0.
          Prizn=TRUE
     )

     --     print ZZA
     --     print XXA
     --     print YYA

     if (Abs(ZZA.Re)<=1E-25) or (Abs(XXA.Re)>1000000000.) or (Abs(YYA.Re)>1000000000.) then
      (
          XXA=B1
          YYA=CompSub(Complex 0. 0.) A1
          ZZA=Complex 0. 0.
     )
            
     return Prizn
) -- LinLinComp

fn ComDuga Xc1 Yc1 Xc2 Yc2 R1 R2 &X1 &Y1 &X2 &Y2 =
(
     DeltaX=CompSub Xc2 Xc1
     DeltaY=CompSub Yc2 Yc1
     R1_2=CompMul R1 R1
     R2_2=CompMul R2 R2
     Xc1_2=CompMul Xc1 Xc1
     Xc2_2=CompMul Xc2 Xc2
     Yc1_2=CompMul Yc1 Yc1 
     Yc2_2=CompMul Yc2 Yc2
     UU=CompSub R1_2 R2_2 
     UU=CompSub UU Yc1_2
     UU=CompSum UU Yc2_2
     UU=CompSub UU Xc1_2 
     UU=CompSum UU Xc2_2
     DeltaX_2=CompMul DeltaX DeltaX
     DeltaY_2=CompMul DeltaY DeltaY

     if (Abs(Xc1.Re-Xc2.Re)>Eps) or (Abs(Xc1.Im-Xc2.Im)>Eps) then

     (
          Success=CompDiv DeltaY_2 DeltaX_2 &V 
          U=Complex 1. 0. 
          A=CompSum V U
          Q1=Complex 2. 0. 
          Q2=CompMul Q1 DeltaY 
          Success=CompDiv Q2 DeltaX &V1 
          V1=CompMul V1 Xc1
          Q=CompMul UU DeltaY 
          Success=CompDiv Q DeltaX_2 &V2 
          Q=Complex 2. 0. 
          V3=CompMul Q YC1
          B=CompSub V1 V2
          B=CompSub B V3

          Q1=CompMul UU UU 
          Q2=Complex 4. 0.
          Q3=CompMul Q2 DeltaX_2 
          Success=CompDiv Q1 Q3 &V1
          Success=CompDiv UU DeltaX &V2
          Q=CompMul V2 Xc1 
          C=CompSub V1 Q
          C=CompSum C XC1_2
          C=CompSum C YC1_2
          C=CompSub C R1_2

          Q1=CompMul B B 
          Q2=Complex 4. 0. 
          Q3=CompMul A C 
          Q4=CompMul Q2 Q3
          D=CompSub Q1 Q4

          Q1=CompSqrt D
          Q2=CompNeg B 
          Q3=Complex 2. 0.
          Q4=CompSum Q2 Q1
          Q5=CompMul Q3 A 
          Success=CompDiv Q4 Q5 &Y1
          Q1=CompSqrt D
          Q2=CompNeg B
          Q3=CompSub Q2 Q1 
          Q4=Complex 2. 0. 
          Q5=CompMul Q4 A 
          Success=CompDiv Q3 Q5 &Y2

          Q1=Complex 2. 0. 
          Q2=CompMul Y1 DeltaY
          Q3=CompMul Q1 Q2 
          V1=CompSub UU Q3 
          Q1=Complex 2. 0. 
          Q2=CompMul Q1 DeltaX 
          Success=CompDiv V1 Q2 &X1
          Q1=Complex 2. 0. 
          Q2=CompMul Y2 DeltaY
          Q3=CompMul Q1 Q2 
          V1=CompSub UU Q3
          Q1=Complex 2. 0.
          Q2=CompMul Q1 DeltaX
          Success=CompDiv V1 Q2 &X2
     ) 
     else 
     if (Abs(Yc1.Re-Yc2.Re)>Eps) or (Abs(Yc1.Im-Yc2.Im)>Eps) then
     (
          Success=CompDiv DeltaX_2 DeltaY_2 &V
          Q1=Complex 1. 0. 
          A=CompSum V Q1
          
          Success=CompDiv(CompMul((Complex 2. 0.) DeltaX)  DeltaY &V1)
          V1=CompMul(V1 Yc1)
          Success= CompDiv(CompMul(UU DeltaX) DeltaY_2 &V2)
          V3=CompMul((Complex 2. 0.) XC1)
          B=CompSub(V1 V2)
          B=CompSub(B V3)

          Success=CompDiv(CompMul(UU UU) CompMul((Complex 4.  0.) DeltaY_2) &V1)
          Success=CompDiv(UU DeltaY &V2)
          C=CompSub(V1 CompMul(V2 Yc1))
          C=CompSum(C YC1_2)
          C=CompSum(C XC1_2)
          C=CompSub(C R1_2)

          D=CompSub(CompMul(B B) CompMul((Complex 4. 0.)  CompMul(A C))) 
     

          Q1=CompSqrt D
          Q2=CompNeg B 
          Q3=Complex 2. 0.
          Q4=CompSum Q2 Q1
          Q5=CompMul Q3 A 
          Success=CompDiv Q4 Q5 &X1
          Q1=CompSqrt D
          Q2=CompNeg B
          Q3=CompSub Q2 Q1 
          Q4=Complex 2. 0. 
          Q5=CompMul Q4 A 
          Success=CompDiv Q3 Q5 &X2

          V1=CompSub(UU CompMul(Complex(2. 0.) CompMul(X1 DeltaX))) 
          Success=CompDiv(V1 CompMul(Complex(2. 0.) DeltaY)  &Y1) 

          V1=CompSub(UU CompMul(Complex(2. 0.) CompMul(X2 DeltaX))) 
          Success=CompDiv(V1 CompMul(Complex(2. 0.) DeltaY) &Y2) 
     )
     Return true

) -- ComDuga