BuildConstrains.java

//import java.time.LocalDate;
//import java.time.LocalTime;
import java.util.Date;
import java.text.SimpleDateFormat;
//import java.util.BitSet;
import java.util.Hashtable;
import java.util.Map;
import java.util.Arrays;
import java.util.ArrayList;
//import java.util.Comparator;
import java.lang.Math;
import java.lang.Comparable;
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
import java.math.BigInteger;
        
/* import os
import sys, getopt
import datetime #as dt
import queue
import csv
#import networkx as nx
#G = nx.Graph()
import numpy as np */

/* #fileName="graph0.csv"
#fileName="graph1.csv"
#fileName="graph11.csv"
#fileName="graph2.csv"
#fileName="graph3.csv"

#print(fileName) */
//--------
class Constants{
    static int EMPTY_EL=-1;
    static int TST=0; //!!!
}

//--------
//--------
/* class VertexSet extends BitSet{
//	protected BitSet set;
    
	VertexSet(){
		super();	
	}
	
    VertexSet(int len){
		super(len);
    }
        
	VertexSet(int len, int ind){
//          if (ind < 0) throw new ValueError("Value of the " + ind + " is negative ! ");
	    super(len);
        super.set(1<<ind, true);	
	}
	
    @Override
    public int length(){
         return super.length();
    } 
    
    public long to_int(){
	int n = super.length();
        long s = 0;
        for(int i=0; i<n; i++) {
           if (super.get(i)) s += (1<<i);
        }
        return s;
	}
    
//    @Override
    public VertexSet vor(VertexSet other){
        VertexSet out = (VertexSet) super.clone();
        out.or(other);
        return out;
    }

    public VertexSet vand(VertexSet other){
        VertexSet out = (VertexSet) super.clone();
        out.and(other);
        return out;
    }

    public VertexSet invert(){
        VertexSet out = (VertexSet) super.clone();
        int n1 = out.length()-1;
        out.flip(0, n1);
        return out;
    }
    
    public Boolean eq(VertexSet other){
        return this.equals(other);
    }

    public Boolean gt(VertexSet other){
        return this.to_int() > other.to_int();
    }
    
/*     # def __ior__(self, other):
        # if not isinstance(other, Set): raise TypeError(f"Type of the {other} isn't Set !")
        # self.set |= other.set        

    def __iand__(self, other):
        if not isinstance(other, Set): raise TypeError(f"Type of the {other} isn't Set !")
        self.set &= other.set */

/*     @Override
    public String toString(){  
        long n = this.to_int();
        return Long.toBinaryString(n);
    }
    
    public static VertexSet int2set(long k, int len){
        VertexSet out = new VertexSet(len);
        String str = Long.toBinaryString(k);
		char[] array = str.toCharArray();
		int lstr1 = array.length-1;
		//if (lstr1+1 > len) Error!!!
		for (int i = lstr1; i >= 0; i--) 
			if (array[i]=='1') out.set(lstr1-i, true);
        return out;
    }
        
    public static VertexSet EMPTY_SET(){
        return new VertexSet();
    }
        
    public static VertexSet[] EMPTY_TURTLE(){
        VertexSet es = EMPTY_SET();
        VertexSet[] out = {es,es};
        return out;
    }
}          */          

class VertexSet {
    BigInteger vset;
	int len;
	
	VertexSet(){
            this.vset = new BigInteger("0");
            this.len = 0;
	}
	
/*     VertexSet(int len){
		vset = new super(len);
    } */
	VertexSet(int ind){
//          if (ind < 0) throw new ValueError("Value of the " + ind + " is negative ! ");
	    this.vset = new BigInteger("0");
            this.vset = this.vset.setBit(ind);
            this.len = ind + 1;
	}
		
/* 	VertexSet(int len, int ind){
//          if (ind < 0) throw new ValueError("Value of the " + ind + " is negative ! ");
	    vset = new super(len);
        super.set(1<<ind, true);	
	} */
	
    //@Override
    public int length(){
         return this.vset.bitLength();
    } 
    
    public long to_int(){
        return this.vset.longValueExact();
	}
    
//    @Override
    public VertexSet vor(VertexSet other){
		VertexSet out = new VertexSet();
		out.vset = this.vset.or(other.vset);
		out.len = Math.max(this.len,other.len);		
        return out;
    }

    public VertexSet vand(VertexSet other){
		VertexSet out = new VertexSet();
		out.vset = this.vset.and(other.vset);
		out.len = this.len;
        return out;
    }

    public VertexSet invert(){
		VertexSet out = new VertexSet();
		out.vset = this.vset.not();
		out.len = this.len;
        return out;
    }
    
    public Boolean eq(VertexSet other){
        return this.vset.compareTo(other.vset) == 0;
    }

    public Boolean gt(VertexSet other){
		int ct = this.vset.compareTo(other.vset);
		return (ct == 1);
    }
    
/*     # def __ior__(self, other):
        # if not isinstance(other, Set): raise TypeError(f"Type of the {other} isn't Set !")
        # self.set |= other.set        

    def __iand__(self, other):
        if not isinstance(other, Set): raise TypeError(f"Type of the {other} isn't Set !")
        self.set &= other.set */

    @Override
    public String toString(){  
        //long n = this.to_int();
        return this.vset.toString(2);
    }
    
    public static VertexSet int2set(long k){
		VertexSet out = new VertexSet();
		String s = ((Long) k).toString();
		out.vset = new BigInteger(s);
		out.len = s.length();
		return out;
		
/*         VertexSet out = new VertexSet(len);
        String str = Long.toBinaryString(k);
		char[] array = str.toCharArray();
		int lstr1 = array.length-1;
		//if (lstr1+1 > len) Error!!!
		for (int i = lstr1; i >= 0; i--) 
			if (array[i]=='1') out.set(lstr1-i, true);
        return out; */
    }
        
    public static VertexSet EMPTY_SET(){
        return new VertexSet();
    }
        
    public static VertexSet[] EMPTY_TURTLE(){
        VertexSet es = EMPTY_SET();
        VertexSet[] out = {es,es};
        return out;
    }
}                     
//--------
/* //--------
public class ArrayListComparatorByString implements Comparator<ArrayList<String>> {

    @Override
    public int compare(ArrayList<String> a1, ArrayList<String> a2) {
        return a1.get(0).compareTo(a2.get(0));
    }

}

public class ArrayListComparatorByInteger implements Comparator<ArrayList<Integer>> {

    @Override
    public int compare(ArrayList<Integer> a1, ArrayList<Integer> a2) {
        return a1.get(0).compareTo(a2.get(0));
    }

} */

public class Vect<T extends Number> extends ArrayList<T> implements Comparable<Vect<T>> {
	ArrayList<T> vector;
	
	Vect<T>() {
		vector = new ArrayList<T>();
	}
	
	@Override
	public int compareTo(Vect<T> vect2) {
		return this.vector.get(0).compareTo(vect2.get(0));
	}

}

//class Matr<T> extends ArrayList<ArrayList<T>> implements Comparator<ArrayList<T>> {
//class Matr<T> extends ArrayList<ArrayList<T>> {
public class Matr<T extend Number> extends ArrayList<Vect<T>> {
    ArrayList<Vect<T>> matr;

    Matr() {
        matr = new ArrayList<Vect<T>>();
    }

    public int len() {
        return matr.size();
    }

    public void append(ArrayList<T> v) {
        matr.add(v);
    }
    


    public void sort() {
		Collections.sort(this.matr);
        //this.matr.sort();
    }

    public int get_lineIndx_by_val_in_col(int col, T e) {
        for(int k=0; k<this.len(); k++)
            if (this.matr.get(k).get(col)==e) return k;
        
        return -1;
    }
 
    public boolean check_list(ArrayList<T> l, T e){
//       print('list',l)
//       print('e',e)
        int n=l.size();
        if (n==0) return false;
        for(T k: l)
            if (k==e) return true;
        
        return false;
    }
}        
//--------
//--------
class Edge(Matr):
    def __init__(self):
        super().__init__()
                
    # def append(self, v):
        # self.super.append(v)
        
    int len(){
         return self.super.len()
    }
                
    def get_vertex(self,k):
        return self.matr[k][0]
        
    def edge_to_limit_side(self,prefix,bitStr):
        """
        prefix str
        bitStr
        edgeSorted[[vertex, vertexIndxInLimit]]
        """
       
        listBit = list(bitStr)
        listBit.reverse()
    //Tst3    print('listBit:',listBit)
    //Tst3    print('edge:',self.matr)
        
        n = len(listBit)
        listS = []
        for i in range(n):
            if listBit[i] == '1' :
                j = self.get_lineIndx_by_val_in_col(1,i)
                listS.append(self.get_vertex(j))
                
        listS.sort()
     //Tst3   print('listS:',listS) 
        
        s = ''
        cnt = 0
        for k in range(len(listS)):
            if cnt > 0 :
                s += ' + '   
            s += prefix + listS[k]
            cnt = cnt + 1
                
     //Tst3   print('s:',s)
        return s
        
    def sort_list_by_val(lst):

    //Tst3    print(' sort_list_by_val')
        //lst_out: [][lst_el, old_indx]
        lst_out=Edge()
        for i in range(len(lst)):
            lst_out.append([lst[i],i])
        
    //Tst3    print('lst_out-s:',lst_out)
        lst_out.sort()
        
    //Tst3    print('lst_out-f:',lst_out)
        return lst_out


//--------        
//--------
class Graph{
	boolean dual;
	String[] lX;
	String[] lY;
	Hashtable<String, String[]> graph;
	
    Graph() {
        dual = false;
        lX = new String[0];
        lY = new String[0];
        graph = new Hashtable<>();
    }
    
    public boolean get_dual(){
        return this.dual;
    }
    
    public Hashtable<String, String[]> get_graph(){
        return graph;
	}
        
//-------- 
// Graph
    private static final String COMMA_DELIMITER = ",";

    public void input(String fileName){
        try {
		//List<List<String>> records = new ArrayList<>();
		BufferedReader br = new BufferedReader(new FileReader(fileName));
			String row;
			while ((row = br.readLine()) != null) {
				//           print('row',row)
				String[] values = row.split(COMMA_DELIMITER);
			//	records.add(Arrays.asList(values));
				String key = values[0];
				String[] vals = new String[values.length-1];
				for(int i=1; i<values.length; i++){
					vals[i-1] = values[i];
				}
				graph.put(key, vals);
			}	
        }
        catch(IOException e){
            e.printStackTrace();
        }
                    //return graph;
     //   print()
     //   print(self.graph)
    }
//--------
// Graph
    public void gen_edges() {
        
     //#   print('graph_ge',self.graph)
        for (Map.Entry<String, String[]> e: this.graph.entrySet()) {
            String keyX = e.getKey();
    //#        print('keyX',keyX)
            if (! Matr.check_list(lX, keyX))
                lX.append(keyX);
            
            for (String y: e.getValue())
    //#            print('y',y)
                if (! Matr.check_list(lY, y))
                    lY.append(y);
        } 
    }
//--------
// Graph
    public Graph create_dual(){
    //    String[] oldVal;
    //    String[] newVal;
        Graph graph_dual = new Graph();
     
    //    short NON=-1;
        
        for (Map.Entry<String, String[]> e: this.graph.entrySet()) { // new y
            String keyX = e.getKey();
	//#Tst        print('keyX',keyX)
	
            for (String y: e.getValue()) { // new x
     //#Tst            print('y',y)
                if (! graph_dual.graph.containsKey(y)) {
     //#Tst                print('NON')
                    String[] vkey = {keyX};
                    graph_dual.graph.put(y,vkey);
                }
                else if (! Matr.check_list(graph_dual.graph.get(y), keyX)) {
     //#Tst                    print('append')
					//!!! Set newVal by oldVal + keyX
                        String[] oldVal = graph_dual.graph.get(y);
                        String[] newVal = new String[oldVal.length+1];
                        for(int i=0; i<oldVal.length; i++) {
                                newVal[i] = oldVal[i];
                        }
                        newVal[oldVal.length] = keyX;
                        graph_dual.graph.replace(y,newVal);                        
		}
                //    else
                //        pass #Error! Dupl edje
            }
	}

     //#Tst2   print('graph_dual:',graph_dual.graph)
        for (Map.Entry<String, String[]> e: graph_dual.graph.entrySet()) {
			String   key = e.getKey();
            String[] arr = e.getValue();
            Arrays.sort(arr);
            graph_dual.graph.replace(key,arr);
	}
            
        graph_dual.dual = true;

//    print('graph_dual:',graph_dual.graph)
        return graph_dual;
    }
#--------
# Graph
    def build_net_limits(self):
        """
        graph: 
        """
    #Tst    print('dual:',self.dual)

        self.gen_edges()
        nX = len(self.lX)
        nY = len(self.lY)
        if Constants.TST in [1]: print('lX:',nX,self.lX)
        if Constants.TST in [1]: print('lY:',nY,self.lY)

        matrG:MatrG = self.set_matrG()

        if Constants.TST in [1]: print('matrG:',matrG.get_matr())
        npQX = QX(matrG)
        #print('npQX:',npQX.npQX)   #Tst
        if Constants.TST in [1,4]: print('npQX:',npQX.get_npQX())
        matrG, self.lX, binMG = matrG.sort_matrG_by_x(self.lX, self.lY, npQX)
        if Constants.TST in [1,4]: print(' after sort_matrG_by_x')#Tst1
        if Constants.TST in [1,4]: print('matrG:',matrG.get_matr())#Tst1
        if Constants.TST in [1,4]: print('lX:',nX,self.lX)#Tst1
        if Constants.TST in [1,4]: print('binMG:',binMG.get_list())#Tst1

        npQX = QX(matrG)
        if Constants.TST in [1,4]: print('npQX:',npQX.get_npQX())#Tst

        listR = Limits.create_limits(npQX, binMG)
        listR.print_list_xy('listR')

        listR.print_limits(self)

#--------
# Graph
    def set_matrG(self): #, nX, nY):
        matr = MatrG(len(self.lX),len(self.lY)) #[ [0]*nY for i in range(nX) ]
    #   matrG: [indX][indY] -> 1 if x connect y
        for keyX in self.graph.keys():
            indX=self.lX.index(keyX)
            for y in self.graph[keyX]:
                indY=self.lY.index(y)
                matr.set_el(indX, indY, 1) #matr.matrG[indX][indY] = 1
                
        return matr
}        
//--------
//--------
class MatrG(list):
    def __init__(self, nX, nY):
        self.matrG = [ [0]*nY for i in range(nX) ] 
        
    def get_matr(self):
        return self.matrG

    def set_binY(self,iv):
        binY=Set()
#        print('binY',type(binY))
        for ky in range(len(self.matrG[iv])):
            if self.matrG[iv][ky] == 1:
#                print(f'Set({ky})',type(Set(ky)))
                binY = binY | Set(ky)
#                print('ky,binY:',ky,binY.to_int())
#        print('binY:',binY.to_int())
        return binY
        
    def get_row(self, kl):
        return self.matrG[kl]
        
    def set_row(self, kl, low):
        self.matrG[kl] = low
        
    def set_el(self, ix, iy, val): 
        self.matrG[ix][iy] = val
               
    def sort_matrG_by_x(self, lX, lY, npQX):
        """
        matrG[x][y]
        lX[x]
        lY[y]
        -
        inbinMG[(binY,kx)],inlX[],inmatrMG[][]: binMG, lX, matrG
        """
        nX = len(lX)
        nY = len(lY)
        if Constants.TST in [1]: print(' sort_matrG_by_x')
    #    inbinMG=[]
        if Constants.TST in [1]: print('matrG:',self.get_matr())
        if Constants.TST in [1]: print('lX:',nX,lX)
        if Constants.TST in [1]: print('lY:',nY,lY)
        if Constants.TST in [1]: print('npQX:',npQX.get_npQX())
        inbinMG:BinMG = npQX.sort_BSF_x(self)
        if Constants.TST in [1]: print('inbinMG:',inbinMG.get_list())
        

    # sort lX, matrG  
        inlX = [-1 for i in range(nX) ]
        inmatrG = MatrG(nX,nY) #[ [0]*nY for i in range(nX) ]  
        for kx in range(inbinMG.len()):
           kxOld = inbinMG.get_kxOld(kx)
           inlX[kx] = lX[kxOld] 
           inmatrG.set_row(kx, self.get_row(kxOld))

        if Constants.TST in [1]: print('inlX:',inlX)
        if Constants.TST in [1]: print('inmatrMG:',inmatrG.get_matr())
        return inmatrG, inlX, inbinMG

#--------
#--------
class QX:
    def __init__(self, matrG):
        matr = matrG.get_matr()
        self.npQX = QX.set_npQX(matr)
        
    def set_npQX(matr):
        npMG = np.array(matr)
        #Tst    print('npMG:',npMG)
        npMX = np.dot(npMG, npMG.transpose())
        #Tst print(' after np.dot')
        #Tst print('npMX:',npMX)
        npQX = np.minimum(npMX, 1)

        return npQX
        
    def get_npQX(self):  
        return self.npQX       
        
    def get_el(self,i,j):  
        return self.npQX[i][j]
        
    def len(self):
        return len(self.npQX)
    
    def sort_BSF_x(self, matrG:MatrG):
# BFS
# Вход: граф G = (V, E), представленный в виде списков смежности,
# и вершина s из V.
# Постусловие: вершина достижима из s тогда и только тогда,
# когда она помечена как «разведанная».
# 1) пометить s как разведанную вершину, все остальные как не-
# разведанные
# 2) Q := очередь, инициализированная вершиной s
# 3) while Q не является пустой do
# 4) удалить вершину из начала Q, назвать ее v
# 5) for каждое ребро (v, w) в списке смежности v do
# 6) if w не разведана then
# 7) пометить w как разведанную
# 8) добавить w в конец Q  
        """
        inbinMG[(binY,kx)]
        """
        #print(' sort_BSF_x')#Tst
        
        q = queue.Queue()
        #print('self.npQX:',self.get_npQX()) #Tst
        #print('matrG:',matrG.get_matr()) #Tst
        lenQX = len(self.npQX)
        explored = [ False for i in range(lenQX) ]
        inbinMG = BinMG(lenQX) #[ (-1,-1) for i in range(lenQX) ]
        #print('inbinMG:',inbinMG.get_list())  #Tst
        
        ibin: int = 0
        while ibin < lenQX:
            istrt = ibin
            explored[istrt] = True
            q.put(istrt)
            while not q.empty():
                iv = q.get()
                y = matrG.set_binY(iv) #Tst
                #print('y:',y.to_int(),y,type(y)) #Tst
                #inbinMG.set_row(ibin, ((matrG.set_binY(iv),iv)))
                inbinMG.set_row(ibin, (y.to_int(),iv)) #Tst
                #inbinMG.set_row(ibin, [y,iv]) #Tst
                ibin += 1
                for iw in range(len(self.npQX[iv])):
                    if (self.npQX[iv][iw] == 1) and (not explored[iw]):
                        explored[iw] = True
                        q.put(iw)

        #print('inbinMG:',inbinMG.get_list())  #Tst
        return inbinMG
        
#--------
#--------
class BinMG:
    def __init__(self, ln):
        self.binMG = [ (-1,-1) for i in range(ln) ]
        
    def get_kxOld(self, kx):
        return self.binMG[kx][1]
        
    def get_y(self, kx):
        return self.binMG[kx][0]
        
    def set_row(self, kx, val):
        #print('val:',val)
        self.binMG[kx] = val
        
    def get_row(self, kx):
        return self.binMG[kx]
        
    def len(self):
        return len(self.binMG)
        
    def get_list(self):
        return self.binMG
        
#---------- 
# BinMG
    def get_x_connection(self, indx):
        """
        binMG[(bitY,kx)]
        return (xbit, ybit)
        """
        x=Set(indx)
        y=Set.int2set(self.get_y(indx))
        if Constants.TST in [4]: print(' indx,x,y current:',indx,x.set2BinStr(),y.set2BinStr())#Constants.TST4 
        return ((x, y))
#---------- 
# BinMG
    def get_sorted_prev_connections(self,indx,npQX):
        """
        It get previous connected vertexes  for current vertex 
        indx: int
        npQX[kx][kx]
        binMG[(binY,kx)]
        -
        prev_connections[](xbit, ybit)
        """
        if Constants.TST in [4]: print(' get_sorted_prev_connections')#Tst
    #Tst     print(f'npQX[{indx}]',npQX[indx])
        prev_connections=Limits()
        
        for i in range(indx):
            if npQX.get_el(indx,i) == 1:
                prev_connections.append(self.get_x_connection(i)) 
        
        if Constants.TST in [4]: print('indx,prev_connections',indx,prev_connections.out_list())#Tst
        return prev_connections

#--------
#--------         
class Limit:
    pass

class Limits:
    def __init__(self):
        self.limits = []
        
    def append(self, limit):
        self.limits.append(limit)
        
    def extend(self, limits):
        self.limits.extend(limits)

    def delete(self, krow):
        del self.limits[krow]
        
    def set_row(self, krow, val):
        self.limits[krow] = val
        
    def get_row(self, krow):
        return self.limits[krow]    
     
    def get_x(self, krow):  #->Set
        return self.limits[krow][0]
        
    def get_y(self, krow):  #->Set
        return self.limits[krow][1]

    def len(self):
        return len(self.limits)
        
    def get_list(self):
        return self.limits
        
    def out_list(self):    
        list_xy = []
        for i in range(self.len()):
            list_xy.append( ( self.get_x(i).to_int(), self.get_y(i).to_int() )  )    
        return list_xy
        
    def clear_limits(self):
        lenLimits = self.len()
        for k in range (lenLimits-1, -1, -1):
            row = self.get_row(k)
            x = row[0]
            y = row[1]
            if x == Set.EMPTY_SET() and y == Set.EMPTY_SET():
                self.delete(k)
            
#----------  
# cls
    def create_limits(npQX, binMG):
        """
        npQX[kx][kx]
        binMG[](bitY,kx)
        -
        listLimits[(xbit, ybit)]
        xPrevConnections[(xbit, ybit)]
        connection (xbit, ybit)
        xPrevLimitList[(xbit, ybit)]
        """
    #Tst     print(' create_limits')
        listLimits = Limits()
        for indx in range(npQX.len()):
            if Constants.TST in [4]: print('indQX:',indx)
            if indx == 0 :
                connection = binMG.get_x_connection(indx)
                listLimits.append(connection)
                if Constants.TST in [4]: listLimits.print_list_xy('after append listLimits')
                continue
            else:
                xPrevConnections = binMG.get_sorted_prev_connections(indx,npQX)
                if xPrevConnections.len() > 0 :
                    xPrevLimitList = listLimits.get_prev_connected_limits(xPrevConnections)
                else: # First vertex in connected component
                    xPrevLimitList = Limits()
                
                connection = binMG.get_x_connection(indx)
                listLimits.append(connection)
                if Constants.TST in [4]: listLimits.print_list_xy('after append listLimits')
                
                if xPrevLimitList.len() > 0 :
                    xPrevLimitList.add_xy_bits_to_prev(indx,binMG)
                    xPrevLimitList.check_dupl_y_in_prev()
                    listLimits.check_prev_y_in_limits(xPrevLimitList)
                    listLimits.extend(xPrevLimitList.get_list())
                    if Constants.TST in [4]: listLimits.print_list_xy('after extend listLimits')
                        
        return listLimits

#----------  
# Limits
    def get_prev_connected_limits(self, xPrevConnections):
        """
        for each prev connected vertex we get limits with it
        listLimits[](xbit, ybit)
        xPrevConnections[](xbit, ybit)
        -
        prev_limits[](xbit, ybit)
        """
        if Constants.TST in [4]: print(' get_prev_connected_limits')#Tst
    #Tst     xPrevConnections.print_list_xy('xPrevConnections')
    #Tst     listLimits.print_list_xy('listLimits')
        
        prev_limits=Limits()
        for i in range(xPrevConnections.len()) :
            xPrev = xPrevConnections.get_x(i)
    #Tst         print('i,xPrev:',i,xPrev)
            for k in range(self.len()) :
                if (self.get_x(k) & xPrev).to_int() > 0 :
                    prev_limits.append(self.get_row(k))
              
        if Constants.TST in [4]: prev_limits.print_list_xy('prev_limits')#Tst
        return prev_limits
#----------
# Limits
    def add_xy_bits_to_prev(self,indx,binMG):
        """
        adding current x & y to each previous limit
        binMG[(bitY,kx)]
        xPrevLimitList[(xbit, ybit)]
        """
        if Constants.TST in [4]: print(' add_xy_bits_to_prev')#Tst
        if Constants.TST in [4]: self.print_list_xy('xPrevLimitList-s')#Tst
        x,y = binMG.get_x_connection(indx)    
        if Constants.TST in [4]: print('indx,x,y:',indx,x.set2BinStr(),y.set2BinStr())#Tst 
        
        for i in range(self.len()):
            self.set_row(i, (self.get_x(i) | x, self.get_y(i) | y)) 
        
        if Constants.TST in [4]: self.print_list_xy('xPrevLimitList-f')#Tst
    
#----------
# Limits
    def check_dupl_y_in_prev(self):
        """
        check and clear previous limits for duplicated y
        xPrevLimitList[(xbit, ybit)]
        """
        if Constants.TST in [4]: print(' check_dupl_y_in_prev')#Tst
        if Constants.TST in [4]: self.print_list_xy('xPrevLimitList-s')#Tst
        lenP = self.len()
        
        for kp in range(lenP-1, -1, -1):
            yp = self.get_y(kp)
            if yp == Set.EMPTY_SET(): continue
            for kl in range(kp-1, -1, -1):
                if self.get_y(kl) == yp:
                    self.set_row(kp, (self.get_x(kp) | self.get_x(kl), yp)) 
                    self.set_row(kl, Set.EMPTY_TURTLE())    
       
        if Constants.TST in [4]: self.print_list_xy('xPrevLimitList-e')#Tst
        
    #   clear previous limits
    #   clear list 
        self.clear_limits()
                
        if Constants.TST in [4]: self.print_list_xy('xPrevLimitList-f')#Tst

#----------
# Limits
    def check_prev_y_in_limits(self,xPrevLimitList):
        """
        check and clear common limits for duplicated y by previous limits
        listLimits[(xbit, ybit)]
        xPrevLimitList[(xbit, ybit)]
        """
        if Constants.TST in [4]: print(' check_prev_y_in_limits')#Tst
        if Constants.TST in [4]: xPrevLimitList.print_list_xy('xPrevLimitList')#Tst
        if Constants.TST in [4]: self.print_list_xy('listLimits-s')#Tst+
        lenP = xPrevLimitList.len()
        lenL = self.len()
        
        for kp in range(lenP):
            yp = xPrevLimitList.get_y(kp)
            for kl in range(lenL):
                if self.get_y(kl) == yp:
                    xPrevLimitList.set_row(kp, (xPrevLimitList.get_x(kp) | self.get_x(kl), yp)) 
                    self.set_row(kl, Set.EMPTY_TURTLE())
                    
        if Constants.TST in [4]: self.print_list_xy('listLimits-e')#Tst            

    #   clear limits 
    #   clear list  
        self.clear_limits()
            
        if Constants.TST in [4]: self.print_list_xy('listLimits-f')  #Tst  
    
#----------
# Limits    
    def print_limits(self, graph):
        """
        print limit in symbolic view
        listR[(xbit, ybit)]
        lX[x]
        lY[y]
        dual: logical
        -
        lXsort[[val, oldInd]]
        lYsort[[val, oldInd]]
        """
            
        lXsort = Edge.sort_list_by_val(graph.lX)    
        lYsort = Edge.sort_list_by_val(graph.lY)    
        
 ##       for l in listR:
        for iR in range(self.len()):
            sl,sr = '',''

            xa = self.get_x(iR).set2BinStr()     #
            yb = self.get_y(iR).set2BinStr()     #
 #!!!           xa,yb = set2BinStr(self.get_row(iR))
    #Tst3        print('xa,yb:',xa,yb)
     
            if graph.get_dual():
                sl = lXsort.edge_to_limit_side('b',xa)
                sr = lYsort.edge_to_limit_side('a',yb)
            else:
                sl = lXsort.edge_to_limit_side('a',xa)
                sr = lYsort.edge_to_limit_side('b',yb)
            
            print(sl,'<=',sr)

#----------
# Limits  
    def print_list_xy(self, prefix):
        """
        prefix: str
        list_xy[](xbin, ybin)
        """
        
        list_xy = []
        lp=[]
        for i in range(self.len()):
            list_xy.append( ( self.get_x(i).to_int(), self.get_y(i).to_int() )  )
            lp.append( ( self.get_x(i).set2BinStr(), self.get_y(i).set2BinStr() ) )
        
        print(prefix+':', list_xy)
        print(' '*len(prefix), lp)
        
#-------------------
#-------------------
#-------------------
def main(argv):

    fileName = argv[1]
    print(fileName)
    
# check filename for existence !  
    if not os.path.isfile(fileName):
        print(f"The input file {fileName} doesn't exists!")
        return
  
    if len(sys.argv) > 2 :
        nMode = int(argv[2])
    else:
        nMode = 0

    print('mode:',nMode)
    graph = Graph()

    graph.input(fileName)
    #Tst print(' after graph_input')
    print('graph:',graph.get_graph())

    if nMode in (0,1):
    #    dual = False
        graph.build_net_limits()

    if nMode in (0,2):
    #    dual = True
        graph_dual = graph.create_dual()
        print('graph_dual:',graph_dual.get_graph())
        graph_dual.build_net_limits()

    if not nMode in (0,1,2):
        print('Invalid mode !',nMode)

//-------------------
//-------------------
class BuildConstrains {

 private static void main1(String[] argv){

    var fileName = argv[1];
    System.out.println(fileName);
    
// check filename for existence !  
    if (not os.path.isfile(fileName)) {
        print(f"The input file {fileName} doesn't exists!");
        return;
    }
    
    if len(sys.argv) > 2 :
        nMode = int(argv[2])
    else:
        nMode = 0

    print('mode:',nMode)
    graph = Graph()

    graph.input(fileName)
    #Tst print(' after graph_input')
    print('graph:',graph.get_graph())

    if nMode in (0,1):
    #    dual = False
        graph.build_net_limits()

    if nMode in (0,2):
    #    dual = True
        graph_dual = graph.create_dual()
        print('graph_dual:',graph_dual.get_graph())
        graph_dual.build_net_limits()

    if not nMode in (0,1,2):
        print('Invalid mode !',nMode)
  }
 
  public static void main(String[] argv) {
 //   java.time.LocalDate currDate = java.time.LocalDate.now();
 //   System.out.print(currDate);
 //   System.out.print("_");
 //   java.time.LocalTime currTime = java.time.LocalTime.now();
 //   System.out.println(currTime);
    Date current = new Date();
    SimpleDateFormat formatter = new SimpleDateFormat("d-MM-yyyy_H:m");
    System.out.println(formatter.format(current));

    if (argv.length == 1)
        System.out.println("Usage: " + argv[0] + " Input_File" + " mode(?)");
    else {
        System.out.println(argv);
        main1(argv);
    }		
  }
}