public void CalculateTest()
{
IOneArgumentCalculator calculator = new Arcsin();
double result = calculator.Calculate(1);
Assert.AreEqual(1.57, result, 0.01);
}
public void CloneTest()
{
var exp = new Arcsin(new Number(1));
var clone = exp.Clone();
Assert.Equal(exp, clone);
}
public void ArcsinSin()
{
var exp = new Arcsin(new Sin(new Variable("x")));
var expected = new Variable("x");
SimpleTest(exp, expected);
}
public void CalculateTest(double argument, double result, double accracy)
{
var testingFunction = new Arcsin();
var testResult = testingFunction.Calculate(argument);
Assert.AreEqual(result, testResult, accracy);
}
public void CalculateTest(double value, double expected)
{
var calculator = new Arcsin();
var actualResult = calculator.SingleCalculate(value);
Assert.AreEqual(expected, actualResult, 0.0001);
}
public void CalculateTest(double firstValue, double expected)
{
var calculator = new Arcsin();
var actualResult = calculator.OneArgumentOperation(firstValue);
Assert.AreEqual(expected, actualResult, 0.001);
}
public void ArcsinSin()
{
var exp = new Arcsin(new Sin(Variable.X));
var expected = Variable.X;
SimpleTest(exp, expected);
}
public void Calculate()
{
Arcsin calculator = new Arcsin();
double result = calculator.Calculate(1);
Assert.AreEqual(1.570, result, 0.001);
}
public void CalculationTest(double value, double answer)
{
var calculator = new Arcsin();
double actual = calculator.calculate(value);
Assert.AreEqual(answer, actual, 0.001);
}
public void Calcpr(
double firstElement,
double expected)
{
var calculator = new Arcsin();
var actualResult = calculator.OneCalculate(firstElement);
Assert.AreEqual(expected, actualResult, 0.01);
}
public void CalculateTest(
double first,
double expected)
{
var calculator = new Arcsin();
var actualResult = calculator.CalculateTwo(first);
Assert.AreEqual(expected, actualResult, 0.001);
}
public void CalculatorTest(
double firstValue,
double expected)
{
var calculator = new Arcsin();
var actualResult = calculator.Calculate(firstValue);
Assert.Throws <Exception>(() => calculator.Calculate(-5));
Assert.AreEqual(expected, actualResult, 0.01);
}
public void ExecuteComplexNumberTest()
{
var complex = new Complex(3, 2);
var exp = new Arcsin(new ComplexNumber(complex));
var result = (Complex)exp.Execute();
Assert.Equal(Complex.Asin(complex), result);
Assert.Equal(0.96465850440760248, result.Real, 15);
Assert.Equal(1.9686379257930975, result.Imaginary, 15);
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>
/// The result of analysis.
/// </returns>
public override IExpression Analyze(Arcsin exp)
{
if (!Helpers.HasVariable(exp, Variable))
{
return(new Number(0));
}
var involution = new Pow(exp.Argument.Clone(), new Number(2));
var sub = new Sub(new Number(1), involution);
var sqrt = new Sqrt(sub);
var division = new Div(exp.Argument.Clone().Analyze(this), sqrt);
return(division);
}
public void ReproductArcSin(Series plotn, Series teor, Series niz, Series verh)
{
double a = Math.Sqrt(2 * (InitialMoment(2) - Expectation * Expectation));
double Da = Math.Pow(a, 4) / (8 * d.Length);
if (Reproducting != null)
{
Reproducting(this,
new ReproductEventArgs(
new Param("а", a, Math.Sqrt(Da), _kvantil)
));
}
IReproductable Distr = new Arcsin(a, Da);
VisualizeDistribution(Distr, plotn, teor, niz, verh);
}
public void ExceptionLessThanZeroTest(double firstArgument)
{
var calculator = new Arcsin();
Assert.Throws <Exception>(() => calculator.Calculate(firstArgument));
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>The result of analysis.</returns>
public string Analyze(Arcsin exp)
{
return(ToString(exp, "arcsin({0})"));
}
/// <summary>
/// Creates an expression object from <see cref="FunctionToken"/>.
/// </summary>
/// <param name="token">The function token.</param>
/// <returns>An expression.</returns>
protected virtual IExpression CreateFunction(FunctionToken token)
{
IExpression exp;
switch (token.Function)
{
case Functions.Add:
exp = new Add(); break;
case Functions.Sub:
exp = new Sub(); break;
case Functions.Mul:
exp = new Mul(); break;
case Functions.Div:
exp = new Div(); break;
case Functions.Pow:
exp = new Pow(); break;
case Functions.Absolute:
exp = new Abs(); break;
case Functions.Sine:
exp = new Sin(); break;
case Functions.Cosine:
exp = new Cos(); break;
case Functions.Tangent:
exp = new Tan(); break;
case Functions.Cotangent:
exp = new Cot(); break;
case Functions.Secant:
exp = new Sec(); break;
case Functions.Cosecant:
exp = new Csc(); break;
case Functions.Arcsine:
exp = new Arcsin(); break;
case Functions.Arccosine:
exp = new Arccos(); break;
case Functions.Arctangent:
exp = new Arctan(); break;
case Functions.Arccotangent:
exp = new Arccot(); break;
case Functions.Arcsecant:
exp = new Arcsec(); break;
case Functions.Arccosecant:
exp = new Arccsc(); break;
case Functions.Sqrt:
exp = new Sqrt(); break;
case Functions.Root:
exp = new Root(); break;
case Functions.Ln:
exp = new Ln(); break;
case Functions.Lg:
exp = new Lg(); break;
case Functions.Lb:
exp = new Lb(); break;
case Functions.Log:
exp = new Log(); break;
case Functions.Sineh:
exp = new Sinh(); break;
case Functions.Cosineh:
exp = new Cosh(); break;
case Functions.Tangenth:
exp = new Tanh(); break;
case Functions.Cotangenth:
exp = new Coth(); break;
case Functions.Secanth:
exp = new Sech(); break;
case Functions.Cosecanth:
exp = new Csch(); break;
case Functions.Arsineh:
exp = new Arsinh(); break;
case Functions.Arcosineh:
exp = new Arcosh(); break;
case Functions.Artangenth:
exp = new Artanh(); break;
case Functions.Arcotangenth:
exp = new Arcoth(); break;
case Functions.Arsecanth:
exp = new Arsech(); break;
case Functions.Arcosecanth:
exp = new Arcsch(); break;
case Functions.Exp:
exp = new Exp(); break;
case Functions.GCD:
exp = new GCD(); break;
case Functions.LCM:
exp = new LCM(); break;
case Functions.Factorial:
exp = new Fact(); break;
case Functions.Sum:
exp = new Sum(); break;
case Functions.Product:
exp = new Product(); break;
case Functions.Round:
exp = new Round(); break;
case Functions.Floor:
exp = new Floor(); break;
case Functions.Ceil:
exp = new Ceil(); break;
case Functions.Derivative:
exp = new Derivative(); break;
case Functions.Simplify:
exp = new Simplify(); break;
case Functions.Del:
exp = new Del(); break;
case Functions.Define:
exp = new Define(); break;
case Functions.Vector:
exp = new Vector(); break;
case Functions.Matrix:
exp = new Matrix(); break;
case Functions.Transpose:
exp = new Transpose(); break;
case Functions.Determinant:
exp = new Determinant(); break;
case Functions.Inverse:
exp = new Inverse(); break;
case Functions.If:
exp = new If(); break;
case Functions.For:
exp = new For(); break;
case Functions.While:
exp = new While(); break;
case Functions.Undefine:
exp = new Undefine(); break;
case Functions.Im:
exp = new Im(); break;
case Functions.Re:
exp = new Re(); break;
case Functions.Phase:
exp = new Phase(); break;
case Functions.Conjugate:
exp = new Conjugate(); break;
case Functions.Reciprocal:
exp = new Reciprocal(); break;
case Functions.Min:
exp = new Min(); break;
case Functions.Max:
exp = new Max(); break;
case Functions.Avg:
exp = new Avg(); break;
case Functions.Count:
exp = new Count(); break;
case Functions.Var:
exp = new Var(); break;
case Functions.Varp:
exp = new Varp(); break;
case Functions.Stdev:
exp = new Stdev(); break;
case Functions.Stdevp:
exp = new Stdevp(); break;
default:
exp = null; break;
}
if (exp is DifferentParametersExpression diff)
{
diff.ParametersCount = token.CountOfParams;
}
return(exp);
}
public void NegativeArcsinTest()
{
var calculator = new Arcsin();
Assert.Throws <Exception>(() => calculator.calculate(2));
}
public void CalculateTestExeptionTest()
{
IOneArgumentCalculator calculator = new Arcsin();
Assert.Throws <Exception>(() => calculator.Calculate(3));
}
public void ArcsinToStringTest()
{
var exp = new Arcsin(new Number(5));
Assert.Equal("arcsin(5)", exp.ToString(commoonFormatter));
}
/// <summary>
/// Analyzes the specified expression.
/// </summary>
/// <param name="exp">The expression.</param>
/// <returns>
/// The result of analysis.
/// </returns>
/// <exception cref="System.NotSupportedException">Always.</exception>
public virtual TResult Analyze(Arcsin exp)
{
throw new NotSupportedException();
}
public void CalculateDegreeTest()
{
var exp = new Arcsin(new Number(1));
Assert.Equal(Math.Asin(1) / Math.PI * 180, exp.Execute(AngleMeasurement.Degree));
}
public void CalculateGradianTest()
{
var exp = new Arcsin(new Number(1));
Assert.Equal(Math.Asin(1) / Math.PI * 200, exp.Execute(AngleMeasurement.Gradian));
}
private static void arcsin_cdf_test()
//****************************************************************************80
//
// Purpose:
//
// ARCSIN_CDF_TEST tests ARCSIN_CDF, ARCSIN_CDF_INV, ARCSIN_PDF.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 26 August 2006
//
// Author:
//
// John Burkardt
//
{
int i;
int seed = 123456789;
Console.WriteLine("");
Console.WriteLine("ARCSIN_CDF_TEST");
Console.WriteLine(" ARCSIN_CDF evaluates the Arcsin CDF;");
Console.WriteLine(" ARCSIN_CDF_INV inverts the Arcsin CDF.");
Console.WriteLine(" ARCSIN_PDF evaluates the Arcsin PDF;");
double a = 1.0E+00;
Console.WriteLine("");
Console.WriteLine(" PDF parameter A = " + a + "");
if (!Arcsin.arcsin_check(a))
{
Console.WriteLine("");
Console.WriteLine("TEST006 - Fatal error!");
Console.WriteLine(" The parameters are not legal.");
return;
}
Console.WriteLine("");
Console.WriteLine(" X PDF CDF CDF_INV");
Console.WriteLine("");
for (i = 1; i <= 10; i++)
{
double x = Arcsin.arcsin_sample(a, ref seed);
double pdf = Arcsin.arcsin_pdf(x, a);
double cdf = Arcsin.arcsin_cdf(x, a);
double x2 = Arcsin.arcsin_cdf_inv(cdf, a);
Console.WriteLine(" "
+ x.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ pdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ cdf.ToString(CultureInfo.InvariantCulture).PadLeft(12) + " "
+ x2.ToString(CultureInfo.InvariantCulture).PadLeft(12) + "");
}
}
public void WrongAnswer()
{
var calculator = new Arcsin();
Assert.Throws <Exception>(code: () => calculator.CalculateTwo(45));
}
public void Exception()
{
var calculator = new Arcsin();
Assert.Throws <Exception>(() => calculator.OneCalculate(-10));
}
public void ExecuteTestException()
{
var exp = new Arcsin(new Bool(false));
Assert.Throws <ResultIsNotSupportedException>(() => exp.Execute());
}
public void ArcTestsNegative()
{
var calculator = new Arcsin();
var result = calculator.Calculate(-6);
}
private static void arcsin_sample_test()
//****************************************************************************80
//
// Purpose:
//
// ARCSIN_SAMPLE_TEST tests ARCSIN_MEAN, ARCSIN_SAMPLE, ARCSIN_VARIANCE.
//
// Licensing:
//
// This code is distributed under the GNU LGPL license.
//
// Modified:
//
// 26 August 2006
//
// Author:
//
// John Burkardt
//
{
const int SAMPLE_NUM = 1000;
double a = 0;
int i;
int seed = 123456789;
double[] x = new double[SAMPLE_NUM];
Console.WriteLine("");
Console.WriteLine("ARCSIN_SAMPLE_TEST");
Console.WriteLine(" ARCSIN_MEAN computes the Arcsin mean;");
Console.WriteLine(" ARCSIN_SAMPLE samples the Arcsin distribution;");
Console.WriteLine(" ARCSIN_VARIANCE computes the Arcsin variance.");
for (i = 1; i <= 2; i++)
{
a = i switch
{
1 => 1.0E+00,
2 => 16.0E+00,
_ => a
};
Console.WriteLine("");
Console.WriteLine(" PDF parameter A = " + a + "");
if (!Arcsin.arcsin_check(a))
{
Console.WriteLine("");
Console.WriteLine("ARCSIN_SAMPLE_TEST - Fatal error!");
Console.WriteLine(" The parameters are not legal.");
return;
}
double mean = Arcsin.arcsin_mean(a);
double variance = Arcsin.arcsin_variance(a);
Console.WriteLine(" PDF mean = " + mean + "");
Console.WriteLine(" PDF variance = " + variance + "");
int j;
for (j = 0; j < SAMPLE_NUM; j++)
{
x[j] = Arcsin.arcsin_sample(a, ref seed);
}
mean = typeMethods.r8vec_mean(j, x);
variance = typeMethods.r8vec_variance(j, x);
double xmax = typeMethods.r8vec_max(j, x);
double xmin = typeMethods.r8vec_min(j, x);
Console.WriteLine("");
Console.WriteLine(" Sample size = " + SAMPLE_NUM + "");
Console.WriteLine(" Sample mean = " + mean + "");
Console.WriteLine(" Sample variance = " + variance + "");
Console.WriteLine(" Sample maximum = " + xmax + "");
Console.WriteLine(" Sample minimum = " + xmin + "");
}
}
}
