Power Logic 

C.Second Edition

This is actually third edition of my logic class,in this edition, I made a big change. 

1。 Basic idea: 

I even change the whole 

design of Logic class from "Bool" value to "Logic State"==1:Positive; 0:Possible; -1: Negative. Because in my 

mind, as for an unknown logic object, its state is always unknown or "Possible". We can only use known logic 

object of which the logic state is either "Positive" or "Negative" to deduct all unknown logic object. Of course

during deduction, if you find out you are attempting to change an known logic object from one state(Positive 

or Negative) to its opposite state, we reach an contradiction. I basically define 4 logic operation, but the 

4th one "Conditional" is actually able to be expressed by the other three---"AND", "OR", "NOT".

	I stubbornly try to avoid to write a "parser" which is possibly beyond my ability, energy. So, I use a 

similar method to record each step of logic calculation of a rule(or a logic expression involving several logic

objects connected by logic operators). It is a stack of a record---OpRec which is containing a status flag

indicating whether it is an operand, operator or a result, a pointer in case operand or result, or simply an 

operator flag if it is an operator. In order to save space, I use an union to represent "operator" and "operand".

(It doesn't matter, nobody cares about it. I mean space.)

	The most important part is that I implement a series of judgement function according to different operators.

For example, for "AND" operator, if either of the two operand is false, and the result is true, you definitely reach 

a conclusion that they are contradictive. If the result is true, only one possible solution is that both operands

are true. This is called "deduction". So simple it is.

2。 Program design: In Logic class, there is one static object of Analyse class objects which fulfill analysing

function. In this Analyse object there is a stack to contain array of record---*OpRec--in this record, I record

each logic objects, operators, even including the temperatory logic objects. For example, ~R|W I have to record

"R" as first operand, "! " as operator, "~R" as result; "~R" as first operand for second step, "|" as operator,

"W" as operand, "~R|W" as result. So, you see I actually like using stack to do some similar job of parsing.

3。 Major function：

     A. bool Analyse::readStack(int index)

	Major function getting info from stack of Analyse class, judging the operator then call appropriate analsing function.

	result means if there is new discovery or deductions, like find a new value for any step of logic objects.

     B. void Analyse::analysing()

	Keep finding the "result" type in OpRec(the stack) and call "readStack", doing the analysing. Have to clear stack for 

	next expression checking.

	C. 	bool Analyse::analyAnd(Logic* op1, Logic* op2, Logic* result)

		bool Analyse::analyNot(Logic* op1, Logic* result)

		bool Analyse::analyOr(Logic* op1, Logic* op2, Logic* result)

		bool Analyse::analyConditional(Logic* op1, Logic* op2, Logic* result)

	These functions actually do the deduction job, given the state of result, there is certain chance you can get the state

	of certain operand under certain operator. For example: "OR" operator will only give a "Negative" result when two operand

	are both "Negative". That's the idea.

	D. void Logic::pushStack(const Logic* self, const Logic* pDummy, LogicOp opCode)

		This function will put the pointer of each operand, operator, result which is in array of "temp" into Analyse's 

		stack.

	E. LogicState Logic::And(LogicState self, LogicState dummy)

	This is logic "AND"! Have you found out? Say, true=1, false = -1 then result = true "AND"  false = (-1*1)

	There is only one exception: -1*(-1) = 1, so, I only have to judge when two operands are same. In this case, the result is

	same as any of operand.(true&&true=true; false&&false = false) Even Possible is included by the rule as 1*0=0(Possible with 

	any other state is still possible.)

	F. LogicState Logic::And(LogicState self, LogicState dummy)

	This is logic "OR".  The result is always the bigger one among two operands. Right? (say true||false= true, even Possible

	which is 0 also falls within the rule.)

	G. LogicState Logic::Not(LogicState self)

	This is logic "NOT". Whenever the operand is, just times -1. (!true = false)　

	H. void setFacts();     void setFactStr()

	These two global function does initialization job to set the Logic objects with initial Logic state and name expression.

	I. Logic& (* checkLists[10])() = {check1, check2, check3, check4, check5, check6,	check7, check8, check9, check10};

	This is a function array which initialize to 10 checking functions each of which is a logic expression with Logic objects

	in the logic list of "element[ElementNum]" and connected by logic operators. The return value is actually the final result

	Logic objects which is stored in the internal list "temp" along all other transpositional results. And this last result

	itself is the so-called "RULE" which should be true. and I set up its state to be Positive before deduction in 

		void Analyse::analysing()

4。 Further improvement：

	A. I always want to write those global function to make them part of class function. But it is not a easy 

	job.

	B.

#include <iostream>

using namespace std;

const int StackLimit = 30;

enum LogicOp
{AND, OR, NOT, CONDITIONAL};

enum OpState
{Operand, Operator, Result};

enum LogicState
{Positive =1, Possible =0, Negative =-1};

bool operator == (LogicState self, LogicState dummy)
{
	return ((self - dummy) == 0);
}

//forward declaration
class Analyse;

char* OpStr[4] = {" AND ", " OR ", " NOT "," CONDITIONAL "};

class Logic
{
private:
	static Analyse* analyse;
	static bool status;
	static int logicCount;
	char* express;
	int index;
	LogicState state;
	void catName(char*, const char*, LogicOp); 
	static Logic* temp[100];
	static int tempCount;
	static Logic* TRUE;
	static Logic* FALSE;
	bool definedStatus;
	LogicState And(LogicState self, LogicState dummy);
	LogicState Or(LogicState self, LogicState dummy);
	LogicState Not(LogicState self);
	void pushStack(const Logic* self, const Logic* pDummy, LogicOp opCode); 
	Logic* getTemp() { return temp[tempCount -1];}
protected:
	void initialize();
	bool compare(const Logic& dummy);
	void uninitialize();
public:
	Analyse* getAnalyse();
	Logic(const char* newExpress, const LogicState value=Possible);
	~Logic();
	Logic();
	void prepare();
	bool getStatus() const {return definedStatus;}
	void setStatus(const bool newStatus) {definedStatus = newStatus;}
	void setExpress(const char*);
	char* getExpress() const {return express;}
	void setIndex(const int newIndex) { index = newIndex;}
	int getIndex() const {return index;}
	void setState(LogicState newState) { state = newState;}
	LogicState getState() const{ return state;}
	static const int count()  {return logicCount;}
	Logic& operator&&(Logic& dummy);
	Logic& operator||(Logic& dummy);
	Logic& operator!();
	bool operator==(const Logic& dummy);
	Logic& operator&&(const bool value);
	Logic& operator||(const bool value);	
	Logic& operator=(const Logic& dummy);
	Logic& operator>>(Logic& dummy);
	void doAnalysing(); 
};

union UNKNOWN
{
	LogicOp operator = (LogicOp dummy);
	Logic* operator = (const Logic* dummy);
	Logic* logic;
	LogicOp op;
};

struct OpRec
{
	OpState opType;
	union UNKNOWN unknown;
};

Logic* UNKNOWN::operator =(const Logic* dummy)
{
	logic = (Logic*)dummy;
	return logic;
}

LogicOp UNKNOWN::operator = (LogicOp dummy)
{
	op = dummy;
	return op;
}

class Analyse
{
private:
	bool analyAnd(Logic* op1, Logic* op2, Logic* result);
	bool analyOr(Logic* op1, Logic* op2, Logic* result);
	bool analyConditional(Logic* op1, Logic* op2, Logic* result);
	bool analyNot(Logic* op1, Logic* result);
	static OpRec* opStack[StackLimit];	
	int top;
	void clearStack();
	LogicOp findOpCode(int index);
	bool setNewOp(Logic* dummy, LogicState newValue);
	int findPreResult(int index);
	OpRec* getTop(){ if (top>0)  return opStack[top -1]; else return NULL;}
public:
	Analyse();
	~Analyse();
	void push(OpRec* newRec) {if (top<StackLimit) opStack[top++] = newRec;}
	OpRec* pop() {if (top>0) return opStack[--top];}
	bool readStack(int index);
	void analysing();
};

const ElementNum = 7;

enum ELEMENT
{R,S,I,W,D,H,F};

char* factStr[7] = 
	{"It is raining", "It is snowing", "I get ill","I get wet", "I need doctor",
	"It is hot", "I have a fevor"};

Logic element[ElementNum];

Logic& check1();

Logic& check2();

Logic& check3();

Logic& check4();

Logic& check5();

Logic& check6();

Logic& check7();

Logic& check8();

Logic& check9();

Logic& check10();

Logic& (* checkLists[10])() = {check1, check2, check3, check4, check5, check6,
	check7, check8, check9, check10};

char* logicStr[3] = {"True", "Unknown", "False"};

void displayResult();

void setFactStr();

void setFacts();

int main()
{
	setFactStr();
	setFacts();
	for (int j=0; j<2; j++)
	{

		for (int i=0; i<10; i++)
		{
			cout<<"\nNow check rule of no "<<i<<endl;
			(checkLists[i]()).doAnalysing();
		}
	}
	displayResult();

	return 0;
}

void setFacts()
{
	element[R].setState(Positive);
	element[H].setState(Negative);
}

void setFactStr()
{
	for (int i=0; i< ElementNum; i++)
	{
		element[i].setExpress(factStr[i]);
	}
}

void displayResult()
{
	for (int i=0; i< ElementNum; i++)
	{
		cout<<"\nThe logic expression '"<<factStr[i]<<" 'is ";
		switch (element[i].getState())
		{
		case Positive:
			cout<<logicStr[0];
			break;
		case Possible:
			cout<<logicStr[1];
			break;
		case Negative:
			cout<<logicStr[2];
			break;
		}
		cout<<"\n";
	}
}

Logic& check10()
{
	return (!element[R])||(element[W]);
}

Logic& check2()
{
	return (element[R])||(element[S]);
}

Logic& check3()
{
	return (!element[R])||(!element[S]);
}

Logic& check4()
{
	return (!element[S])||(!element[H]);
}

Logic& check5()
{
	return (!element[W])||(element[H])||(element[I]);
}

Logic& check6()
{
	return (!element[I])||(!element[F])||(element[D]);
}

Logic& check7()
{
	return (element[F])||(!element[D]);
}

Logic& check1()
{
	return (!element[S])||(!element[H]);
}

Logic& check9()
{
	return (!element[I])||(element[H])||(element[D]);
}

Logic& check8()
{
	return (element[H])||(!element[I])||(!element[W])||(element[F]);
}

Analyse* Logic::getAnalyse()
{
	return analyse;
}

void Logic::doAnalysing()
{
	getAnalyse()->analysing();
}

int Analyse::findPreResult(int index)
{
	while (index > 0)
	{
		index -- ;
		if  (opStack[index]->opType== Result)
			return index;
	}
	return -1;
}

void Analyse::analysing()
{
	if (getTop()->opType!= Result)
	{
		cout<<"\nOpStack is not ended with Result:"<<endl;
			return ;
	}
	else
	{
		int i = top -1;
		opStack[i]->unknown.logic->setState(Positive);
		while (i!= -1)
		{
			readStack(i);
			i = findPreResult(i);		
		}
	}
	clearStack();
}

LogicOp Analyse::findOpCode(int index)
{
	int i = index;
	while (opStack[i]->opType != Operator)
	{
		i--;
	}
	return opStack[i]->unknown.op;
}

bool Analyse::readStack(int index)
{	
	bool result= false;
	LogicOp opCode;
	if (opStack[index]->opType != Result )
	{
		cout<<"Stack error!\n";
		return false;
	}
	opCode = findOpCode(index);
	switch (opCode)
	{
	case AND:
		result = analyAnd(opStack[index-3]->unknown.logic, 
			opStack[index - 1]->unknown.logic, 	opStack[index]->unknown.logic);
		break;
	case OR:
		result = analyOr(opStack[index-3]->unknown.logic, 
			opStack[index - 1]->unknown.logic, opStack[index]->unknown.logic);
		break;
	case CONDITIONAL:
		result = analyConditional(opStack[index-3]->unknown.logic, 
			opStack[index - 1]->unknown.logic, opStack[index]->unknown.logic);
		break;
	case NOT:
		result = analyNot(opStack[index -1]->unknown.logic, opStack[index]->unknown.logic);
		break;
	}
	return result;
}

bool Analyse::setNewOp(Logic* dummy, LogicState newValue)
{
	if (dummy->getState()!= newValue)
	{
		if (dummy->getState() != Possible)
		{
			cout<<"\nYou are changing expression '"<<dummy->getExpress()<<"' value!";
			return false;
		}
		else
		{
			dummy->setState(newValue);
			return true;
		}
	}
	else
		return false;
}

bool Analyse::analyAnd(Logic* op1, Logic* op2, Logic* result)
{
	bool newOp = false;
	switch (result->getState())
	{
	case Positive:
		if (op1->getState()==Negative||op2->getState()==Negative)
		{
			cout<<"\nThere is contradictive at:"<<result->getExpress();
			return false;
		}
	

		newOp =	setNewOp(op1, Positive) || setNewOp(op2 ,Positive);
			

		break;
	case Negative:
		if (op1->getState()==Positive&&op2->getState() == Positive)
		{
			cout<<"\nThere is contradictive at:"<<result->getExpress();
			return false;
		}
		if (op1->getState()==Positive)
		{
			newOp = setNewOp(op2, Negative);		
		}
		else
		{
			if (op2->getState() == Positive)
			{
				newOp = newOp || setNewOp(op1, Negative);
			}
		}
		break;
	case Possible:
		break;
	}
	return false;
}

bool Analyse::analyOr(Logic* op1, Logic* op2, Logic* result)
{
	bool newOp = false;
	switch(result->getState())
	{
	case Positive:
		if (op1->getState()==Negative && op2->getState()==Negative)
		{
			cout<<"\nThere is contradictive at:"<<result->getExpress();
			return false;
		}
		if (op1->getState() == Negative)
		{
			newOp = setNewOp(op2, Positive);
		}
		else
		{
			if (op2->getState() == Negative)
			{
				newOp = newOp || setNewOp(op1, Positive);
			}
		}
		break;
	case Negative:
		if (op1->getState()==Positive || op2->getState()== Positive)
		{
			cout<<"\nThere is contradictive at:"<<result->getExpress();
			return false;
		}
		break;
	case Possible:
		break;
	}
	return newOp;
}

bool Analyse::analyConditional(Logic* op1, Logic* op2, Logic* result)
{
	bool newOp = false;
	switch (result->getState())
	{
	case Positive:
		if (op1->getState()==Positive&& op2->getState()== Negative)
		{
			cout<<"\nThere is contradictive at:"<<result->getExpress();
			return false;
		}
		if (op1->getState()==Positive)
		{
			newOp = setNewOp(op2, Positive);
		}
		else
		{
			if (op2->getState() == Positive)
			{
				newOp = setNewOp(op1, Positive);
			}
		}
		break;
	case Negative:
		if (op1->getState() == Negative)
		{
			cout<<"\nThere is contradictive at:"<<result->getExpress();
			return false;
		}

		newOp = setNewOp(op2, Negative);
		newOp = newOp || setNewOp(op1, Positive);
		break;
	case Possible:
		break;
	}
	return newOp;
}
	

bool Analyse::analyNot(Logic* op1, Logic* result)
{
	bool newOp = false;
	

	switch (result->getState())
	{
	case Positive:
		if (op1->getState() == Positive)
		{
			cout<<"\nThere is contradictive at:"<<result->getExpress();
			return false;
		}
		else
		{
			newOp = setNewOp(op1, Negative);
		}
		break;
	case Negative:
		if (op1->getState() == Negative)
		{
			cout<<"\nThere is contradictive at:"<<result->getExpress();
			return false;
		}
		else
		{
			newOp = setNewOp(op1, Positive);
		}
		break;
	case Possible:
		break;
	}
	return newOp;
}

	
Analyse* Logic::analyse = new Analyse;

OpRec* Analyse::opStack[StackLimit];

void Analyse::clearStack()
{
	for (int i =0; i< top; i++)
	{
		delete opStack[i];
	}
	top = 0;
}

Analyse::Analyse()
{
	top = 0;
}

Analyse::~Analyse()
{
	clearStack();
}

LogicState Logic::And(LogicState self, LogicState dummy)
{
	if (self!=dummy)
	{
		return (LogicState)(self*dummy);
	}
	else
	{
		return self;
	}
}

LogicState Logic::Or(LogicState self, LogicState dummy)
{
	return ((self>= dummy)?self: dummy);
}

LogicState Logic::Not(LogicState self)
{
	return (LogicState)(-1* self);
}

void Logic::prepare()
{
	for (int i=0; i< tempCount; i++)
	{
		free(temp[i]);
	}
	tempCount =0;
}

Logic& Logic::operator >>(Logic& dummy)
{
	char buffer[256];
	catName(buffer, dummy.getExpress(), CONDITIONAL);

	temp[tempCount] = new Logic(buffer);

	temp[tempCount]->setState(Or(Not(state), dummy.getState()));
	

	tempCount++;
	pushStack(this, &dummy, CONDITIONAL);

	return *temp[tempCount-1];		
}

void Logic::uninitialize()
{
	status = true;
	

	for (int i=0; i< tempCount;i++)
	{
		delete temp[i];
	}
}

bool Logic::status = false;

Logic* Logic::temp[100] = {NULL}; // = new Logic;

int Logic::tempCount = 0;

Logic* Logic::FALSE = new Logic("FALSE", Negative);

Logic& Logic::operator =(const Logic& dummy)
{
	setExpress(dummy.getExpress());
	setState(dummy.getState());
	return *this;
}

Logic* Logic::TRUE = new Logic("TRUE", Positive);;

Logic& Logic::operator &&(const bool value)
{
	if (value)
	{
		return (*this)&&(*TRUE);
	}
	else
	{
		return (*this)&&(*FALSE);
	}
}

Logic& Logic::operator ||(const bool value)
{
	if (value)
	{
		return (*this)||(*TRUE);
	}
	else
	{
		return (*this)||(*FALSE);
	}
}

bool Logic::operator ==(const Logic& dummy)
{
	return compare(dummy);
}

bool Logic::compare(const Logic& dummy)
{
	return (index==dummy.getIndex());
}

void Logic::catName(char* buffer, const char* second, LogicOp opcode)
{	
	strcpy(buffer, getExpress());
	strcat(buffer, OpStr[opcode]);
	strcat(buffer, second);
}

Logic& Logic::operator !()
{
	char buffer[256];
	OpRec* ptr;
	strcpy(buffer, OpStr[NOT]);
	strcat(buffer, getExpress());

	temp[tempCount] = new Logic(buffer);
	temp[tempCount]->setState(Not(getState()));

	tempCount++;
	

	ptr = new OpRec;
	ptr->opType = Operator;
	ptr->unknown = NOT;
	

	analyse->push(ptr);

	ptr = new OpRec;
	ptr->opType = Operand;
	ptr->unknown = this;

	analyse->push(ptr);

	ptr = new OpRec;
	ptr->opType = Result;
	ptr->unknown = temp[tempCount-1];

	analyse->push(ptr);

	return *temp[tempCount-1];	
}

void Logic::pushStack(const Logic* self, const Logic* pDummy, LogicOp opCode)
{
	OpRec* ptr;

	ptr = new OpRec;
	ptr->opType = Operand;
	ptr->unknown = self;
	analyse->push(ptr);

	ptr = new OpRec;
	ptr->opType = Operator;
	ptr->unknown = opCode;
	analyse->push(ptr);

	ptr = new OpRec;
	ptr->opType = Operand;
	ptr->unknown = pDummy;
	analyse->push(ptr);

	ptr = new OpRec;
	ptr->opType = Result;
	ptr->unknown = getTemp();
	analyse->push(ptr);
}
	

Logic& Logic::operator &&(Logic& dummy)
{
	char buffer[256];
	

	catName(buffer, dummy.getExpress(), AND);

	temp[tempCount] = new Logic(buffer);
	temp[tempCount]->setState(And(getState(),dummy.getState()));

	tempCount++;
	pushStack(this, &dummy, AND);

	return *temp[tempCount-1];
}

Logic& Logic::operator ||(Logic& dummy)
{
	char buffer[256];
	catName(buffer, dummy.getExpress(), OR);
	

	temp[tempCount] = new Logic(buffer);
	temp[tempCount]->setState(Or(getState(),dummy.getState()));

	tempCount++;
	pushStack(this, &dummy, OR);

	return *temp[tempCount-1];
}

int Logic::logicCount =0;

void Logic::initialize()
{
	express = NULL;
	state = Possible;
	definedStatus = false;
	setIndex(logicCount);
	logicCount++;
	status = false;
}

Logic::~Logic()
{

	if (!status)  //if you destroy one, then you destroy all!!!!!
	{
		uninitialize();
	}

	if (express!=NULL)
	{
		free(express);
	}
}

Logic::Logic(const char* newExpress, const LogicState value)
{
	initialize();
	setExpress(newExpress);
	setState(value);
}

Logic::Logic()
{
	initialize();
}

void Logic::setExpress(const char* newExpress)
{
	int i;
	i = strlen(newExpress) +1;

	if (express==NULL)
	{	
		express = (char*)malloc(i);		
	}
	else
	{
		express = (char*)realloc((void*)express, i);
	}

	strcpy(express, newExpress);

}