public void AllMethodsTest() { double epsilon = Math.Pow(10, -10); int maxIterations = 10000; GaussSeidel gaussSeidel = new GaussSeidel(_generatorTotalCases, _generatorMatrix, _generatorVector, maxIterations, epsilon); PartialGauss sparsePartialGauss = new PartialGauss(_generatorTotalCases, _generatorMatrix, _generatorVector, true); PartialGauss partialGauss = new PartialGauss(_generatorTotalCases, _generatorMatrix, _generatorVector, false); SparseLUSolver sparseLUSolver = new SparseLUSolver(_generatorTotalCases, _generatorMatrix, _generatorVector); OwnSparseSolver ownSparseSolver = new OwnSparseSolver(_ownSparseGenerator.GenerateOwnSparseMatrix(), _generatorVector, maxIterations, epsilon); }
static void Main(string[] args) { GaussSeidel solver = new GaussSeidel(1.0); double[] M = new double[9]; M[0] = 12.0; M[1] = 3.0; M[2] = -5.0; M[3] = 1.0; M[4] = 5.0; M[5] = 3.0; M[6] = 3.0; M[7] = 7.0; M[8] = 13.0; double[] B = new double[3]; B[0] = 1.0; B[1] = 28.0; B[2] = 76.0; double[] startX = new double[3]; startX[0] = 1.0; startX[0] = 0.0; startX[0] = 1.0; LinearProblemProperties linearProblemProperties = new LinearProblemProperties( M, B, startX, 3); double[] X = new double[3]; NonLinearConjugateGradient nonLinearConjugateGradient = new NonLinearConjugateGradient(3); double[] X1 = nonLinearConjugateGradient.Solve(linearProblemProperties); for (int i= 0;i<4;i++) X = solver.Solve(linearProblemProperties); double[] out0 = nonLinearConjugateGradient.CalculateError(linearProblemProperties.M, linearProblemProperties.B, X1); double[] out1 = nonLinearConjugateGradient.CalculateError(linearProblemProperties.M, linearProblemProperties.B, X); Console.ReadLine(); }
private void button1_Click(object sender, EventArgs e) { if (Operaciones.Text != "") { Operaciones.Clear(); Operaciones.Focus(); } GSeidel = new GaussSeidel(); int cantidadElementos = int.Parse(textBox1.Text); GSeidel.cantidadElementos = int.Parse(textBox1.Text); cantidadElementos = GSeidel.cantidadElementos; int pointx = 70; int pointy = 70; panel2.Controls.Clear(); for (int j = 0; j < int.Parse(textBox1.Text); j++) { for (int i = 0; i < int.Parse(textBox1.Text); i++) { TextBox text = new TextBox(); string nombre = "txt" + j + i; text.Name = nombre; text.BackColor = Color.PaleVioletRed; text.Location = new Point(pointx, pointy); text.Size = new Size(40, 40); panel2.Controls.Add(text); pointy += 40; } pointx += 70; pointy = 70; } /* for (int u = 0; u < cantidadElementos; u++) * { * TextBox text = new TextBox(); * string nombre = "txt" + u; * text.Name = nombre; * text.BackColor = Color.Violet; * text.Location = new Point(pointx, pointy); * text.Size = new Size(40, 40); * panel2.Controls.Add(text); * pointy += 40; * }*/ }
static void Main(string[] args) { GaussSeidel solver = new GaussSeidel(1.0); double[] M = new double[9]; M[0] = 12.0; M[1] = 3.0; M[2] = -5.0; M[3] = 1.0; M[4] = 5.0; M[5] = 3.0; M[6] = 3.0; M[7] = 7.0; M[8] = 13.0; double[] B = new double[3]; B[0] = 1.0; B[1] = 28.0; B[2] = 76.0; double[] startX = new double[3]; startX[0] = 1.0; startX[0] = 0.0; startX[0] = 1.0; LinearProblemProperties linearProblemProperties = new LinearProblemProperties( M, B, startX, 3); double[] X = new double[3]; NonLinearConjugateGradient nonLinearConjugateGradient = new NonLinearConjugateGradient(3); double[] X1 = nonLinearConjugateGradient.Solve(linearProblemProperties); for (int i = 0; i < 4; i++) { X = solver.Solve(linearProblemProperties); } double[] out0 = nonLinearConjugateGradient.CalculateError(linearProblemProperties.M, linearProblemProperties.B, X1); double[] out1 = nonLinearConjugateGradient.CalculateError(linearProblemProperties.M, linearProblemProperties.B, X); Console.ReadLine(); }
public void GaussSeidelSparseTest() { int maxIterations = 100; double epsilon = Math.Pow(10, -10); Generator generator = new Generator(30); Generator ownSparseGenerator = new Generator(30, true); GaussSeidel gaussSeidel = new GaussSeidel(generator.TotalCases, generator.OriginalMatrix, generator.OriginalVector, maxIterations, epsilon); OwnSparseSolver ownSparseSolver = new OwnSparseSolver(ownSparseGenerator.GenerateOwnSparseMatrix(), generator.OriginalVector, maxIterations, epsilon); Assert.AreEqual(gaussSeidel.GaussSeidelSolution.Length, ownSparseSolver.OwnSparseMatrixSolution.Length); for (int i = 0; i < gaussSeidel.GaussSeidelSolution.Length; i++) { if (gaussSeidel.GaussSeidelSolution[i] != ownSparseSolver.OwnSparseMatrixSolution[i]) { Assert.Fail(); } } }
private void btnSeidel_Click(object sender, EventArgs e) { txtEcuaciones.Clear(); GaussSeidel mt = new GaussSeidel(dgvEcuaciones.RowCount, dgvEcuaciones.ColumnCount); float[,] matIn = llenarArray(); for (int i = 0; i < dgvEcuaciones.RowCount; i++) { for (int j = 0; j < dgvEcuaciones.ColumnCount; j++) { mt.SetValue(i, j, matIn[i, j]); } } mt.Cambio += new EventHandler <MatrizEventArgs>(mt_Cambio); mt.Completo += new EventHandler <MatrizEventArgs>(mt_Completo); mt.ApplyMethod(); }
public MainWindowViewModel() { logger = new Logger(); logger.Write += Logger_Write; Settings.Load(); run = new RelayCommand(x => { IMethod method = null; var a = Matrix.FromArray(A); var b = Vector.FromArray(B); switch (methodIndex) { case 0: method = new Cholesky(); break; case 1: method = new GaussSeidel(); break; case 2: method = new successive_overrelaxation(); break; case 3: method = new LUmet(); break; default: logger.NewMsg("Такого методу немає"); break; } if (method != null) { method.Log = logger; X = method.Run(a, b).ToArray(); } }); random = new RelayCommand(x => { A = Matrix.GetRandomMatrix(Size).ToArray(); var randB = new double[1, Size]; var r = new Random(); for (int i = 0; i < Size; ++i) { randB[0, i] = r.Next(-1000, 1000); } B = randB; }); close = new RelayCommand(x => { App.Current.Shutdown(); }); clearLog = new RelayCommand(x => { Log = ""; }); openSettings = new RelayCommand(x => { var form = new SettingsWindow(); form.Show(); }); }
public void FormGaussSeidel_Load(object sender, EventArgs e) { GaussSeidel newgaus = new GaussSeidel(); label4.Visible = false; }
public void TimesTest() { /** EXCHANGE SEPARATOR FOR CSV **/ System.Globalization.CultureInfo customCulture = (System.Globalization.CultureInfo)System.Threading.Thread.CurrentThread.CurrentCulture.Clone(); customCulture.NumberFormat.NumberDecimalSeparator = "."; System.Threading.Thread.CurrentThread.CurrentCulture = customCulture; /** CONFIGURATION **/ int totalAgents = 60; int startAgents = 5; int loopJump = 5; int loopCounter = 0; int maxIterations; double epsilon = Math.Pow(10, -10); Generator generator; Generator ownSparseGenerator; maxIterations = 1000; double[] agents = new double[totalAgents / startAgents]; double[] cases = new double[totalAgents / startAgents]; /** TIMES LISTS **/ List <double> partialGaussTimes = new List <double>(); List <double> sparsePartialGaussTimes = new List <double>(); List <double> gaussSeidelTimes = new List <double>(); List <double> sparseLUTimes = new List <double>(); List <double> ownSparseTimes = new List <double>(); /** X AND F(X) FOR APPROXIMATION **/ Approximation approximation = new Approximation(); double[] arguments = new double[totalAgents - startAgents + 1]; double[] partialGaussValues = new double[totalAgents - startAgents + 1]; double[] sparsePartialGaussValues = new double[totalAgents - startAgents + 1]; double[] gaussSeidelValues = new double[totalAgents - startAgents + 1]; double[] sparseLUValues = new double[totalAgents - startAgents + 1]; double[] ownSparseValues = new double[totalAgents - startAgents + 1]; /** COUNTING TIMES **/ using (var w = new StreamWriter("times.csv")) { var newLine = "Total Agents, Total Cases, Generate Equation, SparseLU, Gauss-Seidel, Sparse Partial Gauss, Partial Gauss, Own Sparse"; w.WriteLine(newLine); w.Flush(); loopCounter = 0; for (int i = startAgents; i <= totalAgents; i += loopJump) { partialGaussTimes.Clear(); sparsePartialGaussTimes.Clear(); gaussSeidelTimes.Clear(); sparseLUTimes.Clear(); ownSparseTimes.Clear(); generator = new Generator(i); ownSparseGenerator = new Generator(i, true); for (int j = 0; j < 100; j++) { GaussSeidel gaussSeidel = new GaussSeidel(generator.TotalCases, generator.OriginalMatrix, generator.OriginalVector, maxIterations, epsilon); PartialGauss partialGauss = new PartialGauss(generator.TotalCases, generator.OriginalMatrix, generator.OriginalVector, false); PartialGauss sparsePartialGauss = new PartialGauss(generator.TotalCases, generator.OriginalMatrix, generator.OriginalVector, true); SparseLUSolver sparseLUSolver = new SparseLUSolver(generator.TotalCases, generator.OriginalMatrix, generator.OriginalVector); OwnSparseSolver ownSparseSolver = new OwnSparseSolver(ownSparseGenerator.GenerateOwnSparseMatrix(), generator.OriginalVector, maxIterations, epsilon); partialGaussTimes.Add(partialGauss.GaussPartialTiming); sparsePartialGaussTimes.Add(sparsePartialGauss.SparseGaussPartialTiming); gaussSeidelTimes.Add(gaussSeidel.GaussSeidelTiming); sparseLUTimes.Add(sparseLUSolver.SparseLUTiming); ownSparseTimes.Add(ownSparseSolver.OwnSparseMatrixTiming); } partialGaussTimes.Sort(); sparsePartialGaussTimes.Sort(); gaussSeidelTimes.Sort(); sparseLUTimes.Sort(); ownSparseTimes.Sort(); partialGaussTimes.Remove(partialGaussTimes.FirstOrDefault()); partialGaussTimes.Remove(partialGaussTimes.LastOrDefault()); sparsePartialGaussTimes.Remove(sparsePartialGaussTimes.FirstOrDefault()); sparsePartialGaussTimes.Remove(sparsePartialGaussTimes.LastOrDefault()); gaussSeidelTimes.Remove(gaussSeidelTimes.FirstOrDefault()); gaussSeidelTimes.Remove(gaussSeidelTimes.LastOrDefault()); sparseLUTimes.Remove(sparseLUTimes.FirstOrDefault()); sparseLUTimes.Remove(sparseLUTimes.LastOrDefault()); ownSparseTimes.Remove(ownSparseTimes.FirstOrDefault()); ownSparseTimes.Remove(ownSparseTimes.LastOrDefault()); newLine = $"{i},{generator.TotalCases},{generator.GenerateEquationTiming},{sparseLUTimes.Average()},{gaussSeidelTimes.Average()},{sparsePartialGaussTimes.Average()}, {partialGaussTimes.Average()}, {ownSparseTimes.Average()}"; w.WriteLine(newLine); w.Flush(); arguments[loopCounter] = generator.TotalCases; partialGaussValues[loopCounter] = partialGaussTimes.Average(); sparsePartialGaussValues[loopCounter] = sparsePartialGaussTimes.Average(); gaussSeidelValues[loopCounter] = gaussSeidelTimes.Average(); sparseLUValues[loopCounter] = sparseLUTimes.Average(); ownSparseValues[loopCounter] = ownSparseTimes.Average(); agents[loopCounter] = generator.TotalAgents; cases[loopCounter] = generator.TotalCases; loopCounter++; } } /** APPROXIMATION **/ var partialGaussApproximationTest = approximation.GetApproximation(3, arguments, partialGaussValues); var sparsePartialGaussApproximationTest = approximation.GetApproximation(2, arguments, sparsePartialGaussValues); var gaussSeidelApproximationTest = approximation.GetApproximation(2, arguments, gaussSeidelValues); var sparseLUApproximationTest = approximation.getLinearRegression(arguments, sparseLUValues); var ownSparseApproximationTest = approximation.GetApproximation(2, arguments, ownSparseValues); /** toString **/ using (var s = new StreamWriter("strings.txt")) { s.WriteLine("PARTIAL GAUSS " + partialGaussApproximationTest.GetString()); s.WriteLine("SPARSE PARTIAL GAUUS " + sparsePartialGaussApproximationTest.GetString()); s.WriteLine("GAUSS SEIDEL " + gaussSeidelApproximationTest.GetString()); s.WriteLine("SPARSE LU " + sparseLUApproximationTest.GetString()); s.WriteLine("OWN SPARSE " + ownSparseApproximationTest.GetString()); s.Flush(); } /** toValue **/ using (var v = new StreamWriter("approximation.csv")) { var line = "Total Agents, Total Cases, SparseLU, Gauss-Seidel, Sparse Partial Gauss, Partial Gauss, Own Sparse"; v.WriteLine(line); v.Flush(); for (int i = 0; i < (totalAgents / startAgents); i++) { line = $"{agents[i]}, {cases[i]}, {sparseLUApproximationTest.GetResult(cases[i])}, {gaussSeidelApproximationTest.GetResult(cases[i])}, {sparsePartialGaussApproximationTest.GetResult(cases[i])}, {partialGaussApproximationTest.GetResult(cases[i])}, {ownSparseApproximationTest.GetResult(cases[i])}"; v.WriteLine(line); v.Flush(); } } /** ERRORS **/ double partialGaussError = 0; double sparsePartialGaussError = 0; double gaussSeidelError = 0; double sparseLUError = 0; double ownSparseError = 0; for (int i = 0; i < (totalAgents / startAgents); i++) { partialGaussError += Math.Sqrt(Math.Pow(partialGaussValues[i] - partialGaussApproximationTest.GetResult(cases[i]), 2)); sparsePartialGaussError += Math.Sqrt(Math.Pow(sparsePartialGaussValues[i] - sparsePartialGaussApproximationTest.GetResult(cases[i]), 2)); gaussSeidelError += Math.Sqrt(Math.Pow(gaussSeidelValues[i] - gaussSeidelApproximationTest.GetResult(cases[i]), 2)); sparseLUError += Math.Sqrt(Math.Pow(sparseLUValues[i] - sparseLUApproximationTest.GetResult(cases[i]), 2)); ownSparseError += Math.Sqrt(Math.Pow(ownSparseValues[i] - ownSparseApproximationTest.GetResult(cases[i]), 2)); } using (var e = new StreamWriter("errors.txt")) { e.WriteLine("PARTIAL GAUSS ERROR " + partialGaussError); e.WriteLine("SPARSE PARTIAL GAUSS ERROR " + sparsePartialGaussError); e.WriteLine("GAUSS SEIDEL ERROR " + gaussSeidelError); e.WriteLine("SPARSE LU ERROR " + sparseLUError); e.WriteLine("OWN SPARSE ERROR " + ownSparseError); e.Flush(); } /** COUNTING TIME FOR 100K */ using (var w = new StreamWriter("100k.txt")) { w.WriteLine("PARTIAL GAUSS 100k " + partialGaussApproximationTest.GetResult(100000) / Math.Pow(10, 6) + " SEKUND"); w.WriteLine("SPARSE PARTIAL 100k " + sparsePartialGaussApproximationTest.GetResult(100000) / Math.Pow(10, 6) + " SEKUND"); w.WriteLine("GAUSS SEIDEL 100k " + gaussSeidelApproximationTest.GetResult(100000) / Math.Pow(10, 6) + " SEKUND"); w.WriteLine("SPARSE LU 100k " + sparseLUApproximationTest.GetResult(100000) + " MIKROSEKUND"); w.WriteLine("OWN SPARSE 100k " + ownSparseApproximationTest.GetResult(100000) / Math.Pow(10, 6) + " SEKUND"); w.Flush(); } }
static void Main(string[] args) { var sw = new Stopwatch(); var a = new Matrix(3); a[0, 0] = 25; a[0, 1] = 15; a[0, 2] = -5; a[1, 0] = 15; a[1, 1] = 18; a[1, 2] = 0; a[2, 0] = -5; a[2, 1] = 0; a[2, 2] = 11; var x = new Vector(3); x[0] = 1; x[1] = 1; x[2] = 1; var b = a * x; IMethod method = null; Console.WriteLine("*** Performance Test ***"); Console.WriteLine("*** Successive Overrelaxation ***"); method = new successive_overrelaxation(); method.Run(a, b); var listRes = new List <TimeSpan>(); for (int i = 0; i < 1000; i++) { sw.Start(); var res = method.Run(a, b); sw.Stop(); listRes.Add(sw.Elapsed); Console.WriteLine($"{sw.Elapsed.TotalMilliseconds} ms"); sw.Reset(); } Console.WriteLine($"Average - {listRes.Average(y => y.TotalMilliseconds)} ms"); Console.WriteLine("*** LU ***"); method = new LUmet(); listRes = new List <TimeSpan>(); for (int i = 0; i < 1000; i++) { sw.Start(); var res = method.Run(a, b); sw.Stop(); listRes.Add(sw.Elapsed); Console.WriteLine($"{sw.Elapsed.TotalMilliseconds} ms"); sw.Reset(); } Console.WriteLine($"Average - {listRes.Average(y => y.TotalMilliseconds)} ms"); Console.WriteLine("*** Gauss - Seidel ***"); method = new GaussSeidel(); listRes = new List <TimeSpan>(); for (int i = 0; i < 1000; i++) { sw.Start(); var res = method.Run(a, b); sw.Stop(); listRes.Add(sw.Elapsed); Console.WriteLine($"{sw.Elapsed.TotalMilliseconds} ms"); sw.Reset(); } Console.WriteLine($"Average - {listRes.Average(y => y.TotalMilliseconds)} ms"); Console.WriteLine("*** Cholesky ***"); method = new Cholesky(); listRes = new List <TimeSpan>(); for (int i = 0; i < 1000; i++) { sw.Start(); var res = method.Run(a, b); sw.Stop(); listRes.Add(sw.Elapsed); Console.WriteLine($"{sw.Elapsed.TotalMilliseconds} ms"); sw.Reset(); } Console.WriteLine($"Average - {listRes.Average(y => y.TotalMilliseconds)} ms"); Console.ReadLine(); }
public static void monogrid_poisson_1d(int n, double a, double b, double ua, double ub, Func <double, double> force, Func <double, double> exact, ref int it_num, ref double[] u) //****************************************************************************80 // // Purpose: // // MONOGRID_POISSON_1D solves a 1D PDE, using the Gauss-Seidel method. // // Discussion: // // This routine solves a 1D boundary value problem of the form // // - U''(X) = F(X) for A < X < B, // // with boundary conditions U(A) = UA, U(B) = UB. // // The Gauss-Seidel method is used. // // This routine is provided primarily for comparison with the // multigrid solver. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 26 July 2014 // // Author: // // John Burkardt // // Reference: // // William Hager, // Applied Numerical Linear Algebra, // Prentice-Hall, 1988, // ISBN13: 978-0130412942, // LC: QA184.H33. // // Parameters: // // Input, int N, the number of intervals. // // Input, double A, B, the endpoints. // // Input, double UA, UB, the boundary values at the endpoints. // // Input, double FORCE ( double x ), the name of the function // which evaluates the right hand side. // // Input, double EXACT ( double x ), the name of the function // which evaluates the exact solution. // // Output, int &IT_NUM, the number of iterations. // // Output, double U[N+1], the computed solution. // { double d1 = 0; int i; // // Initialization. // const double tol = 0.0001; // // Set the nodes. // double[] x = typeMethods.r8vec_linspace_new(n + 1, a, b); // // Set the right hand side. // double[] r = new double[n + 1]; r[0] = ua; double h = (b - a) / n; for (i = 1; i < n; i++) { r[i] = h * h * force(x[i]); } r[n] = ub; for (i = 0; i <= n; i++) { u[i] = 0.0; } it_num = 0; // // Gauss-Seidel iteration. // for (;;) { it_num += 1; GaussSeidel.gauss_seidel(n + 1, r, ref u, ref d1); if (d1 <= tol) { break; } } }
public static void multigrid_poisson_1d(int n, double a, double b, double ua, double ub, Func <double, double> force, Func <double, double> exact, ref int it_num, ref double[] u) //****************************************************************************80 // // Purpose: // // MULTIGRID_POISSON_1D solves a 1D PDE using the multigrid method. // // Discussion: // // This routine solves a 1D boundary value problem of the form // // - U''(X) = F(X) for A < X < B, // // with boundary conditions U(A) = UA, U(B) = UB. // // The multigrid method is used. // // Licensing: // // This code is distributed under the GNU LGPL license. // // Modified: // // 26 July 2014 // // Author: // // Original FORTRAN77 version by William Hager. // C++ version by John Burkardt. // // Reference: // // William Hager, // Applied Numerical Linear Algebra, // Prentice-Hall, 1988, // ISBN13: 978-0130412942, // LC: QA184.H33. // // Parameters: // // Input, int N, the number of intervals. // N must be a power of 2. // // Input, double A, B, the endpoints. // // Input, double UA, UB, the boundary values at the endpoints. // // Input, double FORCE ( double x ), the name of the function // which evaluates the right hand side. // // Input, double EXACT ( double x ), the name of the function // which evaluates the exact solution. // // Output, int &IT_NUM, the number of iterations. // // Output, double U[N+1], the computed solution. // { int i; // // Determine if we have enough storage. // int k = (int)Math.Log2(n); if (Math.Abs(n - Math.Pow(2, k)) > double.Epsilon) { Console.WriteLine(""); Console.WriteLine("MULTIGRID_POISSON_1D - Fatal error!"); Console.WriteLine(" N is not a power of 2."); return; } int nl = n + n + k - 2; // // Initialization. // const int it = 4; it_num = 0; const double tol = 0.0001; const double utol = 0.7; int m = n; // // Set the nodes. // double[] x = typeMethods.r8vec_linspace_new(n + 1, a, b); // // Set the right hand side. // double[] r = new double[nl]; r[0] = ua; double h = (b - a) / n; for (i = 1; i < n; i++) { r[i] = h * h * force(x[i]); } r[n] = ub; double[] uu = new double[nl]; for (i = 0; i < nl; i++) { uu[i] = 0.0; } // // L points to first entry of solution // LL points to penultimate entry. // int l = 0; int ll = n - 1; // // Gauss-Seidel iteration // double d1 = 0.0; int j = 0; for (;;) { double d0 = d1; j += 1; GaussSeidel.gauss_seidel(n + 1, r, ref uu, ref d1, rIndex: +l, uIndex: +l); it_num += 1; // // Do at least 4 iterations at each level. // if (j < it) { } // // Enough iterations, satisfactory decrease, on finest grid, exit. // else if (d1 < tol && n == m) { break; } // // Enough iterations, satisfactory convergence, go finer. // else if (d1 < tol) { Transfer.ctof(n + 1, uu, n + n + 1, ref uu, ucIndex: +l, ufIndex: +(l - 1 - n - n)); n += n; ll = l - 2; l = l - 1 - n; j = 0; } // // Enough iterations, slow convergence, 2 < N, go coarser. // else if (utol * d0 <= d1 && 2 < n) { Transfer.ftoc(n + 1, uu, r, n / 2 + 1, ref uu, ref r, ufIndex: +l, rfIndex: +l, ucIndex: +(l + n + 1), rcIndex: +(l + n + 1)); n /= 2; l = ll + 2; ll = ll + n + 1; j = 0; } } for (i = 0; i < n + 1; i++) { u[i] = uu[i]; } }