public Equation(string str) { if (str.Length < 3) { throw new Exception("Invalid equation"); } int index = 0; LeftSide = new Expression(str, ref index).Inflate(); str.PassWhiteSpace(ref index); if (str[index] != '=') { throw new Exception("Invalid equation"); } index++; RightSide = new Expression(str, ref index).Inflate(); Variables = new List <Variable>(LeftSide.Variables.Union(RightSide.Variables)); if (Variables.Count == 0) { throw new Exception("Equation found without any variable in it"); } }
public ExponentTerm(TermBase @base, TermBase degree) { if (@base is ExponentTerm et) { _degree = degree * et.Degree; _base = et.Base; } else { _base = @base; _degree = degree; } InvalidateTypeAndVariables(); }
public Equation(TermBase lhs, TermBase rhs) { if (lhs is null || rhs is null) { throw new ArgumentNullException("lhs", "Invalid equation, lhs or rhs was null"); } LeftSide = lhs; RightSide = rhs; Variables = LeftSide.Variables.Union(RightSide.Variables).ToList(); if (Variables.Count == 0) { throw new Exception("Equation found without any variable in it"); } Type = lhs.Type.CombineWith(rhs.Type); }
public double CoefficientOF(TermBase term) { if (this == term) { return(1); } if (term.Type == ExpressionType.Polynomial && Type == ExpressionType.Polynomial && Base is Expression) { var clone = (Clone() as ExponentTerm).Expand(); if (clone is Expression) { return((clone as Expression).CoEfficientOf(term)); } } return(0); }
public Expression(string str, ref int index) { NonConstantChildren = new List <TermBase>(); char oprtr = '\0'; bool starting_bracket_found = false; str.PassWhiteSpace(ref index); if (str[index].IsStartingBracket()) { starting_bracket_found = true; index++; } while (index < str.Length) { if (str[index].IsEndingBracket()) { if (starting_bracket_found) { index++; } break; } if (str[index] == '=') { break; } else if (str[index].IsAdditiveOperator()) { oprtr = str[index]; index++; continue; } TermBase ex = str.NextTerm(ref index); add_impl(ex, oprtr == '\0' ? '+' : oprtr); oprtr = '\0'; } InvalidateTypeAndVariables(); }
/// <param name="index">the index from where main body starts, excluding operator</param> public OperatoredTerm(string op, TermBase term) { Operator = op; MainBody = term; ///other stuffs Variables = MainBody.Variables; if (term.Type == ExpressionType.Constant) { Type = ExpressionType.Constant; } else { switch (op) { case "sin": case "Sin": case "cos": case "Cos": case "Tan": case "tan": case "Cot": case "cot": case "Sec": case "sec": Type = ExpressionType.Trigonometric; break; case "Log": case "log": case "ln": case "Ln": Type = ExpressionType.Logarithmic; break; } } }
public int CompareTo(TermBase other) { throw new NotImplementedException(); }
public TermBase Expand() { if (Degree.Type == ExpressionType.Constant && Base is Expression exprBase) { double degree_value = Degree.EvaluateFor(null); if (degree_value % 1 != 0 || degree_value < 2) { return(this); } if (exprBase.ConstantPart == 0) { if (exprBase.Count == 1) { return(this); } if (exprBase.Count > 2) { var Term = exprBase[exprBase.Count - 1]; var clone = exprBase.Clone() as Expression; clone.RemoveAt(exprBase.Count - 1); List <(TermBase, char)> list = new List <(TermBase, char)>(); ///(a+b)^k for (int i = 0; i <= degree_value; i++) { /// a^i * b^(k-i) * kCi TermBase atok = new ExponentTerm(clone, i).Inflate(); if (atok is IExpandable expandable) { atok = expandable.Expand(); } TermBase btok = new ExponentTerm(Term, degree_value - i).Inflate(); var term = new TermPool((atok, '*'), (btok, '*'), (degree_value.Combination(i), '*')).Inflate(); if (term is IExpandable) { term = (term as IExpandable).Expand(); } list.Add((term, '+')); } return(new Expression(list.ToArray())); } List <(TermBase, char)> list2 = new List <(TermBase, char)>(); for (int i = 0; i <= degree_value; i++) { /// a^i * b^(k-i) * kCi TermBase atok = new ExponentTerm(exprBase[0], i).Inflate(); TermBase btok = new ExponentTerm(exprBase[1], degree_value - i).Inflate(); var term = new TermPool((atok, '*'), (btok, '*'), (degree_value.Combination(i), '*')).Inflate(); if (term is IExpandable) { term = (term as IExpandable).Expand(); } list2.Add((term, '+')); } return(new Expression(list2.ToArray())); } else { if (exprBase.Count == 0) { return(this); } if (exprBase.Count > 1) { var clone = exprBase.WithoutConstantPart(); List <(TermBase, char)> list = new List <(TermBase, char)>(); ///(a+b)^k for (int i = 0; i <= degree_value; i++) { /// a^i * b^(k-i) * kCi TermBase atok = new ExponentTerm(clone, i).Inflate(); if (atok is IExpandable expandable) { atok = expandable.Expand(); } TermBase btok = Math.Pow(exprBase.ConstantPart, degree_value - i); var term = new TermPool((atok, '*'), (btok, '*'), (degree_value.Combination(i), '*')).Inflate(); if (term is IExpandable) { term = (term as IExpandable).Expand(); } list.Add((term, '+')); } return(new Expression(list.ToArray())); } List <(TermBase, char)> list2 = new List <(TermBase, char)>(); for (int i = 0; i <= degree_value; i++) { /// a^i * b^(k-i) * kCi TermBase atok = new ExponentTerm(exprBase[0], i).Inflate(); TermBase btok = Math.Pow(exprBase.ConstantPart, degree_value - i); var term = new TermPool((atok, '*'), (btok, '*'), (degree_value.Combination(i), '*')).Inflate(); if (term is IExpandable) { term = (term as IExpandable).Expand(); } list2.Add((term, '+')); } return(new Expression(list2.ToArray())); } } else if (Base is TermPool tp) { List <(TermBase, char)> list = new List <(TermBase, char)>(); for (int i = 0; i < tp.Count; i++) { list.Add((new ExponentTerm(tp[i], Degree).Inflate(), tp.Operator(i))); } if (tp.ConstantPart != 1) { if (Degree.Type == ExpressionType.Constant) { list.Add((Math.Pow(tp.ConstantPart, Degree.EvaluateFor(null)), '*')); } else { list.Add((new ExponentTerm(tp.ConstantPart, Degree), '*')); } } return(new TermPool(list.ToArray()).Inflate()); } return(this); }
public override TermBase Div(TermBase b) => b switch {
public Leaf(TermBase term, Token token, int index, string localName, bool isHead, string semanticId) : base(NodeType.Leaf, index, localName, isHead, semanticId) { Term = term; Token = token; }
public static TermsBase Create(TermBase term) => term switch {
private TermsSingle(TermBase term) { Term = term; }
public Frequency(int l, TermBase t) { eFrequency result = eFrequency.Annual; switch (t._termbase) { case TermBase.eTermBase.Days: result = eFrequency.Daily; break; case TermBase.eTermBase.Months: switch (l) { case 1: result = eFrequency.Monthly; break; case 2: result = eFrequency.Bimonthly; break; case 3: result = eFrequency.Quarterly; break; case 4: result = eFrequency.EveryFourthMonth; break; case 6: result = eFrequency.Semiannual; break; default: result = eFrequency.Semiannual; break; } break; case TermBase.eTermBase.Weeks: switch (l) { case 2: result = eFrequency.Biweekly; break; case 4: result = eFrequency.EveryFourthWeek; break; case 1: result = eFrequency.Weekly; break; default: result = eFrequency.Weekly; break; } break; case TermBase.eTermBase.Years: result = eFrequency.Annual; break; default: result = eFrequency.Once; break; } _frequency = result; }