public MainWindowViewModel()
{
_trapeziumMethod = new TrapeziumMethod();
_simpsonMethod = new SimpsonMethod();
_rectangleMethod = new MediumRectangleMethod();
ClearFixedTableCommand = new LambdaCommand(OnClearFixedTableCommandExecuted, CanClearFixedTableCommandExecute);
ClearAutoTableCommand = new LambdaCommand(OnClearAutoTableCommandExecuted, CanClearAutoTableCommandExecute);
CalculateFixedTableCommand = new LambdaCommand(OnCalculateFixedTableCommandExecuted, CanCalculateFixedTableCommandExecute);
CalculateAutoStepTableCommand = new LambdaCommand(OnCalculateAutoStepTableCommandExecuted, CanCalculateAutoStepTableCommandExecute);
}
public override object GetProbabilityLessThan(object a)
{
if (!IsFloat(a))
{
throw new ArgumentException(ERROR_ARGUMENT_FLOAT);
}
float za = GetZValue(Convert.ToSingle(a));
SimpsonMethod sm = new SimpsonMethod(-3.6, za, 30000, zFunction);
return((float)((1 / Math.Sqrt(2 * Math.PI)) * sm.GetResult()));
}
public override object GetProbabilityGreaterThan(object a)
{
if (!IsDouble(a))
{
throw new ArgumentException(ERROR_ARGUMENT_DOUBLE);
}
double za = GetZValue(Convert.ToDouble(a));
SimpsonMethod sm = new SimpsonMethod(za, 3.6, 30000, zFunction);
return((1 / Math.Sqrt(2 * Math.PI)) * sm.GetResult());
}
public override object GetProbabilityGreaterThan(object a)
{
if (!IsDecimal(a))
{
throw new ArgumentException(ERROR_ARGUMENT_DECIMAL);
}
decimal za = GetZValue((decimal)a);
SimpsonMethod sm = new SimpsonMethod((double)za, 3.6, 30000, zFunction);
return((decimal)((1 / Math.Sqrt(2 * Math.PI)) * sm.GetResult()));
}
public override object GetProbabilityBetween(object a, object b)
{
if (!IsDecimal(a) || !IsDecimal(b))
{
throw new ArgumentException(ERROR_ARGUMENT_DECIMAL);
}
decimal za = GetZValue((decimal)a);
decimal zb = GetZValue((decimal)b);
SimpsonMethod sm = new SimpsonMethod((double)za, (double)zb, 30000, zFunction);
return((decimal)((1 / Math.Sqrt(2 * Math.PI)) * sm.GetResult()));
}
private void button1_Click(object sender, EventArgs e)
{
richTextBox1.Text = "";
Parser parserComp = new Parser();
//при помощи компонента-парсера преобразуем входные данные
//в формат, используемый другими компонентами:
//считаем пределы интегрирования и погрешность
double a = 0, b = 0, eps = 0;
if (!parserComp.ParseParam(ref a, ref b, ref eps, textBox2.Text, textBox3.Text, textBox4.Text))
{
richTextBox1.Text += "Ошибка ввода параметров";
return;
}
parserComp.Dispose();
//преобразуем строку в очередь токенов в обратной польской нотации
//для компонента, вычисляющего значения формулы при подстановке
FormulaExecutor formulaComp = new FormulaExecutor(parserComp.ShuntingYard(textBox1.Text));
if (formulaComp.formula == null)
{
richTextBox1.Text += "Ошибка ввода выражения";
return;
}
//при помощи компонентов методов численного интегрирования вычислим значение опред. интеграла
Container methodComponents = new Container();
if (checkBox1.Checked)
{
RectangleMethod rectangleComp = new RectangleMethod();
methodComponents.Add(rectangleComp);
richTextBox1.Text += (rectangleComp.Integration(formulaComp, a, b, eps).ToString()
+ " (метод левых прямоугольников)\n");
}
if (checkBox2.Checked)
{
TrapezoidalMethod trapezoidComp = new TrapezoidalMethod();
methodComponents.Add(trapezoidComp);
richTextBox1.Text += (trapezoidComp.Integration(formulaComp, a, b, eps).ToString()
+ " (метод трапеций)\n");
}
if (checkBox3.Checked)
{
SimpsonMethod simpsonComp = new SimpsonMethod();
methodComponents.Add(simpsonComp);
richTextBox1.Text += (simpsonComp.Integration(formulaComp, a, b, eps).ToString()
+ " (метод Симпсона)\n");
}
methodComponents.Dispose();
formulaComp.Dispose();
}
public virtual object GetTwoMeansEqualTesting(MeanSample sample1, MeanSample sample2, out object lessThan, out object greaterThan)
{
double z = (sample1.mean - sample2.mean) - (sample1.meanPopulation - sample2.meanPopulation) / Math.Sqrt(Math.Pow(sample1.sigmaPopulation, 2) / Convert.ToDouble(sample1.sampleQuantity) + Math.Pow(sample2.sigmaPopulation, 2) / Convert.ToDouble(sample2.sampleQuantity));
SimpsonMethod sm1 = new SimpsonMethod(-3.6, z, 30000, zFunction);
lessThan = (1 / Math.Sqrt(2 * Math.PI)) * sm1.GetResult();
SimpsonMethod sm2 = new SimpsonMethod(z, 3.6, 30000, zFunction);
greaterThan = (1 / Math.Sqrt(2 * Math.PI)) * sm2.GetResult();
return(z);
}
public virtual object GetTwoPercentageTesting(BinominalSample sample1, BinominalSample sample2, out object lessThan, out object greaterThan)
{
double totalP = Convert.ToDouble(sample1.nFeature + sample2.nFeature) / Convert.ToDouble(sample1.nTotal + sample2.nTotal);
double z = (sample1.testingP - sample2.testingP) / Math.Sqrt(totalP * (1 - totalP) * (1 / Convert.ToDouble(sample1.nTotal) + 1 / Convert.ToDouble(sample2.nTotal)));
SimpsonMethod sm1 = new SimpsonMethod(-3.6, z, 30000, zFunction);
lessThan = (1 / Math.Sqrt(2 * Math.PI)) * sm1.GetResult();
SimpsonMethod sm2 = new SimpsonMethod(z, 3.6, 30000, zFunction);
greaterThan = (1 / Math.Sqrt(2 * Math.PI)) * sm2.GetResult();
return(z);
}
decimal FindZ(decimal baseValue)
{
double initialValue = -3.60;
while (initialValue < 3.61)
{
SimpsonMethod sm = new SimpsonMethod(-3.6, initialValue, 30000, zFunction);
double checkValue = (1 / Math.Sqrt(2 * Math.PI)) * sm.GetResult();
if ((double)baseValue - checkValue < 0.0005)
{
return((decimal)Math.Round(initialValue, 2));
}
initialValue += 0.01;
}
return((decimal)Math.Round(initialValue, 2));
}
float FindZ(float baseValue)
{
float initialValue = -3.60F;
while (initialValue < 3.61F)
{
SimpsonMethod sm = new SimpsonMethod(-3.6, initialValue, 30000, zFunction);
double checkValue = (1 / Math.Sqrt(2 * Math.PI)) * sm.GetResult();
if (baseValue - checkValue < 0.0005F)
{
return(initialValue);
}
initialValue += 0.01F;
}
return(initialValue);
}
double FindZ(double baseValue)
{
double initialValue = -3.60;
while (initialValue < 3.61)
{
SimpsonMethod sm = new SimpsonMethod(-3.6, initialValue, 30000, zFunction);
double checkValue = (1 / Math.Sqrt(2 * Math.PI)) * sm.GetResult();
if (baseValue - checkValue < 0.00025)
{
return(initialValue);
}
initialValue += 0.01;
}
return(initialValue);
}
public override object GetHypothesisTestingForPercentage(object p0, out object lessThan, out object greaterThan)
{
if (!IsDouble(p0))
{
throw new ArgumentException(ERROR_ARGUMENT_DOUBLE);
}
double z = ((double)p0 - p) / Math.Sqrt(p * (1 - p) / n);
SimpsonMethod sm1 = new SimpsonMethod(-3.6, z, 30000, zFunction);
lessThan = (1 / Math.Sqrt(2 * Math.PI)) * sm1.GetResult();
SimpsonMethod sm2 = new SimpsonMethod(z, 3.6, 30000, zFunction);
greaterThan = (1 / Math.Sqrt(2 * Math.PI)) * sm2.GetResult();
return(z);
}
public override object GetHypothesisTestingForPercentage(object p0, out object lessThan, out object greaterThan)
{
if (!IsDecimal(p0))
{
throw new ArgumentException(ERROR_ARGUMENT_DECIMAL);
}
decimal z = ((decimal)p0 - p) / Convert.ToDecimal(Math.Sqrt(Convert.ToDouble(p * (1 - p) / n)));
SimpsonMethod sm1 = new SimpsonMethod(-3.6, Convert.ToDouble(z), 30000, zFunction);
lessThan = (1 / Math.Sqrt(2 * Math.PI)) * sm1.GetResult();
SimpsonMethod sm2 = new SimpsonMethod(Convert.ToDouble(z), 3.6, 30000, zFunction);
greaterThan = (1 / Math.Sqrt(2 * Math.PI)) * sm2.GetResult();
return(z);
}
public override object GetHypothesisTestingForMean(object m, object sigma, out double lessThan, out double greaterThan)
{
if (!IsDouble(m) || !IsDouble(sigma))
{
throw new ArgumentException(ERROR_ARGUMENT_DOUBLE);
}
double z = (mean - (double)m) / ((double)sigma / Math.Sqrt(dataArray.Length));
SimpsonMethod sm1 = new SimpsonMethod(-3.6, z, 30000, zFunction);
lessThan = (1 / Math.Sqrt(2 * Math.PI)) * sm1.GetResult();
SimpsonMethod sm2 = new SimpsonMethod(z, 3.6, 30000, zFunction);
greaterThan = (1 / Math.Sqrt(2 * Math.PI)) * sm2.GetResult();
return(z);
}
static void Main(string[] args)
{
// Définition de l'équation différentielle à tester
Func <double, double, double> equation = (x, y) => - 2 * y * x;
bool isIterationDetailsAsked = true;
IFirstOrderDifferentialEquation equationToSolve = new FirstOrderEulerMethod(equation);
// Test de la méthode d'Euler
Console.WriteLine("Test méthode Euler :");
equationToSolve.SetStartingPoint(0, 1);
equationToSolve.SetComputeStep(0.1);
double?result = equationToSolve.ComputeForGivenX(1.8, isIterationDetailsAsked);
if (result.HasValue)
{
Console.WriteLine("Résultat du calcul : " + result);
if (isIterationDetailsAsked)
{
string details = equationToSolve.BuildFormatedComputationDetailsForDisplay();
if (details != null)
{
Console.WriteLine(details);
}
}
}
else
{
Console.WriteLine("Calcul impossible");
}
// Test de la méthode de Cauchy
Console.WriteLine("Test méthode Cauchy :");
equationToSolve = new FirstOrderCauchyMethod(equation);
equationToSolve.SetStartingPoint(0, 1);
equationToSolve.SetComputeStep(0.1);
result = equationToSolve.ComputeForGivenX(1.8, isIterationDetailsAsked);
if (result.HasValue)
{
Console.WriteLine("Résultat du calcul : " + result);
if (isIterationDetailsAsked)
{
string details = equationToSolve.BuildFormatedComputationDetailsForDisplay();
if (details != null)
{
Console.WriteLine(details);
}
}
}
else
{
Console.WriteLine("Calcul impossible");
}
// Test de la méthode de Heun
Console.WriteLine("Test méthode Heun :");
equationToSolve = new FirstOrderHeunMethod(equation);
equationToSolve.SetStartingPoint(0, 1);
equationToSolve.SetComputeStep(0.1);
result = equationToSolve.ComputeForGivenX(1.8, isIterationDetailsAsked);
if (result.HasValue)
{
Console.WriteLine("Résultat du calcul : " + result);
if (isIterationDetailsAsked)
{
string details = equationToSolve.BuildFormatedComputationDetailsForDisplay();
if (details != null)
{
Console.WriteLine(details);
}
}
}
else
{
Console.WriteLine("Calcul impossible");
}
// Test de la méthode Runge-Kutta au 4ème ordre
Console.WriteLine("Test méthode Runge-Kutta au 4ème ordre :");
equationToSolve = new FirstOrderRungeKuttaMethod(equation);
equationToSolve.SetStartingPoint(0, 1);
equationToSolve.SetComputeStep(0.1);
result = equationToSolve.ComputeForGivenX(1.8, isIterationDetailsAsked);
if (result.HasValue)
{
Console.WriteLine("Résultat du calcul : " + result);
if (isIterationDetailsAsked)
{
string details = equationToSolve.BuildFormatedComputationDetailsForDisplay();
if (details != null)
{
Console.WriteLine(details);
}
}
}
else
{
Console.WriteLine("Calcul impossible");
}
// Définition de l'équation différentielle à tester
Func <double, double, double, double>[] equations = new Func <double, double, double, double>[]
{
(x, y, z) => - 2 * z,
(x, y, z) => y - Math.Sin(x) * Math.Sin(x)
};
isIterationDetailsAsked = true;
ISecondOrderDifferentialEquation equations2Solve = new SecondOrderEulerMethod(equations);
// Test de la méthode de Euler 2ème ordre
Console.WriteLine("Test méthode Euler 2ème ordre :");
equations2Solve.SetStartingPoints(new double[3] {
0, 1, 0
});
equations2Solve.SetComputeStep(0.05);
double[] results = equations2Solve.ComputeForGivenX(0.5, isIterationDetailsAsked);
if (results != null && results.Length > 0)
{
Console.WriteLine($"Résultat du calcul : y = {results[1]}, z = {results[2]}");
if (isIterationDetailsAsked)
{
string details = equations2Solve.BuildFormatedComputationDetailsForDisplay();
if (details != null)
{
Console.WriteLine(details);
}
}
}
else
{
Console.WriteLine("Calcul impossible");
}
// Test de la méthode de Cauchy 2ème ordre
Console.WriteLine("Test méthode Cauchy 2ème ordre :");
equations2Solve = new SecondOrderCauchyMethod(equations);
equations2Solve.SetStartingPoints(new double[3] {
0, 1, 0
});
equations2Solve.SetComputeStep(0.05);
results = equations2Solve.ComputeForGivenX(0.5, isIterationDetailsAsked);
if (results != null && results.Length > 0)
{
Console.WriteLine($"Résultat du calcul : y = {results[1]}, z = {results[2]}");
if (isIterationDetailsAsked)
{
string details = equations2Solve.BuildFormatedComputationDetailsForDisplay();
if (details != null)
{
Console.WriteLine(details);
}
}
}
else
{
Console.WriteLine("Calcul impossible");
}
// Test de la méthode de Heun 2ème ordre
Console.WriteLine("Test méthode Heun 2ème ordre :");
equations2Solve = new SecondOrderHeunMethod(equations);
equations2Solve.SetStartingPoints(new double[3] {
0, 1, 0
});
equations2Solve.SetComputeStep(0.05);
results = equations2Solve.ComputeForGivenX(0.5, isIterationDetailsAsked);
if (results != null && results.Length > 0)
{
Console.WriteLine($"Résultat du calcul : y = {results[1]}, z = {results[2]}");
if (isIterationDetailsAsked)
{
string details = equations2Solve.BuildFormatedComputationDetailsForDisplay();
if (details != null)
{
Console.WriteLine(details);
}
}
}
else
{
Console.WriteLine("Calcul impossible");
}
// Test de la méthode de Runge-Kutta au 4ème ordre
Console.WriteLine("Test méthode Runge-Kutta au 4ème ordre :");
equations2Solve = new SecondOrderRungeKuttaMethod(equations);
equations2Solve.SetStartingPoints(new double[3] {
0, 1, 0
});
equations2Solve.SetComputeStep(0.05);
results = equations2Solve.ComputeForGivenX(0.5, isIterationDetailsAsked);
if (results != null && results.Length > 0)
{
Console.WriteLine($"Résultat du calcul : y = {results[1]}, z = {results[2]}");
if (isIterationDetailsAsked)
{
string details = equations2Solve.BuildFormatedComputationDetailsForDisplay();
if (details != null)
{
Console.WriteLine(details);
}
}
}
else
{
Console.WriteLine("Calcul impossible");
}
// Calcul du zéro d'une fonction
Func <double, double> equationToComputeZero = (x) => Math.Exp(x) - 6 * x;
Func <double, double> derivedEquationToComputeZero = (x) => Math.Exp(x) - 6;
NewtonRaphsonMethod zeroFinder = new NewtonRaphsonMethod(equationToComputeZero, derivedEquationToComputeZero);
double?zero = zeroFinder.ComputeForZero(3, true);
if (zero.HasValue)
{
Console.WriteLine($"Zéro trouvé : {zero.Value} en {zeroFinder.IterationNumberReached} iterations");
Console.WriteLine(zeroFinder.BuildFormatedComputationDetailsForDisplay());
}
else
{
Console.WriteLine("Calcul impossible");
}
// Calcul d'une intégrale
Func <double, double> equationToInteger = (x) => Math.Exp(-x) + 2 * x;
SimpsonMethod integral = new SimpsonMethod(equationToInteger);
integral.SetIterationNumber(100);
double?computedIntegral = integral.ComputeIntegral(2, 6);
if (computedIntegral.HasValue)
{
Console.WriteLine($"Intégrale : {computedIntegral.Value}");
}
else
{
Console.WriteLine("Calcul impossible");
}
// Calcul d'une comète
Comet comet = new Comet(0.5, 0.95, 1.0, 0.03);
var tailResult = comet.ComputeSyndynams(-114.5916);
Console.ReadKey();
}
/// <summary>
/// Computes the forward transformation.
/// </summary>
/// <param name="coordinate">The coordinate.</param>
/// <returns>The transformed coordinate.</returns>
protected override Coordinate ComputeForward(GeoCoordinate coordinate)
{
// source: EPSG Guidance Note number 7, part 2, page 76
Double easting, northing;
if (_ellipsoid.IsSphere)
{
easting = _falseEasting + _ellipsoid.SemiMajorAxis.Value * (coordinate.Longitude.BaseValue - _longitudeOfNaturalOrigin) * Math.Cos(_latitudeOf1stStadardParallel);
northing = _falseNorthing + _ellipsoid.SemiMajorAxis.Value * coordinate.Latitude.BaseValue;
}
else
{
Double latitude = coordinate.Latitude.BaseValue;
Double m = _ellipsoid.SemiMajorAxis.Value * (1 - _ellipsoid.EccentricitySquare) * SimpsonMethod.Integrate(phi => Math.Pow(1 - _ellipsoid.EccentricitySquare * Calculator.Sin2(phi), -1.5), 0, latitude, 100);
easting = _falseEasting + _nu1 * Math.Cos(_latitudeOf1stStadardParallel) * (coordinate.Longitude.BaseValue - _longitudeOfNaturalOrigin);
northing = _falseNorthing + m;
}
return(new Coordinate(easting, northing));
}
float Beta(double x, double y)
{
SimpsonMethod sm = new SimpsonMethod(0, 1, 100000, x, y, BetaFunction);
return((float)sm.GetResultParameterizedMethod2Arguments());
}
double Beta(double a, double b, double x, double y)
{
SimpsonMethod sm = new SimpsonMethod(a, b, 100000, x, y, BetaFunction);
return(sm.GetResultParameterizedMethod2Arguments());
}
