Advertisement
Slavik9510

Untitled

Dec 4th, 2022
345
0
Never
Not a member of Pastebin yet? Sign Up, it unlocks many cool features!
C# 4.42 KB | None | 0 0
  1. using System;
  2. namespace NewtonMethod
  3. {
  4.     class Program
  5.     {
  6.         static double phi1DerivByX(double x, double y)
  7.         {
  8.             // return Math.Sin(x);
  9.             double top, bottom;
  10.             top = (2 - Math.Log(y)) * Math.Cos(x * y) * y;
  11.             bottom = Math.Pow(Math.Sin(x * y), 2);
  12.             return -top / bottom;
  13.         }
  14.         static double phi1DerivByY(double x, double y)
  15.         {
  16.             double top, bottom;
  17.             top = Math.Sin(x * y) + x * y * (-2 + Math.Log(y)) * Math.Cos(x * y);
  18.             bottom = y * Math.Pow(Math.Sin(x * y), 2);
  19.             return -top / bottom;
  20.         }
  21.         static double phi2DerivByX(double x, double y)
  22.         {
  23.             return -Math.Pow(Math.E, x - 3 * y) - x * Math.Pow(Math.E, x - 3 * y);
  24.         }
  25.         static double phi2DerivByY(double x, double y)
  26.         {
  27.             //return Math.Cos(y - 0.5) / 2;
  28.             return 3 * x * Math.Pow(Math.E, x - 3 * y) - 45.0 / (Math.Pow(Math.E, Math.E * y));
  29.         }
  30.         static double func1DerivByX(double x, double y)
  31.         {
  32.             //
  33.             return Math.Sin(x * y) + x * y * Math.Cos(x * y);
  34.         }
  35.         static double func1DerivByY(double x, double y)
  36.         {
  37.             //
  38.             return x * x * Math.Cos(x * y) - 1 / y;
  39.         }
  40.         static double func2DerivByX(double x, double y)
  41.         {
  42.             return Math.Pow(Math.E, x) + x * Math.Pow(Math.E, x);
  43.         }
  44.         static double func2DerivByY(double x, double y)
  45.         {
  46.             return Math.Pow(Math.E, 3*y) + 3 * y * Math.Pow(Math.E, 3*y);
  47.         }
  48.         static double func1(double x, double y)
  49.         {
  50.             // return Math.Cos(x) + y - 1.5;
  51.             return x * Math.Sin(x * y) - Math.Log(y) - 2;
  52.         }
  53.         static double func2(double x, double y)
  54.         {
  55.             //return 2 * x - Math.Sin(y - 0.5) - 1;
  56.             return x * Math.Pow(Math.E, x) + y * Math.Pow(Math.E, 3 * y) - 15;
  57.         }
  58.         static double jacobian(double x, double y)
  59.         {
  60.             double jacobian = 0;
  61.             jacobian += func1DerivByX(x, y) * func2DerivByY(x, y);
  62.             jacobian -= func2DerivByX(x, y) * func1DerivByY(x, y);
  63.  
  64.             return jacobian;
  65.         }
  66.         static double deltaX(double x, double y)
  67.         {
  68.             double deltaX = 0;
  69.             if (jacobian(x, y) != 0)
  70.             {
  71.                 deltaX += func1(x, y) * func2DerivByY(x, y);
  72.                 deltaX -= func2(x, y) * func1DerivByY(x, y);
  73.                 deltaX /= -jacobian(x, y);
  74.             }
  75.             else
  76.             {
  77.                 Console.WriteLine("Jacobian = 0. Delta x can not be calculated!");
  78.                 Environment.Exit(1);
  79.             }
  80.             return deltaX;
  81.         }
  82.         static double deltaY(double x, double y)
  83.         {
  84.             double deltaY = 0;
  85.             if (jacobian(x, y) != 0)
  86.             {
  87.                 deltaY += func2(x, y) * func1DerivByX(x, y);
  88.                 deltaY -= func1(x, y) * func2DerivByX(x, y);
  89.                 deltaY /= -jacobian(x, y);
  90.             }
  91.             else
  92.             {
  93.                 Console.WriteLine("Jacobian = 0. Delta y can not be calculated!");
  94.                 Environment.Exit(1);
  95.             }
  96.             return deltaY;
  97.         }
  98.         static void findRoots()
  99.         {
  100.             double Xn = 1.5;
  101.             double Yn = 0.5;
  102.  
  103.             double xDif = Math.Abs(phi1DerivByX(Xn, Yn)) + Math.Abs(phi2DerivByX(Xn, Yn));
  104.             double yDif = Math.Abs(phi1DerivByY(Xn, Yn)) + Math.Abs(phi2DerivByY(Xn, Yn));
  105.  
  106.             if (xDif < 1 && yDif < 1)
  107.             {
  108.                 Console.WriteLine("Процес не збіжний");
  109.             }
  110.  
  111.             double xPrev;
  112.             double yPrev;
  113.  
  114.             int iteration = 0;
  115.             do
  116.             {
  117.                 Console.WriteLine($"Iteration: {iteration:D2} X = {Xn:F4} Y = {Yn:F4}");
  118.                 xPrev = Xn;
  119.                 yPrev = Yn;
  120.  
  121.                 Xn = xPrev + deltaX(xPrev, yPrev);
  122.                 Yn = yPrev + deltaY(xPrev, yPrev);
  123.                 iteration++;
  124.             } while (Math.Abs(Xn - xPrev) + Math.Abs(Yn - yPrev) > 0.001);
  125.  
  126.             Console.WriteLine("\nКоренi:");
  127.             Console.WriteLine($"X = {Xn}");
  128.             Console.WriteLine($"Y = {Yn}");
  129.         }
  130.         static void Main(string[] args)
  131.         {
  132.             findRoots();
  133.         }
  134.     }
  135. }
Advertisement
Add Comment
Please, Sign In to add comment
Advertisement