isotonicq

int2

Nov 23rd, 2016
205
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
  1. /*
  2. Metody Numeryczne zadanie INT1
  3. Przygotował: Dawid Grzeszuk
  4. Kierunek: Informatyka 3 semestr
  5. Środowisko: Visual Studio 2015
  6. Język programowania: C#
  7. */
  8.  
  9. using System;
  10. using System.Collections.Generic;
  11. using System.Data;
  12. using System.Linq;
  13. using System.Text;
  14. using System.Threading.Tasks;
  15.  
  16. namespace INT
  17. {
  18.     class UserMatrix
  19.     {
  20.         private readonly double?[,] _tab;
  21.         private readonly int _NrOfNodes;
  22.         private readonly int _columns;
  23.  
  24.         public UserMatrix()
  25.         {
  26.             Console.WriteLine("Podaj stopien wielomianu:");
  27.             _NrOfNodes = Convert.ToInt32(Console.ReadLine());
  28.             _columns = _NrOfNodes + 1;
  29.             _tab = new double?[_columns, 2];
  30.  
  31.             Console.Clear();
  32.         }
  33.  
  34.         public void FillTable()
  35.         {
  36.             for (int x = 0; x < _columns; x++)
  37.             {
  38.                 ShowTable();
  39.  
  40.                 for (int y = 0; y < 2; y++)
  41.                 {
  42.                     if (y == 0)
  43.                     {
  44.                         Console.WriteLine($"\nPodaj {x + 1} węzeł x: ");
  45.                         _tab[x, y] = Convert.ToDouble(Console.ReadLine());
  46.                     }
  47.                     else if (y == 1)
  48.                     {
  49.                         Console.WriteLine($"\nPodaj {x + 1} węzeł y: ");
  50.                         _tab[x, y] = Convert.ToDouble(Console.ReadLine());
  51.                     }
  52.                 }
  53.             }
  54.         }
  55.  
  56.         public void ShowTable()
  57.         {
  58.             Console.Clear();
  59.             Console.WriteLine("x y");
  60.             for (int x = 0; x < _columns; x++)
  61.             {
  62.                 for (int y = 0; y < 2; y++)
  63.                 {
  64.                     if (_tab[x, y] == null)
  65.                     {
  66.                         Console.Write("- ");
  67.  
  68.                     }
  69.                     else
  70.                     {
  71.                         Console.Write("{0} ", _tab[x, y]);
  72.                     }
  73.                 }
  74.                 Console.WriteLine();
  75.             }
  76.         }
  77.  
  78.         public int ReturnNodes() => _NrOfNodes;
  79.         public double?[,] ReturnMatrix() => _tab;
  80.     }
  81.  
  82.     class ProgramMatrix
  83.     {
  84.         private double[,] _programTable;
  85.         private double?[,] _userTable;
  86.         private int _nodes;
  87.         private double _max;
  88.         private int _equation;
  89.  
  90.         private double Equation(double x, int n)
  91.         {
  92.             if (n == 0)
  93.                 return 1;
  94.             else if (n == 1)
  95.                 return 2 * x;
  96.             else
  97.                 return (((2 * n - 3 * x) * Equation(x, n - 1)) - ((x + 5 * n) * Equation(x, n - 2)));
  98.         }
  99.  
  100.         public ProgramMatrix(int nodes, double?[,] matrix)
  101.         {
  102.             _programTable = new double[nodes + 1, nodes + 2];
  103.             _userTable = matrix;
  104.             _nodes = nodes;
  105.  
  106.             for (int x = 0; x < _nodes + 1; x++)
  107.             {
  108.                 _programTable[x, 0] = 1;
  109.                 _programTable[x, 1] = 2 * _userTable[x, 0].Value;
  110.                 _programTable[x, _nodes] = _userTable[x, 1].Value;
  111.             }
  112.  
  113.             for (int x = 0; x < _nodes + 1; x++)
  114.             {
  115.                 for (int y = 2; y < _nodes; y++)
  116.                 {
  117.                     _programTable[x, y] = Equation(_userTable[x, 0].Value, y);
  118.                 }
  119.             }
  120.         }
  121.  
  122.         public void MakeMath()
  123.         {
  124.             for (int column = 0; column < _nodes; column++)
  125.             {
  126.                 _max = _programTable[column, column];
  127.                 _equation = column;
  128.  
  129.                 for (int x = column; x < _nodes+1; x++)
  130.                 {
  131.                     if (Math.Abs(_programTable[x, column]) > Math.Abs(_max))
  132.                     {
  133.                         _max = _programTable[x, column];
  134.                         _equation = x;
  135.                     }
  136.                 }
  137.  
  138.                 if (Math.Abs(_max) < 1e-30)
  139.                 {
  140.                     throw new Exception();
  141.                 }
  142.  
  143.                 for (int x = column; x < _nodes + 2; x++)
  144.                 {
  145.                     SwapElements(column, x, _equation, x);
  146.                 }
  147.  
  148.                 for (int x = column; x < _nodes +2; x++)
  149.                 {
  150.                     _programTable[column, x] = _programTable[column, x] / _max;
  151.                 }
  152.  
  153.                 for (int x = 0; x < _nodes+1; x++)
  154.                 {
  155.                     if (x != column)
  156.                     {
  157.                         double z = _programTable[x, column];
  158.                         for (int y = column; y < _nodes + 1; y++)
  159.                         {
  160.                             _programTable[x, y] = _programTable[x, y] - z * _programTable[column, y];
  161.                         }
  162.                     }
  163.                 }
  164.             }
  165.         }
  166.  
  167.         public void SwapElements(int x1, int y1, int x2, int y2)
  168.         {
  169.             double temp = _programTable[x1, y1];
  170.             _programTable[x1, y1] = _programTable[x2, y2];
  171.             _programTable[x2, y2] = temp;
  172.         }
  173.  
  174.         public void ShowResult()
  175.         {
  176.             double x, p;
  177.             bool choice = true;
  178.  
  179.             while (choice)
  180.             {
  181.                 Console.WriteLine("\nPodaj x: ");
  182.                 x = Convert.ToDouble(Console.ReadLine());
  183.                 p = 0;
  184.  
  185.                 for (int y = 0; y < _nodes; y++)
  186.                 {
  187.                     p = p + _programTable[y, _nodes] * Equation(x, y);
  188.                 }
  189.  
  190.                 Console.WriteLine($"\nWynik to y={Math.Round(p,3)}");
  191.                 Console.WriteLine("Czy chcesz liczyć dalej? (t/n)");
  192.                 var option = Console.ReadLine();
  193.  
  194.                 if (option == "t")
  195.                 {
  196.                     choice = true;
  197.                 }
  198.                 else if (option == "n")
  199.                 {
  200.                     choice = false;
  201.                 }
  202.                 else
  203.                 {
  204.                     Console.Clear();
  205.                     Console.WriteLine("Nacisnij t lub n");
  206.                     Console.ReadKey();
  207.                     ShowResult();
  208.                 }
  209.  
  210.                 Console.Clear();
  211.             }
  212.         }
  213.  
  214.         public void ShowTable()
  215.         {
  216.             for (int x = 0; x < _nodes; x++)
  217.             {
  218.                 for (int y = 0; y < _nodes + 1; y++)
  219.                 {
  220.                     Console.Write($"{Math.Round(_programTable[x, y], 3)} ");
  221.                 }
  222.                 Console.WriteLine();
  223.             }
  224.         }
  225.     }
  226.  
  227.     class Program
  228.     {
  229.         static void Main(string[] args)
  230.         {
  231.             var user = new UserMatrix();
  232.             user.FillTable();
  233.             var program = new ProgramMatrix(user.ReturnNodes(), user.ReturnMatrix());
  234.             Console.Clear();
  235.             Console.WriteLine("Macierz przed obliczeniami: ");
  236.             program.ShowTable();
  237.             Console.WriteLine("\nMacierz po obliczeniach: ");
  238.             try
  239.             {
  240.                 program.MakeMath();
  241.                 program.ShowTable();
  242.                 Console.WriteLine("\nNacisnij dowolny klawisz aby kontynuować");
  243.                 Console.ReadLine();
  244.                 Console.Clear();
  245.                 try
  246.                 {
  247.                     program.ShowResult();
  248.                 }
  249.                 catch
  250.                 {
  251.                     program.ShowResult();
  252.                 }
  253.             }
  254.             catch
  255.             {
  256.                 Console.Clear();
  257.                 Console.WriteLine("Macierz Osobliwa");
  258.             }
  259.             finally
  260.             {
  261.                 Console.WriteLine("Program wykonał swój kod");
  262.             }
  263.         }
  264.     }
  265. }
RAW Paste Data