private void StartParsing()
{
if (IsdataANumberOrX())
{
_operator = GetNumberOrXOperator();
return;
}
switch (_data[0])
{
case '!':
_operator = new FactorialMathOperator(GetNumberInOperator());
return;
case 'n':
case 'r':
_operator = new ConstantMathOperator(GetNumberInOperator());
return;
}
var factory = new OperatorFactory();
var oper = factory.GetOperator(_data[0]);
Console.WriteLine(_data[0]);
oper.Instantiate(oper.GetOperatorNeededArguments() == 2
? new[] { GetFirstArgument(), GetSecondArgument() }
: new[] { GetFirstArgument() });
_operator = oper;
}
public static IBaseMathOperator CalculateNPolynomial(IBaseMathOperator original, double x, uint n)
{
var addList = new List <IBaseMathOperator>();
var lastDerivative = original;
original.SetXValue(x);
addList.Add(new ConstantMathOperator(original.Result()));
for (var i = 1; i < n; i++)
{
var times = new MultiplyMathOperator();
{
var der = lastDerivative.Derivate();
lastDerivative = der;
}
lastDerivative.SetXValue(x);
var divide = new DevideMathOperator();
var factorial = new FactorialMathOperator(i);
divide.Instantiate(new IBaseMathOperator[] { new ConstantMathOperator(lastDerivative.Result()), factorial });
var minus = new MinMathOperator();
minus.Instantiate(new IBaseMathOperator[] { new VariableXMathOperator(), new ConstantMathOperator(x) });
var power = new ExpotentialOperator();
power.Instantiate(new IBaseMathOperator[] { minus, new ConstantMathOperator(i) });
times.Instantiate(new IBaseMathOperator[] { divide, power });
addList.Add(times.DeepSimplyfy());
}
return(new AddMathOperator().CreateFromList(addList).DeepSimplyfy());
}
public override IBaseMathOperator Simplyfy()
{
if (cachedSimplyfy != null)
{
return(cachedSimplyfy);
}
return(cachedSimplyfy = CalculateSimplyfy());
}
private static double GetYValue(IBaseMathOperator oper, double x, double h)
{
oper.SetXValue(x + h);
var first = oper.Result();
oper.SetXValue(x);
var second = oper.Result();
return((first - second) / h);
}
public static double CalculateSum(IBaseMathOperator oper, double start, double end, double increase = 0.00001d)
{
double total = 0;
for (var i = start; i < end; i += increase)
{
var result = oper.Result();
oper.SetXValue(i);
total += result * increase;
}
return(total);
}
public static JsonModel CreateFromBaseOpeator(IBaseMathOperator baseOperator)
{
var json = new JsonModel();
var text = new TextModel();
text.title = baseOperator.MathSymbol();
json.text = text;
if (baseOperator.GetChilds() != null)
{
json.children = baseOperator.GetChilds().Where(x => x != null).Select(CreateFromBaseOpeator).ToList();
}
return(json);
}
public static IList <Point> CalculatePoints(IBaseMathOperator oper, double h, double spaceX, double startX, double endX)
{
var list = new List <Point>();
for (var x = startX; x <= endX; x += spaceX)
{
var point = new Point
{
X = x,
Y = GetYValue(oper, x, h)
};
list.Add(point);
}
return(list);
}
public static ExpotentialOperator SetExpotentialOperator(IBaseMathOperator A, float number)
{
var expo = new ExpotentialOperator();
if (A is ExpotentialOperator)
{
var times = new MultiplyMathOperator();
times.Instantiate(new IBaseMathOperator[] { A.GetChilds()[1], new ConstantMathOperator(number), });
expo.Instantiate(new IBaseMathOperator[] { A.GetChilds()[0], times });
return(expo);
}
expo.Instantiate(new IBaseMathOperator[] { A, new ConstantMathOperator(number) });
return(expo);
}
public override IBaseMathOperator Simplyfy()
{
if (_cachedSimplify != null)
{
return(_cachedSimplify);
}
IBaseMathOperator result = null;
do
{
var calc = CalculateSimplyfy();
if (result != null && calc.ToMathString().Equals(result.ToMathString()))
{
_cachedSimplify = calc;
return(calc);
}
result = calc;
} while (true);
}
public virtual void Instantiate(IBaseMathOperator[] arguments)
{
A = arguments[0];
}
public override void Instantiate(IBaseMathOperator[] arguments)
{
base.Instantiate(arguments);
B = arguments[1];
}
