Комплексные числа, округление, ввод тригонометрической формы со строки - C#

Узнай цену своей работы

Формулировка задачи:

Не знаю, как округлить значения, к примеру до 2-3 символа. Еще не понимаю как сделать метод для преобразования строки в тригонометрическую форму. Помогите пожалуйста.
Листинг программы 
  1. using System;
  2. using System.Collections.Generic;
  3. using System.Linq;
  4. using System.Text;
  5. using System.Text.RegularExpressions;
  6. using System.Threading.Tasks;
  7.  
  8. namespace ConsoleApplication5
  9. {
  10.     class Program
  11.     {
  12.         class Complex
  13.         {
  14.             double re = 0, im;
  15.             double p, q;
  16.             //конструктор и его перегрузки
  17.             public Complex() 
  18.             {
  19.  
  20.             }
  21.             public Complex(double r) // конструктор для триг
  22.             {
  23.                 re = r;
  24.                 im = 0;
  25.             }
  26.             public Complex(double r, double i) // конструктор для алгебр
  27.             {
  28.                 re = r;
  29.                 im = i;
  30.             }
  31.             public Complex(double r, double i, string flag) 
  32.             {
  33.                 if (flag == "alg")
  34.                 {
  35.                     re = r;
  36.                     im = i;
  37.                 }
  38.                 if (flag == "trig")
  39.                 {
  40.                     p = r;
  41.                     q = i;
  42.                 }
  43.             }
  44.             
  45.             public static Complex AlgToTrig(Complex f)
  46.             {
  47.                 Complex f1 = new Complex();
  48.                 double ABS = f.abs();
  49.  
  50.                 double b = Math.Atan(f.im / f.re) + Math.PI;
  51.                 f1.p = ABS;
  52.                 f1.q = b;
  53.                
  54.                 return f1;
  55.             }
  56.             public static Complex TrigToAlg(Complex f)
  57.             {
  58.                 Complex f1 = new Complex();
  59.                 f1.re = f.p * Math.Cos(f.q) * -1;
  60.                 f1.im = f.p * Math.Sin(f.q) * -1;
  61.  
  62.                 return f1;
  63.             }
  64.  
  65.             //метод преобразования в строку
  66.             public string getComplexStrAlg() // в алг
  67.             {
  68.                 string gc;
  69.                 if (im >= 0)
  70.                 {
  71.                     gc = re + "+" + im + "i";
  72.                 }
  73.                 else
  74.                 {
  75.                     gc = re + "" + im + "i";
  76.                 }
  77.  
  78.                 return gc;
  79.             }
  80.             public string getComplexStrTrig()  // в триг
  81.             {
  82.                 string gc;
  83.  
  84.                 gc = String.Format("z={0:n3}(cos{1:n3}+sin{1:n3})", p, q);
  85.  
  86.                 return gc;
  87.             }
  88.  
  89.             #region перезагрузки арифметических операторов
  90.          
  91.             public static Complex operator +(Complex f1, Complex f2) // сложение
  92.             {
  93.                 if (f1.p != 0 && f2.p != 0)
  94.                 {
  95.                     Complex ff1 = Complex.TrigToAlg(f1);
  96.                     Complex ff2 = Complex.TrigToAlg(f2);
  97.                     Complex th = new Complex();
  98.                     th.re = ff1.re + ff2.re;
  99.                     th.im = ff1.im + ff2.im;
  100.                     return th;
  101.                 }
  102.                 else
  103.                 {
  104.                     Complex th = new Complex();
  105.                     th.re = f1.re + f2.re;
  106.                     th.im = f1.im + f2.im;
  107.                     return th;
  108.                 }
  109.             }
  110.             public static Complex operator -(Complex f1, Complex f2) //вычитание
  111.             {
  112.                 if (f1.p != 0 && f2.p != 0)
  113.                 {
  114.                     Complex ff1 = Complex.TrigToAlg(f1);
  115.                     Complex ff2 = Complex.TrigToAlg(f2);
  116.                     Complex th = new Complex();
  117.                     th.re = ff1.re - ff2.re;
  118.                     th.im = ff1.im - ff2.im;
  119.                     return th;
  120.                 }
  121.                 else
  122.                 {
  123.                     Complex th = new Complex();
  124.                     th.re = f1.re - f2.re;
  125.                     th.im = f1.im - f2.im;
  126.                     return th;
  127.                 }
  128.             }
  129.             public static Complex operator *(Complex f1, Complex f2)// умножение
  130.             {
  131.                 if (f1.p != 0 && f2.p != 0)
  132.                 {
  133.                     Complex ff1 = Complex.TrigToAlg(f1);
  134.                     Complex ff2 = Complex.TrigToAlg(f2);
  135.                     Complex th = new Complex();
  136.                     th.re = ff1.re * ff2.re - ff1.im * ff2.im;
  137.                     th.im = ff1.re * ff2.im + ff1.im * ff2.re;
  138.                     return th;
  139.                 }
  140.                 else
  141.                 {
  142.                     Complex th = new Complex();
  143.                     th.re = f1.re * f2.re - f1.im * f2.im;
  144.                     th.im = f1.re * f2.im + f1.im * f2.re;
  145.                     return th;
  146.  
  147.                 }
  148.             }
  149.             public static Complex operator /(Complex f1, Complex f2)// деление
  150.             {
  151.                 if (f1.p != 0 && f2.p != 0)
  152.                 {
  153.                     Complex ff1 = Complex.TrigToAlg(f1);
  154.                     Complex ff2 = Complex.TrigToAlg(f2);
  155.                     Complex th = new Complex();
  156.                     th.re =(ff1.re * ff2.re + ff1.im * ff2.im) / (Math.Pow(ff2.re, 2) + Math.Pow(ff2.im, 2));
  157.                     th.im = (ff2.re * ff1.im - ff1.re * ff2.im) / (Math.Pow(ff2.re, 2) + Math.Pow(ff2.im, 2));
  158.                     return th;
  159.                 }
  160.                 else
  161.                 {
  162.                     Complex th = new Complex();
  163.                     th.re = (f1.re * f2.re + f1.im * f2.im) / (Math.Pow(f2.re, 2) + Math.Pow(f2.im, 2));
  164.                     th.im = (f2.re * f1.im - f1.re * f2.im) / (Math.Pow(f2.re, 2) + Math.Pow(f2.im, 2));
  165.                     return th;
  166.                 }
  167.             }
  168.             #endregion
  169.             
  170.             public double abs()
  171.             {
  172.                 double r;
  173.                 r = Math.Sqrt(Math.Pow(re, 2) + Math.Pow(im, 2));
  174.                 return r;
  175.             }
  176.             #region перезагрузки операторов сравнения
  177.             
  178.             public static bool operator >(Complex f1, Complex f2)
  179.             {
  180.                 double r1, r2;
  181.                 if (f1.p != 0 && f2.p != 0)
  182.                 {
  183.                     Complex ff1 = Complex.TrigToAlg(f1);
  184.                     Complex ff2 = Complex.TrigToAlg(f2);
  185.                     r1 = ff1.abs();
  186.                     r2 = ff2.abs();
  187.                 }
  188.                 else
  189.                 {
  190.                     r1 = f1.abs();
  191.                     r2 = f2.abs();
  192.                 }
  193.                 if (r1 > r2)
  194.                 {
  195.                     return true;
  196.                 }
  197.                 else
  198.                 {
  199.                     return false;
  200.                 }
  201.             }
  202.             public static bool operator <(Complex f1, Complex f2)
  203.             {
  204.                 double r1, r2;
  205.                 if (f1.p != 0 && f2.p != 0)
  206.                 {
  207.                     Complex ff1 = Complex.TrigToAlg(f1);
  208.                     Complex ff2 = Complex.TrigToAlg(f2);
  209.                     r1 = ff1.abs();
  210.                     r2 = ff2.abs();
  211.                 }
  212.                 else
  213.                 {
  214.                     r1 = f1.abs();
  215.                     r2 = f2.abs();
  216.                 }
  217.                 if (r1 < r2)
  218.                 {
  219.                     return true;
  220.                 }
  221.                 else
  222.                 {
  223.                     return false;
  224.                 }
  225.             }
  226.             public static bool operator <=(Complex f1, Complex f2)
  227.             {
  228.                 double r1, r2;
  229.                 if (f1.p != 0 && f2.p != 0)
  230.                 {
  231.                     Complex ff1 = Complex.TrigToAlg(f1);
  232.                     Complex ff2 = Complex.TrigToAlg(f2);
  233.                     r1 = ff1.abs();
  234.                     r2 = ff2.abs();
  235.                 }
  236.                 else
  237.                 {
  238.                     r1 = f1.abs();
  239.                     r2 = f2.abs();
  240.                 }
  241.                 if (r1 <= r2)
  242.                 {
  243.                     return true;
  244.                 }
  245.                 else
  246.                 {
  247.                     return false;
  248.                 }
  249.             }
  250.             public static bool operator >=(Complex f1, Complex f2)
  251.             {
  252.                 double r1, r2;
  253.                 if (f1.p != 0 && f2.p != 0)
  254.                 {
  255.                     Complex ff1 = Complex.TrigToAlg(f1);
  256.                     Complex ff2 = Complex.TrigToAlg(f2);
  257.                     r1 = ff1.abs();
  258.                     r2 = ff2.abs();
  259.                 }
  260.                 else
  261.                 {
  262.                     r1 = f1.abs();
  263.                     r2 = f2.abs();
  264.                 }
  265.                 if (r1 >= r2)
  266.                 {
  267.                     return true;
  268.                 }
  269.                 else
  270.                 {
  271.                     return false;
  272.                 }
  273.             }
  274.             public static bool operator ==(Complex f1, Complex f2)
  275.             {
  276.                 double r1, r2;
  277.                 if (f1.p != 0 && f2.p != 0)
  278.                 {
  279.                     Complex ff1 = Complex.TrigToAlg(f1);
  280.                     Complex ff2 = Complex.TrigToAlg(f2);
  281.                     r1 = ff1.abs();
  282.                     r2 = ff2.abs();
  283.                 }
  284.                 else
  285.                 {
  286.                     r1 = f1.abs();
  287.                     r2 = f2.abs();
  288.                 }
  289.                 if (r1 == r2)
  290.                 {
  291.                     return true;
  292.                 }
  293.                 else
  294.                 {
  295.                     return false;
  296.                 }
  297.             }
  298.             public static bool operator !=(Complex f1, Complex f2)
  299.             {
  300.                 double r1, r2;
  301.                 if (f1.p != 0 && f2.p != 0)
  302.                 {
  303.                     Complex ff1 = Complex.TrigToAlg(f1);
  304.                     Complex ff2 = Complex.TrigToAlg(f2);
  305.                     r1 = ff1.abs();
  306.                     r2 = ff2.abs();
  307.                 }
  308.                 else
  309.                 {
  310.                     r1 = f1.abs();
  311.                     r2 = f2.abs();
  312.                 }
  313.                 if (r1 >= r2)
  314.                 {
  315.                     return true;
  316.                 }
  317.                 else
  318.                 {
  319.                     return false;
  320.                 }
  321.             }
  322.             #endregion
  323.             
  324.             public static Complex StringToComplex(string s)//статический метод из строки в комплексное число
  325.             {
  326.                 Complex f = new Complex();
  327.                 String pattern = @"[-+]?(\d+)([-+*/])(\d+)";
  328.                 foreach (Match m in Regex.Matches(s, pattern))
  329.                 {
  330.                     f.re = Int32.Parse(m.Groups[1].Value);
  331.                     f.im = Int32.Parse(m.Groups[3].Value);
  332.                     if (m.Groups[0].Value == "-")
  333.                     {
  334.                         f.re = f.re * -1;
  335.                     }
  336.                     if (m.Groups[2].Value == "-")
  337.                     {
  338.                         f.im *= -1;
  339.                     }
  340.                 }
  341.                 return f;
  342.             }
  343.  
  344.             ~Complex() 
  345.             {
  346.                 Console.WriteLine("Экземпляр уничтожен");
  347.             }
  348.  
  349.         }
  350.         static void Main(string[] args)
  351.         {
  352.  
  353.             Complex cmx1 = new Complex();
  354.             Complex cmx2 = new Complex();
  355.             Complex cmx = new Complex();
  356.             Console.WriteLine("Введите первое комплексное число в алгебраической форме:");
  357.             string comp1 = Console.ReadLine();
  358.             cmx1 = Complex.StringToComplex(comp1);
  359.             Console.WriteLine("Введите второе комплексное число в алгебраической форме:");
  360.             string comp2 = Console.ReadLine();
  361.             cmx2 = Complex.StringToComplex(comp2);
  362.             Console.WriteLine("ОПЕРАТОРЫ");
  363.             cmx = cmx1 + cmx2;
  364.             Console.WriteLine(cmx1.getComplexStrAlg() + "+" + cmx2.getComplexStrAlg() + "=" + cmx.getComplexStrAlg());
  365.             cmx = cmx1 - cmx2;
  366.             Console.WriteLine(cmx1.getComplexStrAlg() + "-" + cmx2.getComplexStrAlg() + "=" + cmx.getComplexStrAlg());
  367.             cmx = cmx1 * cmx2;
  368.             Console.WriteLine(cmx1.getComplexStrAlg() + "*" + cmx2.getComplexStrAlg() + "=" + cmx.getComplexStrAlg());
  369.             cmx = cmx1 / cmx2;
  370.             Console.WriteLine(cmx1.getComplexStrAlg() + "/" + cmx2.getComplexStrAlg() + "=" + cmx.getComplexStrAlg());
  371.             if (cmx1 > cmx2)
  372.             {
  373.                 Console.WriteLine(cmx1.getComplexStrAlg() + ">" + cmx2.getComplexStrAlg() + "=true");
  374.             }
  375.             else
  376.             if (cmx1 < cmx2)
  377.             {
  378.                 Console.WriteLine(cmx1.getComplexStrAlg() + "<" + cmx2.getComplexStrAlg() + "=true");
  379.             }
  380.             else
  381.             {
  382.                 Console.WriteLine(cmx1.getComplexStrAlg() + "==" + cmx2.getComplexStrAlg() + "=true");
  383.             }
  384.             Console.WriteLine("ТРИГОНОМЕТРИЧЕСКАЯ ФОРМА:");
  385.             Console.WriteLine("Первое число в тригонометрической форме:");
  386.             cmx = Complex.AlgToTrig(cmx1);
  387.             Console.WriteLine(cmx.getComplexStrTrig());//
  388.             Console.WriteLine("Второе число в тригонометрической форме:");
  389.             cmx = Complex.AlgToTrig(cmx2);
  390.             Console.WriteLine(cmx.getComplexStrTrig());//
  391.  
  392.             Console.WriteLine("Введите аргумент комплексного числа:");
  393.             double p = Convert.ToDouble(Console.ReadLine());
  394.             Console.WriteLine("Введите угол комплексного числа:");
  395.             double q = Convert.ToDouble(Console.ReadLine());
  396.             Complex tcmx = new Complex(p, q, "trig");
  397.             Console.WriteLine("Ваше число в тригонометрической и алгеброической формах");
  398.             Console.WriteLine(tcmx.getComplexStrTrig());
  399.             cmx = Complex.TrigToAlg(tcmx);
  400.             Console.WriteLine(cmx.getComplexStrAlg());
  401.  
  402.             Console.ReadLine();
  403.         }
  404.     }
  405. }

Решение задачи: «Комплексные числа, округление, ввод тригонометрической формы со строки»

textual
Листинг программы 
  1.         //метод преобразования в строку
  2.         public string getComplexStrAlg() // в алг
  3.         {
  4.             return string.Format("{0:0.00} {1} {2:0.00}i", re, im >= 0 ? "+" : "-", Math.Abs(im));
  5.         }

ИИ поможет Вам:

  • решить любую задачу по программированию
  • объяснить код
  • расставить комментарии в коде
  • и т.д
Попробуйте бесплатно

Оцени полезность:

5   голосов , оценка 4 из 5

Нужна аналогичная работа?

Оформи быстрый заказ и узнай стоимость

Бесплатно
Оформите заказ и авторы начнут откликаться уже через 10 минут
Похожие ответы