/// <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> /// 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 ConstantInt64; if (term != null) { return m_Value == term.m_Value; } return false; }
/// <summary> /// Dump node to MathML /// </summary> /// <param name="writer"></param> /// <param name="parent"></param> public override void ToMathML(XmlWriter writer, SymMathNode parent) { writer.WriteStartElement("msup"); writer.WriteStartElement("mrow"); A.ToMathML(writer, this); writer.WriteEndElement(); writer.WriteStartElement("mrow"); B.ToMathML(writer, this); writer.WriteEndElement(); writer.WriteEndElement(); }
/// <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> /// 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> /// 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 Add; if (add != null) { return A.Equals(add.B) && B.Equals(add.A); } return false; }
/// <summary> /// Dump node to string /// </summary> /// <param name="builder"></param> /// <param name="parent"></param> public override void ToString(StringBuilder builder, SymMathNode parent) { builder.Append("Sqrt("); A.ToString(builder, this); builder.Append(")"); }
/// <summary> /// Clones current node (deep-copy) /// </summary> /// <param name="a"></param> /// <returns></returns> public abstract UnaryOperation Clone(SymMathNode a);
/// <summary> /// ctor /// </summary> /// <param name="a"></param> public UnaryOperation(SymMathNode a) { A = 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> /// 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> /// <param name="b"></param> public Power(SymMathNode a, SymMathNode b) : base(a, b) { }
/// <summary> /// ctor /// </summary> /// <param name="a"></param> /// <param name="b"></param> public Add(SymMathNode a, SymMathNode b) : base(a, b) { A = a; B = b; }
/// <summary> /// Clones current node (deep-copy) /// </summary> /// <param name="a"></param> /// <returns></returns> public override UnaryOperation Clone(SymMathNode a) { return new SquareRoot(a); }
/// <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> /// ctor /// </summary> /// <param name="a"></param> public SquareRoot(SymMathNode a) : base(a) { }
/// <summary> /// ctor /// </summary> /// <param name="a"></param> /// <param name="b"></param> public Division(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 abstract BinaryOperation Clone(SymMathNode a, SymMathNode b);
/// <summary> /// ctor /// </summary> /// <param name="a"></param> /// <param name="b"></param> public BinaryOperation(SymMathNode a, SymMathNode b) { A = a; B = b; }
/// <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 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 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 Add(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(m_Value); }
public override bool IsApplicable(Division node) { var mulA = node.A as Multiply; SymMathNode mulAOther = null; Constant termN = node.A as Constant; if (mulA != null) { if (mulA.A is Constant && !(mulA.B is Constant)) { termN = (Constant)mulA.A; mulAOther = mulA.B; } if (mulA.B is Constant && !(mulA.A is Constant)) { termN = (Constant)mulA.B; mulAOther = mulA.A; } } Constant termD = node.B as Constant; var mulB = node.B as Multiply; SymMathNode mulBOther = null; if (mulB != null) { if (mulB.A is Constant && !(mulB.B is Constant)) { termD = (Constant)mulB.A; mulBOther = mulB.B; } if (mulB.B is Constant && !(mulB.A is Constant)) { termD = (Constant)mulB.B; mulBOther = mulB.A; } } if (termN != null && termD != null) { var gcd = Constant.Gcd(termN, termD); if (!gcd.IsOne()) { termN = (Constant)(termN / gcd); termD = (Constant)(termD / gcd); SymMathNode newA = termN; if (mulAOther != null) { newA = new Multiply(termN, mulAOther); } SymMathNode newB = termD; if (mulBOther != null) { newB = new Multiply(termD, mulBOther); } return(true); } } return(false); }
/// <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> /// 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> /// ctor /// </summary> /// <param name="a"></param> /// <param name="b"></param> public Equality(SymMathNode a, SymMathNode b) : base(a, b) { }
/// <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); }
/// <summary> /// ctor /// </summary> /// <param name="a"></param> public Minus(SymMathNode a) : base(a) { }