5/7/2017

Trying to implement the reduceShuffle function for Zone method

include/tpdaZone.h

@@ -35,6 +35,7 @@ class stateZone{
 	// return shuffle of this state with s2
 	stateZone* shuffle(stateZone *s2);
 	
+        stateZone* reduceShuffle(stateZone *s2);
 	// Return the first successor state whoose childrens will be right state for shuffle with current state
 	stateZone* sucState();
 

nbproject/private/private.xml

@@ -11,6 +11,8 @@
     <open-files xmlns="http://www.netbeans.org/ns/projectui-open-files/2">
         <group>
             <file>file:/home/sparsa/Programming/mtp/src/tpdaZone.cpp</file>
+            <file>file:/home/sparsa/Programming/mtp/src/tpdaCGPP.cpp</file>
+            <file>file:/home/sparsa/Programming/mtp/include/tpdaZone.h</file>
         </group>
     </open-files>
 </project-private>

src/tpdaZone.cpp

@@ -119,9 +119,10 @@ bool identity(stateZone *vs) {
 stateZone* stateZone::reduceShuffle(stateZone* s2) {
 
 	char *del2 = s2->del, *w2 = s2->w;
-	char P2 = s2->P, L2 = s2->L;
+	char P2 = s2->P;
 	short f2 = s2->f;
-	
+	short L = f&127;
+        short L2 = f2 & 127;
 	short curReset, reset, tempReset; // temp variables to keep reset for a range of points 
 	char count=0; // used for storing #points in new state
 	char i, j; // loopers
@@ -151,11 +152,11 @@ stateZone* stateZone::reduceShuffle(stateZone* s2) {
 	// (s2->P - s2-> L) comes from : all points s2->L+1 to s2->P are there in new state
 	count += L + (P2 - L2); // #points in new state
 	
-	stateGCPP *vs = new stateGCPP(); // new TA state
+	stateZone *vs = new stateZone(); // new TA state
 	
 	vs->del = new char[count]; // allocate memory
-	vs->w = new char[count];
-	vs->L = L;
+	vs->w = new char[count*(count-1)]; //this will hold the matrix without the diagonal element
+	vs->f = f; //f contains the push complete command flag bit along with the value of L
 	
 	short nf = 0; // initially flag is zero
 	short dis; // distance variable
@@ -164,26 +165,87 @@ stateZone* stateZone::reduceShuffle(stateZone* s2) {
 	// Here we are copying points from s2->L+1 to s2->P of 2nd state to new state
 	for(i=P2 - 1; i >= L2; i--, j--) {
 	    vs->del[j] = del2[i]; // copy (i+1)-th transition to (j+1) transition of new state
-	    vs->w[j] = w2[i]; // copy (i+1)-th tsm to (j+1) tsm of new state
-	    
+	    //vs->w[j] = w2[i]; // copy (i+1)-th tsm to (j+1) tsm of new state
+	    //for zone the W contains the details of matrix which we need to copy and check for negetive cycle
 	    // if distance (i+1)->(i+2) of 2nd state is accurate, then distance (j+1)->(j+2) of new state is accurate
-	    if( f2 & a32[i+1] ) 
-	    	nf |= a32[j+1];
+	    //if( f2 & a32[i+1] ) 
+	    //	nf |= a32[j+1];
 	}
 	
 	// Here we are copying points from 1 to L-1 of 1st state to new state
 	for(j=0; j < (L-1); j++) {
 	    vs->del[j] = del[j];
-	    vs->w[j] = w[j];
-	    
+	    //vs->w[j] = w[j];
+	    // same reasons as above
 	    // if distance (j+1)->(j+2) of 1st state is accurate, then distance (j+1)->(j+2) of new state is accurate
-	    nf |= ( f & a32[j+1] );
+	    //nf |= ( f & a32[j+1] ); // here f means some thing different
 	}
 	
 	//copy the point L, doing it separately because of the flag variable which is not applicable for L-th point
 	vs->del[L-1] = del[L-1];
-	vs->w[L-1] = w[L-1];
+	//vs->w[L-1] = w[L-1]; w doesnot contains time stamps any more it contains the matrix 
 	
+        //Here goes the logic of creating the matrix altogether with given values.
+        // copy weights of first state to WT1
+	for(i=0; i < P; i++) {
+		for(j=0; j < P; j++) {
+		  if(i==j) {  //same transition points 
+				WT1[i][i] = 0;
+				open1[i][i] = false;
+			}
+			else if(i < j) {  
+				WT1[i][j] = w[index(i, j, P)] & (~a32[15]); // 15-TH bit is used for open or not
+
+				if( w[index(i, j, P)] & a32[15] ) // as 15th bit is used for open and close interval
+					open1[i][j] = true;
+				else
+					open1[i][j] = false;
+			}
+
+			else{ ///when i > j i.e the edges coming from j to i it must be negetive.
+				WT1[i][j] = - ( w[index(i, j, P)] & (~a32[15]) ); // 15-TH bit is used for open or not
+
+				if( w[index(i, j, P)] & a32[15] )
+					open1[i][j] = true;
+				else
+					open1[i][j] = false;
+			}
+
+		}
+	}
+        //copy weights of second state to WT1
+        // copy weights of current state to WT1
+	for(i=P; i < count; i++) {
+		for(j=P; j < count; j++) {
+		  if(i==j) {  //same transition points 
+				WT1[i][i] = 0;
+				open1[i][i] = false;
+			}
+			else if(i < j) {  
+				WT1[i][j] = w[index((i-P), (j-P), P2)] & (~a32[15]); // 15-TH bit is used for open or not
+
+				if( w[index((i-P), (j-P), P2)] & a32[15] ) // as 15th bit is used for open and close interval
+					open1[i][j] = true;
+				else
+					open1[i][j] = false;
+			}
+
+			else{ ///when i > j i.e the edges coming from j to i it must be negetive.
+				WT1[i][j] = - ( w[index((i-P), (j-P), P2)] & (~a32[15]) ); // 15-TH bit is used for open or not
+
+				if( w[index((i-P), (j-P), P2)] & a32[15] )
+					open1[i][j] = true;
+				else
+					open1[i][j] = false;
+			}
+
+		}
+	}
+        
+        //both the matrices is copied to the variable,
+        //here P = L2 Now we have to check the check points and their 
+        //recent reset points 
+        //now there are some hangng edges which are
 	// Now we watch out for points from L+1 to P of 1st state
 	char lastindex = P;// last index of the point we have taken so far, although P might not be included
 	
@@ -272,7 +334,7 @@ bool stateZone::shuffleCheck(stateZone *s2) {
 
 
 // shuffle of this state with state s2 and return the new state
-stateGCPP* stateGCPP::shuffle(stateGCPP *s2){ // shuffle  with state s2
+stateZone* stateZone::shuffle(stateZone *s2){ // shuffle  with state s2
 
 	if(! shuffleCheck(s2) )	
 		return NULL;
@@ -501,7 +563,7 @@ stateZone* stateZone::addNextTPDA(char dn) {
 		WT = WT1;
 		open = open1;
 	}
-	else{ // if P is odd, the shortest path stored in WT1 and open1
+	else{ // if P is even, the shortest path stored in WT2 and open2
 		WT = WT2;
 		open = open2;
 	}
@@ -815,13 +877,13 @@ runCGPP* runCGPP::shuffle(runCGPP *s2) {
 // this will return a state with only 0-th transition with tsm value 0
 stateZone* getZeroStateZone() {
 
-	stateZone* vs = new stateZone();
+	stateZone* vs = new stateZone(); //initialize a stateZone object
 	
-	vs->P = 1;
-	vs->f = 1; // no push pop info yet and L = 1
+	vs->P = 1; //the first point
+	vs->f = 1; // no push pop info yet and L = 1 cause the last bit of the flag denotes the push complete information
 	
-	vs->del = new char[1]; // memory allocation
-	vs->w = NULL;
+	vs->del = new char[1]; // memory allocation for the transitions 
+	vs->w = NULL; //the 2-dimentional array projected in to one dimentional arry initially empty
 	
 	vs->del[0] = 0; // 0th transition has tsm value 0
 	
@@ -1009,7 +1071,7 @@ bool isEmptyZone() {
 	
 	stateZone *rs, *vs, *vs1, *vs2; // some state variables required for track 
 	
-	trackZone *xrs; // back propagarion state variable
+	trackZone *xrs; // back propagation state variable
 	
 	runZone *prs; // variable for partial run of the TPDA