protected IEnumerable <Proposition> ConvertFromAST(AST ast, Language.Symbol oper)
{
if (ast == null)
{
return(null);
}
List <Proposition> result = new List <Proposition>();
string type = ast.GetType().Name;
if (type == "ASTOpBinary")
{
ASTOpBinary opBin = ast as ASTOpBinary;
if (opBin.value == oper)
{
result.AddRange(ConvertFromAST(opBin.left, oper));
result.AddRange(ConvertFromAST(opBin.right, oper));
return(result);
}
}
// else
result.Add(Proposition.FromAST(ast));
return(result);
}
public MultipleOperation(Proposition prop)
{
if (prop is BinaryOperation)
{
m_props = new List <Proposition>(Plainify(prop));
}
else
{
m_props.Add(prop);
}
}
protected IEnumerable <Proposition> Plainify(Proposition prop, string type = null)
{
List <Proposition> result = new List <Proposition>();
if (prop is BinaryOperation)
{
if (type == null)
{
type = prop.GetType().Name;
}
if (prop.GetType().Name.Equals(type))
{
BinaryOperation binary = prop as BinaryOperation;
result.AddRange(Plainify(binary.Left));
result.AddRange(Plainify(binary.Right));
return(result);
}
}
// else:
result.Add(prop);
return(result);
}
/// <summary>
/// Compare if this proposition negates other.
/// </summary>
/// <param name="other">Proposition to compare negation to</param>
/// <returns>If this proposition negates the other one</returns>
public virtual bool Negates(Proposition other)
{
return(this.Negated().Equals(other));
}
public MultipleDisjunction(Proposition prop) : base(prop)
{
}
public ExclusiveDisjunctionProposition(Proposition p, Proposition q) : base(p, q)
{
}
public EquivalentProposition(Proposition p, Proposition q) : base(p, q)
{
}
public ImpliesProposition(Proposition p, Proposition q) : base(p, q)
{
}
public DisjunctiveProposition(Proposition p, Proposition q) : base(p, q)
{
}
// Constructors
public NegationProposition(Proposition p) : base(p)
{
}
// transitional constructor
public BinaryOperation(ASTOpBinary ast)
{
Left = Proposition.FromAST(ast.left);
Right = Proposition.FromAST(ast.right);
}
public BinaryOperation(Proposition p, Proposition q)
{
Left = p; Right = q;
}
// transitional constructor.
public UnaryOperation(ASTOpUnary ast)
{
P = Proposition.FromAST(ast.ast);
}
public UnaryOperation(char letter)
{
P = new SingleProposition(letter);
}
// Constructor
public UnaryOperation(Proposition p)
{
P = p;
}
