getMinDistancePath function | find min graph distances used this function to refine and remove large distances

Author: saeidEmadi

decoder.cpp

@@ -4,7 +4,7 @@
 /*
 	// No. of state check
 	We have used unsigned __int8 data type value in this simulation,
-	it is obvious that it cannot be checked more than 4 times 
+	it is obvious that it cannot be checked more than 4 times
 	(with 8 bits, 4 bits can be decoded).
 */
 #define MAX_STATE_CEHCK 4
@@ -18,8 +18,9 @@ decoder::decoder() {
 
 unsigned __int8 decoder::decode(unsigned __int8 recv) {
 	std::cout << "decoder : " << std::bitset<8>(recv) << std::endl;
-	node* n = graphTracer(0, recv, 1);
-	printStates(n);
+	//node* n = graphTracer(0, recv, 1);
+	node* n = getMinDistancePaths(0, recv, 1);
+	//printStates(n);
 	/*for (int i = 1; n->getNextFirstStateNode() != nullptr; i++) {
 		std::cout << "i : " << i << " | " << std::bitset<8>(n->getNextFirstStateNodeDistance()&0x03) << std::endl;
 		std::cout << "i : " << i << " | " << std::bitset<8>(n->getNextScondStateNodeDistance() & 0x03) << std::endl;
@@ -29,7 +30,7 @@ unsigned __int8 decoder::decode(unsigned __int8 recv) {
 }
 
 void decoder::printStates(node* n) {
-	if (n->getNextFirstStateNode() == nullptr) {
+	if (n->getNextFirstStateNode() == nullptr || n->getNextScondStateNode() == nullptr) {
 		return;
 	}
 	std::cout << "state : " << std::bitset<8>(n->getState()) << std::endl;
@@ -41,50 +42,145 @@ void decoder::printStates(node* n) {
 	this->printStates(n->getNextScondStateNode());
 }
 
-node* decoder::graphTracer(unsigned __int8 state, unsigned __int8 data, unsigned __int8 level){
+node* decoder::getMinDistancePaths(unsigned __int8 state, unsigned __int8 data, unsigned __int8 level) {
 	// return point | break point of recursive loop
 	if (level == MAX_STATE_CEHCK + 2) {
 		return nullptr;
 	}
 
+	// data shifter : shift in each level
+	__int8 shiftVal = 0;
+	switch (level) {
+	case 1:
+		shiftVal = 6;
+		break;
+	case 2:
+		shiftVal = 4;
+		break;
+	case 3:
+		shiftVal = 2;
+		break;
+	case 4:
+		shiftVal = 0;
+		break;
+	default:
+		shiftVal = 0;
+		break;
+	}
+
+
 	// set next states value
 	// -1 == null value | initial value
 	unsigned __int8 nextFirstState = -1,
 		nextFirstStateIO = -1,
 		nextScondState = -1,
 		nextScondStateIO = -1;
 
-	switch (state){
-		case 0:
-			nextFirstState = 0;
-			nextFirstStateIO = 0,
-			nextScondState = 2,
-			nextScondStateIO = 3;
+	switch (state) {
+	case 0:
+		nextFirstState = 0;
+		nextFirstStateIO = 0,
+		nextScondState = 2,
+		nextScondStateIO = 3;
+		break;
+	case 2:
+		nextFirstState = 1;
+		nextFirstStateIO = 1,
+		nextScondState = 3,
+		nextScondStateIO = 2;
+		break;
+	case 1:
+		nextFirstState = 0;
+		nextFirstStateIO = 3,
+		nextScondState = 2,
+		nextScondStateIO = 0;
+		break;
+	case 3:
+		nextFirstState = 1;
+		nextFirstStateIO = 2,
+		nextScondState = 3,
+		nextScondStateIO = 1;
+		break;
+	}
+	node* stateNode = new node(state & 0x03);
+	stateNode->setNextFirstStateNodeDistance(this->hammingDistance((data >> shiftVal) & 0x03, nextFirstStateIO));
+	stateNode->setNextScondStateNodeDistance(this->hammingDistance((data >> shiftVal) & 0x03, nextScondStateIO));
+	if (stateNode->getNextFirstStateNodeDistance() > stateNode->getNextScondStateNodeDistance()) {
+		stateNode->setNextScondStateNode(*this->getMinDistancePaths(nextScondState, data, level + 1));
+	}else if (stateNode->getNextFirstStateNodeDistance() < stateNode->getNextScondStateNodeDistance()) {
+		stateNode->setNextFirstStateNode(*this->getMinDistancePaths(nextFirstState, data, level + 1));
+	}else {
+		stateNode->setNextFirstStateNode(*this->getMinDistancePaths(nextFirstState, data, level + 1));
+		stateNode->setNextScondStateNode(*this->getMinDistancePaths(nextScondState, data, level + 1));
+	}
+	return stateNode;
+}
+
+node* decoder::graphTracer(unsigned __int8 state, unsigned __int8 data, unsigned __int8 level) {
+	// return point | break point of recursive loop
+	if (level == MAX_STATE_CEHCK + 2) {
+		return nullptr;
+	}
+
+	// data shifter : shift in each level
+	__int8 shiftVal = 0;
+	switch (level){
+		case 1:
+			shiftVal = 6;
 			break;
 		case 2:
-			nextFirstState = 1;
-			nextFirstStateIO = 1,
-			nextScondState = 3,
-			nextScondStateIO = 2;
-			break;
-		case 1:
-			nextFirstState = 0;
-			nextFirstStateIO = 3,
-			nextScondState = 2,
-			nextScondStateIO = 0;
+			shiftVal = 4;
 			break;
 		case 3:
-			nextFirstState = 1;
-			nextFirstStateIO = 2,
-			nextScondState = 3,
-			nextScondStateIO = 1;
+			shiftVal = 2;
+			break;
+		case 4:
+			shiftVal = 0;
+			break;
+		default:
+			shiftVal = 0;
 			break;
 	}
+
+
+	// set next states value
+	// -1 == null value | initial value
+	unsigned __int8 nextFirstState = -1,
+		nextFirstStateIO = -1,
+		nextScondState = -1,
+		nextScondStateIO = -1;
+
+	switch (state) {
+	case 0:
+		nextFirstState = 0;
+		nextFirstStateIO = 0,
+		nextScondState = 2,
+		nextScondStateIO = 3;
+		break;
+	case 2:
+		nextFirstState = 1;
+		nextFirstStateIO = 1,
+		nextScondState = 3,
+		nextScondStateIO = 2;
+		break;
+	case 1:
+		nextFirstState = 0;
+		nextFirstStateIO = 3,
+		nextScondState = 2,
+		nextScondStateIO = 0;
+		break;
+	case 3:
+		nextFirstState = 1;
+		nextFirstStateIO = 2,
+		nextScondState = 3,
+		nextScondStateIO = 1;
+		break;
+	}
 	node* stateNode = new node(state & 0x03);
 	stateNode->setNextFirstStateNode(*this->graphTracer(nextFirstState, data, level + 1));
 	stateNode->setNextScondStateNode(*this->graphTracer(nextScondState, data, level + 1));
-	stateNode->setNextFirstStateNodeDistance(this->hammingDistance(data,nextFirstStateIO));
-	stateNode->setNextScondStateNodeDistance(this->hammingDistance(data,nextScondStateIO));
+	stateNode->setNextFirstStateNodeDistance(this->hammingDistance((data >> shiftVal) & 0x03, nextFirstStateIO));
+	stateNode->setNextScondStateNodeDistance(this->hammingDistance((data >> shiftVal) & 0x03, nextScondStateIO));
 	return stateNode;
 }