public void CalculateTest(double firstValue, double expected)
{
var calculator = new Cos();
var actualResult = calculator.Calculate(firstValue);
Assert.AreEqual(expected, actualResult, 0.01);
}
public bool Visit(Cos cos)
{
cos.Parents.Clear();
cos.Arg.Accept(this);
UpdateInterval(cos, -1, 1);
return(true);
}
public void CalculateCosTestStrong(double firstValue, double expected)
{
IOneArgumentCalculator calculator = new Cos();
double result = calculator.Calculate(firstValue);
Assert.AreEqual(expected, result, 0.00001);
}
public void CosArccos()
{
var exp = new Cos(new Arccos(Variable.X));
var expected = Variable.X;
SimpleTest(exp, expected);
}
public void CosZero()
{
var exp = new Cos(zero);
var expected = new Number(Math.Cos(0));
SimpleTest(exp, expected);
}
public void CalculationTest()
{
var calculator = new Cos();
double actual = calculator.calculate(0);
Assert.AreEqual(1, actual, 0.00);
}
public void Calculate()
{
Cos calculator = new Cos();
double result = calculator.Calculate(0);
Assert.AreEqual(1, result, 0.001);
}
public void CloneTest()
{
var exp = new Cos(new Number(1));
var clone = exp.Clone();
Assert.Equal(exp, clone);
}
public async Task <IActionResult> Edit(int id, [Bind("ID,Title")] Cos cos)
{
if (id != cos.ID)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(cos);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!CosExists(cos.ID))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(cos));
}
public void CalculateTest(double argument, double result)
{
var calculator = new Cos();
var testResult = calculator.Calculate(argument);
Assert.AreEqual(result, testResult);
}
public void AddTest(double first, double expected)
{
Cos calculator = new Cos();
double result = calculator.Calculate(first);
Assert.AreEqual(expected, result, 0.0001);
}
public void CosTest(double first, double expected)
{
ISingleCalculator calculate = new Cos();
double result = calculate.Calculate(first);
Assert.AreEqual(expected, result, 0.00001);
}
public void CosCalculatorTests(double firstArgument, double result)
{
var calculator = new Cos();
var actualResult = calculator.Calculate(firstArgument);
Assert.AreEqual(result, actualResult, 0.0001);
}
public void CosArccos()
{
var exp = new Cos(new Arccos(new Variable("x")));
var expected = new Variable("x");
SimpleTest(exp, expected);
}
public void CalculateTest(double argument, double result, double accracy)
{
var testingFunction = new Cos();
var testResult = testingFunction.Calculate(argument);
Assert.AreEqual(result, testResult, accracy);
}
public void SimpleTest(double arg, double expected)
{
Cos calc = new Cos();
double result = calc.Action(arg);
Assert.AreEqual(expected, result, 0.1);
}
public void SimpleTest(double firstarg, double expected)
{
Cos calc = new Cos();
double result = calc.Calc(firstarg);
Assert.AreEqual(expected, result, 0.00000001);
}
public bool Visit(Cos cos)
{
double size = cos.Arg.Max - cos.Arg.Min;
bool c = false;
if (size <= 2 * Math.PI)
{
double a = Math.Cos(cos.Arg.Max);
double b = Math.Cos(cos.Arg.Min);
double x = Math.Ceiling(cos.Arg.Min / Math.PI);
double y = Math.Floor(cos.Arg.Max / Math.PI);
if (x == y) //single extrema
{
if (((int)x) % 2 == 0) //maxima
{
c = UpdateInterval(cos, Math.Min(a, b), 1);
}
else //minima
{
c = UpdateInterval(cos, -1, Math.Max(a, b));
}
}
else if (x > y) //no extrema
{
c = UpdateInterval(cos, Math.Min(a, b), Math.Max(a, b));
} //multiple extrema, don't update
}
if (c)
{
AddChanged(cos);
}
return(c);
}
public void CalculateTest(double value, double expected)
{
var calculator = new Cos();
var actualResult = calculator.SingleCalculate(value);
Assert.AreEqual(expected, actualResult, 0.00001);
}
public void CosTest(double first, double expected)
{
IoneCalculate calc = new Cos();
double result = calc.Calculate(first);
Assert.AreEqual(expected, result, 0.001);
}
public void CosTest(double first, double expected)
{
IOneCalculation calculator = new Cos();
double result = calculator.Calculate(first);
Assert.AreEqual(expected, result);
}
public void Derivative_Sin_CorrectResultReturned()
{
var sin = new Sin();
var expectedResult = new Cos();
Assert.AreEqual(expectedResult, sin.Derivative());
}
public void TestCos(double firstArgument, double output)
{
var calculator = new Cos();
var testResult = calculator.Calculate(firstArgument);
Assert.AreEqual(output, testResult, 0.0000001);
}
public void Derivative_Cos_CorrectResultReturned()
{
var cos = new Cos();
var expectedResult = new UnaryMinusOfFunction(new Sin());
Assert.AreEqual(expectedResult, cos.Derivative());
}
public void Build_Cos_CorrectResultReturned()
{
var cosBuilder = new CosBuilder();
var res = cosBuilder.Build("Cos");
var expectedResult = new Cos();
Assert.AreEqual(expectedResult, res);
}
public void ValueAtThePoint_Cos_CorrectResultReturned()
{
Function a = new Cos();
const double x = 1;
var expectedResult = Math.Cos(x);
Assert.AreEqual(expectedResult, a.ValueAtPoint(x));
}
public void DeriveTest()
{
var expected = new Cos(new Constant(1)) * new Constant(0);
var actual = new Sin(new Constant(1)).Derive();
Assert.Equal(expected, actual);
}
public void Calculate(double input, double output)
{
var calculator = new Cos();
var testResult = calculator.Calculate(input);
var result = output;
Assert.AreEqual(testResult, result, 0.1);
}
public void DoubleFunctionCos()
{
var sut = new Cos();
var result = sut.Execute(new List <Accumulator> {
new Accumulator(Math.PI / 3)
});
Assert.AreEqual(Math.Cos(Math.PI / 3), result.ValueAsDouble());
}
public void CosShouldReturnCorrectResult()
{
var func = new Cos();
var args = FunctionsHelper.CreateArgs(2);
var result = func.Execute(args, _parsingContext);
var roundedResult = Math.Round((double)result.Result, 9);
Assert.AreEqual(-0.416146837d, roundedResult);
}
void CreateOperators()
{
// Only one of each operation Token needs to be created
opAdd = new Add(workStack);
opSubtract = new Subtract(workStack);
opMultiply = new Multiply(workStack);
opDivide = new Divide(workStack);
opPower = new Power(workStack);
opBracket = new Bracket();
opUnaryMinus = new UnaryMinus(workStack);
opUnaryPlus = new UnaryPlus();
opSqrt = new Sqrt(workStack);
opSin = new Sin(workStack);
opCos = new Cos(workStack);
opTan = new Tan(workStack);
opLog = new Log(workStack);
opAsin = new Asin(workStack);
opAcos = new Acos(workStack);
opAtan = new Atan(workStack);
functions = new Dictionary<string, Function>
{
{"sqr", opSqrt },
{"sin", opSin },
{"cos", opCos },
{"tan", opTan },
{"log", opLog },
{"asin", opAsin },
{"acos", opAcos },
{"atan", opAtan }
};
binaryOperators = new Dictionary<char, BinaryOperator>
{
{'+', opAdd },
{'-', opSubtract },
{'*', opMultiply },
{'/', opDivide },
{'^',opPower }
};
}
