//scheme RHO  = extend MATH with                                                 
//    class                                                                      
//    type                                                                       
//        TArea = Nat >< Nat  >< Int >< Int                                      
//           /*   x - coordinate                                                 
//                       y - coordinate                                          
//                                width  of area                                 
//                                     high   of area                            
//           */                                                                  
//       ,Direction == left_ | right_ | up | down                                
//    value                    /* rho distance between two segments */           
//        mkTArea : (Nat >< Int) >< (Nat >< Int)  -> TArea                       
//        mkTArea ((x,w),(y,h)) is (x,y,w,h)                                     
//                               --                                              
//                               --   (1,1) is segment [1,2]                     
//                               --                                              
//       ,rho : Nat >< Int >< Nat >< Int -> Int                                  
//        rho (x1, l1, x2, l2) is                                                
//          local                                                                
//            variable                                                           
//              rc: Int := - 1                                                     
//          in                                                                   
//            if l1 >=  0  /\ l2 >=  0  then                                         
//              if x1 + l1 < x2 then                                             
//                rc := x2 - x1 - l1                                             
//              elsif x2 + l2 < x1 then                                          
//                rc := x1 - x2 - l2                                             
//              else                                                             
//                rc :=  0                                                         
//              end                                                              
//            end;                                                               
//            rc                                                                 
//          end                                                                  
//       ,intersect :  Nat >< Int >< Nat >< Int -> Nat >< Int                    
//        intersect (x1, l1, x2, l2) is                                          
//          local                                                                
//            variable                                                           
//              rc: Nat >< Int := ( 0 ,- 1 )                                         
//          in                                                                   
//            if l1 >=  0  /\ l2 >=  0  then                                         
//              if x1 + l1 >= x2   /\  x2 + l2 >= x1 then                        
//                  rc := (max(x1, x2), min(x1+l1, x2+l2)-max(x1, x2))           
//              end                                                              
//            end;                                                               
//            rc                                                                 
//          end                                                                  
//                                                                               
//       ,isInter : Nat >< Int >< Nat >< Int -> Bool                             
//        isInter (x1, l1, x2, l2) is                                            
//               rho (x1, l1, x2, l2) =  0                                         
//                                                /* */                          
//                                                                               
//                                       -- do (X,L) include  (x,l) ?            
//                                       -- is (x,l) subset of (X,L)?            
//                                                                               
//       ,doHold : Nat >< Int >< Nat >< Int -> Bool                           
//        doHold (X, L, x, l) is                                              
//            if (l >=  0  /\ L >=  0 ) then                                         
//               x >= X   /\   x+l <= X+L                                        
//            else                                                               
//               false                                                           
//            end                       -- move (X,L) to new position to         
//                                      -- unite a proper ends of two segments   
//                                      -- d = right or down =>  right to  right 
//                                      -- d = left  or up   =>  left  to  left  
//                                      --                                       
//       ,align : Direction >< Nat >< Int >< Nat >< Int -> Nat >< Int            
//        align (d, X, L, x, l) is                                               
//            if L >=  0  /\ l >=  0   then                                          
//                if  d =  right_ \/ d = down then                               
//                    (max(x + l - L,  0 ), L)                                     
//                else                                                           
//                    (x, L)                                                     
//                end                                                            
//            else                                                               
//                (X, L)                 -- nothing to do                        
//            end                                                                
//                                                                               
//                            /* rho distance between two rectangles*/           
//       ,rho2 :  TArea >< TArea -> Int >< Int                                   
//        rho2 ((x,y,w,h), (x1,y1,w1,h1)) is                                     
//              (rho(x,w,x1,w1), rho(y,h,y1,h1))                                 
//                                                                               
//       ,isInter2 : TArea >< TArea -> Bool                                      
//--        isInter2 (a, a1) is                                                  
//--               rho2 (a, a1) = (0,0)                                          
//        isInter2 ((x,y,w,h), (X,Y,W,H)) is                                     
//               isInter (x,w,X,W) /\ isInter(y,h,Y,H)                           
//                                                                               
//                           /* */                                               
//       ,intersect2 : TArea >< TArea -> TArea                                   
//        intersect2 ((x,y,w,h), (X,Y,W,H))  is                                  
//                      mkTArea(intersect(x,w,X,W), intersect(y,h,Y,H))          
//                                                                               
//       ,doHold2 : TArea >< TArea -> Bool                                    
//        doHold2 ((X,Y,W,H), (x,y,w,h)) is                                   
//            doHold(X, W, x, w) /\ doHold(Y, H, y, h)                     
//                                                                               
//                                                                               
//       ,alignEdge : Direction >< TArea >< TArea  -> TArea                      
//        alignEdge (d, (X,Y,W,H), (x,y,w,h)) is                                 
//                                                                               
//            if      d = left_ \/ d = right_  then                              
//                      mkTArea(align(d, X,W, x,w), (Y,H))                       
//            else -- d = up    \/ d = down                                      
//                      mkTArea((X,W), align(d, Y,H, y,h))                       
//            end                                                                
//                                                                               
//       ,align2   : TArea >< TArea ->   TArea                                   
//                --  big window                                                 
//                --          small window                                       
//                --                      new place of big window                
//        align2 ((X,Y,W,H), (x,y,w,h)) is                                       
//            local                                                              
//                variable                                                       
//                    rc : TArea :=  (X,Y,W,H)                                   
//            in                                                                 
//                if doHold2   ((X,Y,W,H), (x,y,w,h)) = false     then        
//                    if X + W < x + w then   -- go to the right                 
//                        rc := alignEdge(right_, rc, (x,y,w,h))                 
//                    elsif   x < X then      -- go to the left                  
//                        rc := alignEdge(left_ , rc, (x,y,w,h))                 
//                    end;                                                       
//                    if Y + H < y + h then   -- go to the down                  
//                        rc := alignEdge(down, rc, (x,y,w,h))                   
//                    elsif   y < Y then      -- go to the left                  
//                        rc := alignEdge(up  , rc, (x,y,w,h))                   
//                    end                                                        
//                end;                                                           
//                rc                                                             
//            end                                                                
//end                                                                            
                                                                               
#ifndef  __XRHO_H
#define  __XRHO_H

# ifdef __cplusplus
      extern "C"    {
# endif

typedef enum x_trend {
    x_up,
    x_right,
    x_down,
    x_left
}
x_trend;


long
x_rho_(
    const long a, const long aLen,
    const long b, const long bLen
)
;

long
x_inter_ (
    long     * i, long     * iLen,
    const long a, const long aLen,
    const long b, const long bLen
)
;

x_bool  
x_isInter_ (
    const long a, const long aLen,
    const long b, const long bLen
)
;

x_bool  
x_doHold_ (     // include
    const long a, const long aLen,
    const long b, const long bLen
)
;

long
x_align_ (
    long          * newA, long     * newALen,

    const x_trend   d,
    const long      a,    const long aLen,
    const long      b,    const long bLen
)
;

long
x_rho(
    long     * xRho, long     * yRho,

    const long x,    const long y,
      const long xLen,    const long yLen,
    const long X,    const long Y,
      const long XLen,    const long YLen
)
;

long
x_inter (
    long  * xi,      long  * yi,
      long   * xiLen,    long  * yiLen,

    const long x,    const long y,
      const long xLen,    const long yLen,
    const long X,    const long Y,
      const long XLen,    const long YLen
)
;

x_bool  
x_isInter (
    const long x,    const long y,
      const long xLen,  const long yLen,  
    const long X,    const long Y,
      const long XLen,    const long YLen
)
;

x_bool  
x_doHold (
    const long x,    const long y,
      const long xLen,  const long yLen,  
    const long X,    const long Y,
      const long XLen,    const long YLen
)
;


long
x_alignEdge (
    long  * XN,      long  * YN,
      long   * XNLen,    long  * YNLen,

    const x_trend   d,
    const long X,    const long Y,
      const long XLen,    const long YLen,
    const long x,    const long y,
      const long xLen,    const long yLen
)
;

long
x_align (
    long  * XN,      long  * YN,
      long   * XNLen,    long  * YNLen,

    const long X,    const long Y,
      const long XLen,    const long YLen,
    const long x,    const long y,
      const long xLen,    const long yLen
)
;

# ifdef __cplusplus
   }
# endif

#endif