public void GoldenSection_Maximum_In_0(double a, double b, double eps)
{
const double expectedValue = 0;
var goldenSection = new GoldenSection(MaximizationFunction);
var max = goldenSection.FindMax(a, b, eps);
Assert.True(Math.Abs(expectedValue - (max.LeftBound - max.RightBound) / 2) <= eps);
}
/// <summary>
/// Finds minimum of given function using the Gradient Descent algorithm.
/// </summary>
/// <param name="function">Function used in algorithm.</param>
/// <param name="e">Precision.</param>
/// <param name="startingPoint">Starting point of algorithm.</param>
/// <param name="usingGoldenSection">Flag used for tracking whether user wants to use Golden Section algorithm or not.</param>
/// <returns>Minimum of function.</returns>
public static Matrica FindMinimum(Function function, double e, Matrica startingPoint, bool usingGoldenSection)
{
Matrica x = new Matrica();
x.Equals(startingPoint);
function.SetParametersSize(x.NoOfRows);
Matrica v = new Matrica();
int brojac = 0;
Matrica xs = new Matrica();
if (usingGoldenSection == false)
{
do
{
xs.Equals(x);
v = function.CalculateGradientValue(x.VectorToArray());
function.IncreaseCounterGradientValue(algorithmName);
v.MultiplyByScalar(-1);
x.AddValue(v);
brojac++;
function.IncreaseCounterValue(algorithmName);
function.IncreaseCounterValue(algorithmName);
} while (brojac < 10000);
}
else
{
do
{
xs.Equals(x);
v = function.CalculateGradientValue(x.VectorToArray());
function.IncreaseCounterGradientValue(algorithmName);
v.MultiplyByScalar(-1);
v.MultiplyByScalar(1.0 / function.GetGradientNorm());
for (int i = 0; i < x.NoOfRows; i++)
{
double value = x.LoadedMatrix[i][0];
double vectorValue = v.LoadedMatrix[i][0];
Expression expression = lambda => value + lambda * vectorValue;
function.SetParameters(i, expression);
}
UnimodalInterval interval = UnimodalInterval.FindUnimodalInterval(function, 0, 1, algorithmName);
UnimodalInterval lambdaInterval = GoldenSection.FindMinimum(function, interval.Minimum, interval.Maximum, e, algorithmName);
double lambdaMin = (lambdaInterval.Minimum + lambdaInterval.Maximum) / 2;
v.MultiplyByScalar(lambdaMin);
x.AddValue(v);
function.IncreaseCounterValue(algorithmName);
function.IncreaseCounterValue(algorithmName);
} while (function.GetGradientNorm() >= e);
}
function.DeleteParameters();
return(x);
}
public bool Match(List <Vector2> positions, float threshold, float minimalScore, float minSize)
{
if (positions.Count < samplesCount)
{
return(false);
}
if (!positions.IsLargeEnough(minSize))
{
return(false);
}
List <Vector2> locals = GoldenSection.Pack(positions, samplesCount);
float score = GoldenSection.Search(locals, points, -MathHelper.PiOver4, MathHelper.PiOver4, threshold);
return(score > minimalScore);
}
static void Main(string[] args)
{
const double eps = 0.001;
Console.WriteLine("Установление первоначальных границ");
var boundFoundary = new UnconditionalOptimization(MaximizationFunction);
boundFoundary.OnIteration += BoundFoundary_OnIteration;
var(startLeftBound, startRightBound) = boundFoundary.GetBoundForMaximization(5, .5);
DisplayResult((startLeftBound, startRightBound), boundFoundary.Iterations, eps);
Console.WriteLine("Уточнение границ методом Золотого сечения");
var goldenSection = new GoldenSection(MaximizationFunction);
goldenSection.OnIteration += BoundFoundary_OnIteration;
var goldenSectionBounds = goldenSection.FindMax(startLeftBound, startRightBound, eps);
DisplayResult(goldenSectionBounds, goldenSection.Iterations, eps);
Console.WriteLine("Квадратичная апроксимация");
var quadraticApproximation = new QuadraticApproximation(MaximizationFunction);
quadraticApproximation.OnIteration += BoundFoundary_OnIteration;
var quadApproxBounds = quadraticApproximation.Calculate(startLeftBound, startRightBound, eps);
DisplayResult(quadApproxBounds, quadraticApproximation.Iterations, eps);
Console.WriteLine("Метод Ньютона");
var newtonsMethod = new NewtonsMethod(MaximizationFunctionDerivative1, MaximizationFunctionDerivative2);
var rootNewtoon = newtonsMethod.Newton(-9, eps);
Console.WriteLine($"Корень {rootNewtoon}");
Console.WriteLine();
Console.ReadLine();
}
public void CloseAndPrepare()
{
points = GoldenSection.Pack(points, samplesCount);
}
public void ExecuteMethod(
string nameMethod,
double param1,
double param2,
double param3,
double param4,
string testFunction,
int rangeArray,
double[] LinSysMasA,
double[,] LinSysMatrixB,
double[] massX,
double[] massF,
double[] massW,
double pointInterpolation,
double[,] MatrixAlgebraA,
double pointPercentile,
double pointGenerator)
{
TestFunction = testFunction;
switch (nameMethod)
{
//*** Approximate decision of equalization f(x)=0 ***
case "Bisection Method":
{
Bisection bisect = new Bisection(new FunctionOne(TestFunBisection), param1, param2, param3);
result = "\n Result of the program: \n" +
" x= " + string.Format("{0:f" + precision + "}", bisect.Result);
}
break;
case "Chord Method":
{
Сhord chord = new Сhord(new FunctionOne(TestFunNewton), new FunctionOne(TestFunNewton2), param1, param2, param3, param4);
result = "\n Result of the program: \n" +
" x= " + string.Format("{0:f" + precision + "}", chord.GetSolution());
}
break;
case "Iteration Method":
{
IterationMethod itermet = new IterationMethod(new FunctionOne(TestFunIteration), param1, param2, param3, param4);
result = "\n Result of the program: \n" +
" x= " + string.Format("{0:f" + precision + "}", itermet.GetSolution());
}
break;
case "Newton Method":
{
Newton newton = new Newton(new FunctionOne(TestFunNewton), new FunctionOne(TestFunNewton2), param1, param2, param3, param4);
result = "\n Result of the program: \n" +
" x= " + string.Format("{0:f" + precision + "}", newton.GetSolution());
}
break;
//*** Differential Equations ***
case "Euler Simple":
{
EulerSimple eulersimpl = new EulerSimple(new Function(TestFunDifferEquations), param1, param2, param3, Convert.ToInt32(param4));
var result_eulersimpl = eulersimpl.Result;
for (int j = 0; j < Convert.ToInt32(param4); j++)
{
result = result + string.Format("{0:f" + precision + "}", result_eulersimpl[0, j])
+ " : "
+ string.Format("{0:f" + precision + "}", result_eulersimpl[1, j]) + "\n";
}
}
break;
case "Euler Modified":
{
EulerModified eulerModif = new EulerModified(new Function(TestFunDifferEquations), param1, param2, param3, Convert.ToInt32(param4));
var result_eulerModif = eulerModif.Result;
for (int j = 0; j < Convert.ToInt32(param4); j++)
{
result = result + string.Format("{0:f" + precision + "}", result_eulerModif[0, j])
+ " : " + string.Format("{0:f" + precision + "}", result_eulerModif[1, j]) + "\n";
// result = result + "fun=\n";
// result = result +Convert.ToString( TestFunDifferEquations);
}
}
break;
case "Euler Corrected":
{
EulerCorrected eulerCorrect = new EulerCorrected(new Function(TestFunDifferEquations), param1, param2, param3, Convert.ToInt32(param4));
var result_eulerCorrect = eulerCorrect.Result;
for (int j = 0; j < Convert.ToInt32(param4); j++)
{
result = result + string.Format("{0:f" + precision + "}", result_eulerCorrect[0, j])
+ " : " + string.Format("{0:f" + precision + "}", result_eulerCorrect[1, j]) + "\n";
}
}
break;
case "Runge-Kutta4":
{
RungeKutta4 rungeKutta4 = new RungeKutta4(new Function(TestFunDifferEquations), param1, param2, param3, Convert.ToInt32(param4));
var result_rungeKutta4 = rungeKutta4.Result;
for (int j = 0; j < Convert.ToInt32(param4); j++)
{
result = result + string.Format("{0:f" + precision + "}", result_rungeKutta4[0, j])
+ " : " + string.Format("{0:f" + precision + "}", result_rungeKutta4[1, j]) + "\n";
}
}
break;
//*** Integration ***
case "Chebishev":
Chebishev chebish = new Chebishev(new FunctionOne(TestFunInteger), param1, param2, Convert.ToInt32(param3));
var result_chebish = chebish.GetSolution();
for (int j = 0; j <= Convert.ToInt32(param3); j++)
{
result = result + "\n h = " + string.Format("{0:f" + precision + "}", result_chebish[1, j]) + " \t integral = "
+ string.Format("{0:f" + precision + "}", result_chebish[0, j]);
}
break;
case "Simpson":
Simpson simps = new Simpson(new FunctionOne(TestFunInteger), param1, param2, Convert.ToInt32(param3));
var result_simps = simps.GetSolution();
for (int j = 0; j <= Convert.ToInt32(param3); j++)
{
result = result + "\n h = " + string.Format("{0:f" + precision + "}", result_simps[1, j]) +
" \t integral = " + string.Format("{0:f" + precision + "}", result_simps[0, j]);
}
break;
case "Simpson2":
Simpson2 simps2 = new Simpson2(new FunctionOne(TestFunInteger), param1, param2, Convert.ToInt32(param3));
var result_simps2 = simps2.GetSolution();
result = "\n\n integral = " + string.Format("{0:f" + precision + "}", result_simps2);
break;
case "Trapezium":
Trapezium trapez = new Trapezium(new FunctionOne(TestFunInteger), param1, param2, Convert.ToInt32(param3));
var result_trapez = trapez.GetSolution();
for (int j = 0; j <= Convert.ToInt32(param3); j++)
{
result = result + "\n h = " + string.Format("{0:f" + precision + "}", result_trapez[1, j])
+ " \t integral = " + string.Format("{0:f" + precision + "}", result_trapez[0, j]);
}
break;
//*** Non Linear equalization ***
case "Half Division":
HalfDivision halfdiv = new HalfDivision(new FunctionOne(TestFunNonLinearEquations), param1, param2, param3);
result = "\n X = " + string.Format("{0:f" + precision + "}", halfdiv.GetSolution()[0, 0])
+ " Iterations = " + string.Format("{0:f" + precision + "}", halfdiv.GetSolution()[1, 0]);
break;
case "Hord Metod":
HordMetod hormet = new HordMetod(new FunctionOne(TestFunNonLinearEquations), param1, param2, Convert.ToInt32(param3));
result = "\n X = " + string.Format("{0:f" + precision + "}", hormet.GetSolution()[0, 0])
+ " Iterations = " + string.Format("{0:f" + precision + "}", hormet.GetSolution()[1, 0]);
break;
case "Newton Metod":
NewtonMethod newt = new NewtonMethod(new FunctionOne(TestFunNonLinearEquations), param1, param2);
result = "\n X = " + string.Format("{0:f" + precision + "}", newt.GetSolution()[0, 0])
+ " Iterations = " + string.Format("{0:f" + precision + "}", newt.GetSolution()[1, 0]);
break;
case "Secant Metod":
Secant sec = new Secant(new FunctionOne(TestFunNonLinearEquations), param1, param2);
result = "\n X = " + string.Format("{0:f" + precision + "}", sec.GetSolution()[0, 0])
+ " Iterations = " + string.Format("{0:f" + precision + "}", sec.GetSolution()[1, 0]);
break;
default:
result = "";
break;
//*** Linear Systems ***
case "Gaus":
double[,] LinSysMatrix;
LinSysMatrix = new double[100, 100];
for (int l = 0; l < rangeArray; l++)
{
for (int j = 0; j < rangeArray; j++)
{
LinSysMatrix[l, j] = LinSysMatrixB[l, j];
}
LinSysMatrix[l, rangeArray] = LinSysMasA[l];
}
Gaus gaus = new Gaus(4, LinSysMatrix);
var result_gaus = gaus.GetSolution();
result = "";
for (int j = 0; j < result_gaus.Length; j++)
{
result = result + "\n X" + j + " = "
+ string.Format("{0:f" + precision + "}", result_gaus[j]) + ";";
}
break;
case "Zeidel":
Zeidel zeidel = new Zeidel(4, LinSysMatrixB, LinSysMasA);
var result_zeidel = zeidel.GetSolution();
result = "";
for (int j = 0; j < result_zeidel.Length; j++)
{
result = result + "\n X" + j + " = "
+ string.Format("{0:f" + precision + "}", result_zeidel[j]) + ";";
}
break;
//*** Interpolation ***
case "Lagrange Interpolator":
LagrangeInterpolator lagran = new LagrangeInterpolator(massX, massF, 6, pointInterpolation);
result = "\n A value interpolation polynomial is in the point of interpolation.";
result = result + "\n\n P = " + string.Format("{0:f" + precision + "}", lagran.GetSolution());
break;
case "Newton Interpolator":
NewtonInterpolator newinterpol = new NewtonInterpolator(massX, massF, 6, pointInterpolation);
result = "\n A value interpolation polynomial is in the point of interpolation.";
result = result + "\n\n P = " + string.Format("{0:f" + precision + "}", newinterpol.GetSolution());
break;
case "Neville Interpolator":
NevilleInterpolator newill = new NevilleInterpolator(massX, massF, 6, pointInterpolation);
result = "\n A value interpolation polynomial is in the point of interpolation.";
result = result + "\n\n P = " + string.Format("{0:f" + precision + "}", newill.GetSolution());
break;
case "Spline Interpolator":
SplineInterpolator spline = new SplineInterpolator(massX, massF, 6, pointInterpolation);
result = "\n A value interpolation polynomial is in the point of interpolation.";
result = result + "\n\n P = " + string.Format("{0:f" + precision + "}", spline.GetSolution());
break;
case "Barycentric Interpolator":
BarycentricInterpolation barycen = new BarycentricInterpolation(massX, massF, massW, 6, pointInterpolation);
result = "\n A value interpolation polynomial is in the point of interpolation.";
result = result + "\n\n P = " + string.Format("{0:f" + precision + "}", barycen.GetSolution());
break;
//*** Matrix Algebra ***
case "Matrix Determinant":
MatrixDeterminant matrdet = new MatrixDeterminant();
result = " \n\n\n Determinant = " + string.Format("{0:f" + precision + "}", matrdet.MatrixDet(MatrixAlgebraA, rangeArray)) + ";\n";
break;
case "RMatrix LU":
MatrixLU matrlu = new MatrixLU(MatrixAlgebraA, rangeArray, rangeArray);
var result_matrlu = matrlu.GetSolution();
var result_matrlu2 = matrlu.GetSolution2();
result = "A:\n";
for (int ii = 0; ii < rangeArray; ii++)
{
for (int j = 0; j < rangeArray; j++)
{
result = result + " \t " + string.Format("{0:f" + precision + "}", result_matrlu[ii, j]);
}
result = result + " \n";
}
result = result + "\nL:\n";
for (int ii = 0; ii < rangeArray; ii++)
{
result = result + " " + string.Format("{0:f" + precision + "}", result_matrlu2[ii]);
}
result = result + " \n ";
break;
case "Matrix Inverse LU":
RMatrixLuInverse matrluinv = new RMatrixLuInverse();
MatrixLU matrlu2 = new MatrixLU(MatrixAlgebraA, rangeArray, rangeArray);
if (matrluinv.rmatrixluinverse(MatrixAlgebraA, rangeArray, matrlu2.GetSolution2()) == true)
{
result = "\n An inverse matrix exists \n\n ";
var result_matrluinv = matrluinv.GetSolution();
for (int ii = 0; ii < rangeArray; ii++)
{
for (int j = 0; j < rangeArray; j++)
{
result = result + " \t" + string.Format("{0:f" + precision + "}", result_matrluinv[ii, j]);
}
result = result + "\n\n";
}
}
else
{
result = "\n An inverse matrix does not exist";
}
break;
//*** Optimizing***
case "Brentopt":
Brentopt brent = new Brentopt(new FunctionOne(TestFunOptimizing), param1, param2, param3);
result = "\n Point of the found minimum :";
result = result + "\n\n XMin = " + string.Format("{0:f" + precision + "}", brent.GetSolution());
result = result + "\n\n A value of function is in the found minimum :";
result = result + "\n\n F(XMin) = " + string.Format("{0:f" + precision + "}", brent.GetSolutionFunction());
break;
case "Golden Section":
GoldenSection godsection = new GoldenSection(new FunctionOne(TestFunOptimizing), param1, param2, Convert.ToInt32(param3));
result = "\n Scopes of segment which a decision of task is on .";
result = result + "\n\n a = " + string.Format("{0:f" + precision + "}", godsection.GetSolutionA());
result = result + "\n\n b = " + string.Format("{0:f" + precision + "}", godsection.GetSolutionB());
break;
case "Pijavsky":
Pijavsky pijavsky = new Pijavsky(new FunctionOne(TestFunOptimizing), param1, param2, param3, Convert.ToInt32(param4));
result = "\n Abscissa of the best point from found..";
result = result + "\n\n F = " + string.Format("{0:f" + precision + "}", pijavsky.GetSolution());
break;
//*** Statistics ***
case "Correlation Pearson":
CorrelationPearson corelperson = new CorrelationPearson(massX, massF, 6);
result = "\n Pearson product-moment correlation coefficient.";
result = result + "\n\n K = " + string.Format("{0:f" + precision + "}", corelperson.GetSolution());
break;
case "Correlation Spearmans Rank":
CorrelationSpearmansRank corelspear = new CorrelationSpearmansRank(massX, massF, 6);
result = "\n Pearson product-moment correlation coefficient.";
result = result + "\n\n K = " + string.Format("{0:f" + precision + "}", corelspear.GetSolution());
break;
case "Descriptive Statistics Median":
DescriptiveStatisticsADevMedian desceripM = new DescriptiveStatisticsADevMedian(massX, 6);
result = "\n Output parameters:";
result = result + "\n\n M = " + string.Format("{0:f" + precision + "}", desceripM.GetSolution());
break;
case "Descriptive Statistics Moments":
DescriptiveStatisticsMoments desceripMo = new DescriptiveStatisticsMoments(massX, 6);
result = "\n Output parameters:";
result = result + "\n\n M = " + string.Format("{0:f" + precision + "}", desceripMo.GetSolution());
result = result + "\n\n Variance = " + string.Format("{0:f" + precision + "}", desceripMo.variance);
result = result + "\n\n Skewness = " + string.Format("{0:f" + precision + "}", desceripMo.skewness) + " (if variance<>0; zero otherwise)";
result = result + "\n\n Kurtosis = " + string.Format("{0:f" + precision + "}", desceripMo.kurtosis) + " (if variance<>0; zero otherwise)";
break;
case "Descriptive Statistics Percentile":
DescriptiveStatisticsPercentile desceripP = new DescriptiveStatisticsPercentile(massX, 6, pointPercentile);
result = "\n Output parameters:";
result = result + "\n\n V = " + string.Format("{0:f" + precision + "}", desceripP.GetSolution());
break;
case "Generator 1":
RandomGeneratorsMethod1 random1 = new RandomGeneratorsMethod1();
result = "\n Output parameters:";
result = result + "\n\n Random = " + string.Format("{0:f" + precision + "}", random1.GetSolution());
break;
case "Generator 2":
RandomGeneratorsMethod2 random2 = new RandomGeneratorsMethod2(Convert.ToInt32(pointGenerator));
result = "\n Output parameters:";
result = result + "\n\n Random = " + string.Format("{0:f" + precision + "}", random2.GetSolution());
break;
case "Generator 3":
RandomGeneratorsMethod3 random3 = new RandomGeneratorsMethod3();
result = "\n Output parameters:";
result = result + "\n\n Random = " + string.Format("{0:f" + precision + "}", random3.GetSolution());
break;
case "Generator 4":
RandomGeneratorsMethod4 random4 = new RandomGeneratorsMethod4();
result = "\n Output parameters:";
result = result + "\n\n Random = " + string.Format("{0:f" + precision + "}", random4.GetSolution());
break;
case "Generator 5":
RandomGeneratorsMethod5 random5 = new RandomGeneratorsMethod5(pointGenerator);
result = "\n Output parameters:";
result = result + "\n\n Random = " + string.Format("{0:f" + precision + "}", random5.GetSolution());
break;
}
}
private static void Main()
{
Parameters.Verbosity = VerbosityLevels.AboveNormal;
// this next line is to set the Debug statements from OOOT to the Console.
Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
/* In this example, we first present how the details of an optimzation
* problem can be saved to an XML-file so that it can be read in
* and solved as opposed to defining all the details in an imperative
* (code line by code line) way. In the first function, the xml file
* name "test1.xml" is created. */
makeAndSaveProblemDefinition();
/* now we create a series of different optimization methods and test
* them on the problem. The problem is now opened from the file and
* the details are stored in an object of class "Problem Definition".*/
var stream = new FileStream(filename, FileMode.Open);
ProblemDefinition probTest1 = ProblemDefinition.OpenprobFromXml(stream);
abstractOptMethod opty;
/***********Gradient Based Optimization with Steepest Descent****************/
SearchIO.output("***********Gradient Based Optimization with Steepest Descent****************");
opty = new GradientBasedOptimization();
opty.Add(probTest1);
abstractSearchDirection searchDirMethod = new SteepestDescent();
opty.Add(searchDirMethod);
//abstractLineSearch lineSearchMethod = new ArithmeticMean(0.0001, 1, 100);
//abstractLineSearch lineSearchMethod = new DSCPowell(0.0001, 1, 100);
abstractLineSearch lineSearchMethod = new GoldenSection(0.0001, 1);
opty.Add(lineSearchMethod);
opty.Add(new squaredExteriorPenalty(opty, 10));
/* since this is not a population-based optimization method, we need to remove the MaxSpan criteria. */
opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence);
double[] xStar;
var timer = Stopwatch.StartNew();
var fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/***********Gradient Based Optimization with Fletcher-Reeves****************/
SearchIO.output("***********Gradient Based Optimization with Fletcher-Reeves****************");
/* we don't need to reset (invoke the constructor) for GradientBasedOptimization since we are only
* change the seaach direction method. */
searchDirMethod = new FletcherReevesDirection();
/* you could also try the remaining 3 search direction methods. */
//searchDirMethod = new CyclicCoordinates();
//searchDirMethod = new BFGSDirection();
//searchDirMethod = new PowellMethod(0.001, 6);
opty.Add(searchDirMethod);
timer = Stopwatch.StartNew();
opty.ResetFunctionEvaluationDatabase();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/******************Generalized Reduced Gradient***********************/
SearchIO.output("******************Generalized Reduced Gradient***********************");
opty = new GeneralizedReducedGradientActiveSet();
opty.Add(probTest1);
opty.Add(new squaredExteriorPenalty(opty, 10));
opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence);
timer = Stopwatch.StartNew();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/* GRG is the ONLY one here that handles constraints explicity. It find the
* optimal very quickly and accurately. However, many of the other show a
* better value of f*, this is because they are using an imperfect penalty
* function (new squaredExteriorPenalty(opty, 10)). While it seems that GRG
* includes it as well, it is only used in the the line search method. */
/******************Random Hill Climbing ***********************/
SearchIO.output("******************Random Hill Climbing ***********************");
opty = new HillClimbing();
opty.Add(probTest1);
opty.Add(new squaredExteriorPenalty(opty, 8));
opty.Add(new RandomNeighborGenerator(probTest1.SpaceDescriptor));
opty.Add(new KeepSingleBest(optimize.minimize));
opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence);
/* the deltaX convergence needs to be removed as well, since RHC will end many iterations
* at the same point it started. */
opty.ConvergenceMethods.RemoveAll(a => a is DeltaXConvergence);
timer = Stopwatch.StartNew();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/******************Exhaustive Hill Climbing ***********************/
SearchIO.output("******************Exhaustive Hill Climbing ***********************");
/* Everything else about the Random Hill Climbing stays the same. */
opty.Add(new ExhaustiveNeighborGenerator(probTest1.SpaceDescriptor));
timer = Stopwatch.StartNew();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/******************Simulated Annealing***********************/
SearchIO.output("******************Simulated Annealing***********************");
opty = new SimulatedAnnealing(optimize.minimize);
opty.Add(probTest1);
opty.Add(new squaredExteriorPenalty(opty, 10));
opty.Add(new RandomNeighborGenerator(probTest1.SpaceDescriptor, 100));
opty.Add(new SACoolingSangiovanniVincentelli(100));
opty.ConvergenceMethods.RemoveAll(a => a is MaxSpanInPopulationConvergence);
/* the deltaX convergence needs to be removed as well, since RHC will end many iterations
* at the same point it started. */
opty.ConvergenceMethods.RemoveAll(a => a is DeltaXConvergence);
timer = Stopwatch.StartNew();
fStar = opty.Run(out xStar);
printResults(opty, xStar, fStar, timer);
/******************Exhaustive Search ***********************/
// SearchIO.output("******************Exhaustive Search ***********************");
//opty = new ExhaustiveSearch(probTest1.SpaceDescriptor, optimize.minimize);
//opty.Add(probTest1);
/* No convergence criteria is needed as the process concludes when all
* states have been visited but for this problem that is 4 trillion states.*/
//opty.ConvergenceMethods.Clear();
/* if you DID KNOW the best, you can include a criteria like...*/
//opty.ConvergenceMethods.Add(new ToKnownBestXConvergence(new[] { 3.0, 3.0 }, 0.0000001));
//timer = Stopwatch.StartNew();
//fStar = opty.Run(out xStar);
/* you probably will never see this process complete. Even with the added
* convergence criteria (which is not factored into the estimated time of
* completion), you are probably looking at 1 to 2 years. */
//printResults(opty, xStar, fStar, timer);
}
/// <summary>
/// Finds minimum of function using Newton-Raphson algorithm.
/// </summary>
/// <param name="function">Function used in algorithm.</param>
/// <param name="e">Precision</param>
/// <param name="startingPoint">Starting point of algorithm.</param>
/// <param name="usingGoldenSection">Flag used for tracking whether user wants to use Golden Section algorithm or not.</param>
/// <returns>Minimum of function.</returns>
public static Matrica FindMinimum(Function function, double e, Matrica startingPoint, bool usingGoldenSection)
{
Matrica x = new Matrica();
x.Equals(startingPoint);
function.SetParametersSize(x.NoOfRows);
Matrica gradient = new Matrica();
Matrica hessianMatrix = new Matrica();
int brojac = 0;
Matrica xs = new Matrica();
if (usingGoldenSection == false)
{
do
{
xs.Equals(x);
gradient = function.CalculateGradientValue(x.VectorToArray());
function.IncreaseCounterGradientValue(algorithmName);
hessianMatrix = function.CalculateHessianMatrix(x.VectorToArray());
function.IncreaseCounterHessian(algorithmName);
Matrica LU = hessianMatrix.LUPDecomposition(e, gradient);
Matrica y = Matrica.ForwardSubstitution(LU, gradient);
Matrica deltaX = Matrica.BackwardSubstitution(LU, gradient, e);
x.AddValue(deltaX);
brojac++;
function.IncreaseCounterValue(algorithmName);
function.IncreaseCounterValue(algorithmName);
} while (brojac < 100);
}
else
{
do
{
xs.Equals(x);
gradient = function.CalculateGradientValue(x.VectorToArray());
function.IncreaseCounterGradientValue(algorithmName);
hessianMatrix = function.CalculateHessianMatrix(x.VectorToArray());
function.IncreaseCounterHessian(algorithmName);
Matrica LU = hessianMatrix.LUPDecomposition(e, gradient);
Matrica y = Matrica.ForwardSubstitution(LU, gradient);
Matrica deltaX = Matrica.BackwardSubstitution(LU, gradient, e);
x.AddValue(deltaX);
for (int i = 0; i < x.NoOfRows; i++)
{
double value = x.LoadedMatrix[i][0];
double vectorValue = deltaX.LoadedMatrix[i][0];
Expression expression = lambda => value + lambda * vectorValue;
function.SetParameters(i, expression);
}
UnimodalInterval interval = UnimodalInterval.FindUnimodalInterval(function, 0, 1, algorithmName);
UnimodalInterval lambdaInterval = GoldenSection.FindMinimum(function, interval.Minimum, interval.Maximum, e, algorithmName);
double lambdaMin = (lambdaInterval.Minimum + lambdaInterval.Maximum) / 2;
deltaX.MultiplyByScalar(lambdaMin);
x.AddValue(deltaX);
function.IncreaseCounterValue(algorithmName);
function.IncreaseCounterValue(algorithmName);
} while (function.GetGradientNorm() >= e);
}
function.DeleteParameters();
return(x);
}
