/// <summary>
/// ctor. Term.Factory has to be set otherwise exception is thrown
/// </summary>
/// <param name="a"></param>
public UnaryOperation(long a)
{
if (Constant.Factory == null)
{
throw new Exception("Please set Term.Factory first (you can set it to TermBigInteger.Factory or to TermInt64.Factory).");
}
A = Constant.Factory.Create(a);
}
/// <summary>
/// Returns ture if node is of type T and condition evaluate is satisfied
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="node"></param>
/// <param name="evaluate"></param>
/// <returns></returns>
public static bool IfType <T>(this SymMathNode node, Func <T, bool> evaluate) where T : class
{
var t = node as T;
if (t != null)
{
return(evaluate.Invoke(t));
}
return(false);
}
/// <summary>
/// Returns true if this tree is equal to node tree
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public override bool Equals(SymMathNode node)
{
var term = node as ConstantBigInteger;
if (term != null)
{
return(m_Value == term.m_Value);
}
return(false);
}
/// <summary>
/// True if equal to variable represented by the same symbol
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public override bool Equals(SymMathNode node)
{
var term = node as Variable;
if (term != null)
{
return(string.Equals(Symbol, term.Symbol, StringComparison.OrdinalIgnoreCase));
}
return(false);
}
/// <summary>
/// Dump node to MathML
/// </summary>
/// <param name="writer"></param>
/// <param name="parent"></param>
public override void ToMathML(XmlWriter writer, SymMathNode parent)
{
if (writer == null)
{
throw new ArgumentNullException("writer");
}
writer.WriteStartElement("msqrt");
A.ToMathML(writer);
writer.WriteEndElement();
}
/// <summary>
/// Dump node to MathML
/// </summary>
/// <param name="writer"></param>
/// <param name="parent"></param>
public override void ToMathML(XmlWriter writer, SymMathNode parent)
{
writer.WriteStartElement("mfrac");
writer.WriteStartElement("mrow");
A.ToMathML(writer, this);
writer.WriteEndElement();
writer.WriteStartElement("mrow");
B.ToMathML(writer, this);
writer.WriteEndElement();
writer.WriteEndElement();
}
/// <summary>
/// If any simplification rule exits, simplify given node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static SymMathNode Simplify(this SymMathNode node)
{
foreach (var rule in node.GetSimplificationRules())
{
if (rule.IsApplicable(node))
{
return(rule.Apply(node));
}
}
return(node);
}
/// <summary>
/// If any simplification rule exits, simplify given node
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static bool CanSimplify(this SymMathNode node)
{
foreach (var rule in node.GetSimplificationRules())
{
if (rule.IsApplicable(node))
{
return(true);
}
}
return(false);
}
/// <summary>
/// Returns true if this tree is equal to node tree
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public override bool Equals(SymMathNode node)
{
if (this.GetType() == node.GetType())
{
var unaryOperation = node as UnaryOperation;
if (unaryOperation != null)
{
return(A.Equals(unaryOperation.A));
}
}
return(false);
}
/// <summary>
/// Dump node to MathML
/// </summary>
/// <param name="writer"></param>
/// <param name="parent"></param>
public override void ToMathML(XmlWriter writer, SymMathNode parent)
{
if (m_Value < 0)
{
writer.WriteElementString("mo", "-");
writer.WriteElementString("mn", Convert.ToString(-m_Value));
}
else
{
writer.WriteElementString("mn", Convert.ToString(m_Value));
}
}
/// <summary>
/// Returns true if A is symbolically equal to node.A and
/// B is symbolically equal to node.B
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public override bool Equals(SymMathNode node)
{
if (GetType() == node.GetType())
{
var binaryOperation = node as BinaryOperation;
if (binaryOperation != null)
{
return(A.Equals(binaryOperation.A) && B.Equals(binaryOperation.B));
}
}
return(false);
}
/// <summary>
/// Dump node to MathML
/// </summary>
/// <param name="writer"></param>
/// <param name="parent"></param>
public override void ToMathML(XmlWriter writer, SymMathNode parent)
{
if (m_Value < 0)
{
writer.WriteElementString("mo", "-");
writer.WriteElementString("mn", BigInteger.Abs(m_Value).ToString());
}
else
{
writer.WriteElementString("mn", m_Value.ToString());
}
}
/// <summary>
/// Dump node to MathML
/// </summary>
/// <param name="writer"></param>
/// <param name="parent"></param>
public override void ToMathML(XmlWriter writer, SymMathNode parent)
{
bool brackets = parent != null && !(parent is Add);
if (brackets)
{
writer.WriteElementString("mo", "(");
}
A.ToMathML(writer, this);
writer.WriteElementString("mo", "+");
B.ToMathML(writer, this);
if (brackets)
{
writer.WriteElementString("mo", ")");
}
}
/// <summary>
/// Returns true if this tree is equal to node tree
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public override bool Equals(SymMathNode node)
{
if (base.Equals(node))
{
return(true);
}
var add = node as Multiply;
if (add != null)
{
return(A.Equals(add.B) && B.Equals(add.A));
}
return(false);
}
/// <summary>
/// Applies all simplification rules, until none is applicable
/// </summary>
/// <param name="node"></param>
/// <returns></returns>
public static SymMathNode GetBaseForm(this SymMathNode node)
{
var result = node;
while (true)
{
bool ruleFound = false;
foreach (var rule in result.GetSimplificationRules())
{
if (rule.IsApplicable(result))
{
result = rule.Apply(result);
ruleFound = true;
break;
}
}
if (!ruleFound)
{
return(result);
}
}
}
/// <summary>
/// Dump node to string
/// </summary>
/// <param name="builder"></param>
/// <param name="parent"></param>
public override void ToString(StringBuilder builder, SymMathNode parent)
{
bool brackets = parent != null && !(parent is Add);
if (brackets)
{
builder.Append("(");
}
A.ToString(builder, this);
if (B is Minus)
{
builder.Append("-");
((Minus)B).A.ToString(builder, this);
}
else
{
builder.Append("+");
B.ToString(builder, this);
}
if (brackets)
{
builder.Append(")");
}
}
/// <summary>
/// Dump node to string
/// </summary>
/// <returns></returns>
public override void ToString(StringBuilder builder, SymMathNode parent)
{
builder.Append("-(");
A.ToString(builder, this);
builder.Append(")");
}
/// <summary>
/// Dump node to MathML
/// </summary>
/// <param name="writer"></param>
/// <param name="parent"></param>
public override void ToMathML(XmlWriter writer, SymMathNode parent)
{
throw new NotImplementedException();
}
/// <summary>
/// Clones current node (deep-copy)
/// </summary>
/// <param name="a"></param>
/// <returns></returns>
public override UnaryOperation Clone(SymMathNode a)
{
return(new Minus(a));
}
/// <summary>
/// ctor
/// </summary>
/// <param name="a"></param>
public Minus(SymMathNode a) : base(a)
{
}
/// <summary>
/// Dump node to string
/// </summary>
/// <param name="builder"></param>
/// <param name="parent"></param>
public override void ToString(StringBuilder builder, SymMathNode parent)
{
A.ToString(builder, parent);
builder.Append("=");
B.ToString(builder, parent);
}
/// <summary>
///
/// </summary>
/// <param name="writer"></param>
/// <param name="parent"></param>
public override void ToMathML(XmlWriter writer, SymMathNode parent)
{
A.ToMathML(writer, this);
writer.WriteElementString("mo", "=");
B.ToMathML(writer, this);
}
/// <inheritdoc />
public override BinaryOperation Clone(SymMathNode a, SymMathNode b)
{
return(new Equality(a, b));
}
/// <summary>
/// ctor
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
public Equality(SymMathNode a, SymMathNode b) : base(a, b)
{
}
/// <summary>
/// Clones current node (deep-copy)
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public override BinaryOperation Clone(SymMathNode a, SymMathNode b)
{
return(new Division(a, b));
}
/// <summary>
/// ctor
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
public Division(SymMathNode a, SymMathNode b) : base(a, b)
{
}
/// <summary>
/// Dump node to MathML
/// </summary>
/// <param name="writer"></param>
/// <param name="parent"></param>
public override void ToMathML(XmlWriter writer, SymMathNode parent)
{
writer.WriteElementString("mi", Symbol);
}
/// <summary>
/// Clones current node (deep-copy)
/// </summary>
/// <param name="a"></param>
/// <param name="b"></param>
/// <returns></returns>
public override BinaryOperation Clone(SymMathNode a, SymMathNode b)
{
return(new Multiply(a, b));
}
/// <summary>
/// Dump node to string
/// </summary>
/// <param name="builder"></param>
/// <param name="parent"></param>
public override void ToString(StringBuilder builder, SymMathNode parent)
{
builder.Append(Symbol);
}
/// <summary>
/// Dump node to string
/// </summary>
/// <param name="builder"></param>
/// <param name="parent"></param>
public override void ToString(StringBuilder builder, SymMathNode parent)
{
builder.Append(m_Value.ToString());
}
