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;
}
