C# - ako skryť aktívny formulár a otvoriť druhý formulár

5 9 5 1 5 6 1 7 8 9
0 2 5 9 6 8 7 4 1 2
9 8 5 2 1 4 7 7 8 6
1 2 3 6 9 8 7 4 5 6
5 8 9 5 4 1 7 8 5 9
9 5 8 5 8 2 1 5 3 2
7 8 9 6 5 4 1 2 3 0
8 7 4 5 6 3 2 1 5 9
5 5 5 5 5 8 9 6 3 2
8 8 8 7 4 1 2 5 9 8

Od zadanej matice bola odrátaná jednotková matica vynásobená λ

-λ+5  9     5     1     5     6     1     7     8     9     
0     -λ+2  5     9     6     8     7     4     1     2     
9     8     -λ+5  2     1     4     7     7     8     6     
1     2     3     -λ+6  9     8     7     4     5     6     
5     8     9     5     -λ+4  1     7     8     5     9     
9     5     8     5     8     -λ+2  1     5     3     2     
7     8     9     6     5     4     -λ+1  2     3     0     
8     7     4     5     6     3     2     -λ+1  5     9     
5     5     5     5     5     8     9     6     -λ+3  2     
8     8     8     7     4     1     2     5     9     -λ+8 


Determinant matice je:  λ^10-37λ^9-720λ^8-4665λ^7-35022λ^6-144049λ^5-176136λ^4-1424819λ^3-11369883λ^2-4288856λ-28890926

Thread.CurrentCulture.NumberFormat.NumberDecimalSeparator ".";

NumberFormatInfo nfi = new NumberFormatInfo();
nfi.NumberDecimalSeparator = ".";
nfi.NumberGroupSeparator = "";

string number = "15424.23";
Decimal decimalNumber = Decimal.Parse(number, nfi);

staryformular.Polynomial p1 = new staryformular.Polynomial();

public class Formular1 : Form
{
    private string _nejakaHodnota;

    public Formular1(string hodnota)
    {
         NejakaHodnota = hodnota;
    }
}

public class Rodic : Form
{
     private Formular1 _formular1;
     ...

     public void NejakaMetoda()
     {
          _formular1 = new Formular1("nejaka hodnota");
          _formular1.Show();
     }
}

public class Formular1 : Form
{
    public string NejakaHodnota
    {
          get { return txtBox1.Text; }
          set { txtBox1.Text = value; }
    }

    ...
}

public partial class Form1 : Form
.
.
.
{
   public Class Polynomial {...}
   public Class Matrix {...}
   public struct resultOfDivisionPolynoms
   {
       public Polynomial Integral;
       public Polynomial Remainder;
   }
}
.
.
.

static public Polynomial Derive(Polynomial p1, int n)
            {
                for (int i = 1; i <= n; i++)
                {
                    int p1L = p1.Body.Length;
                    if (p1L <= 1)
                    {
                        //pDerived = new Polynomial(new Decimal[] { 0 });
                        p1 = new Polynomial(new Decimal[] { 0 });
                        break;
                    }
                    //pDerived = new Polynomial(new Decimal[p1L - 1]);
                    for (int j = 1; j < p1L; j++)
                    {
                        p1.Body[j - 1] = j * p1.Body[j];
                    }
                    p1.Body[p1L - 1] = 0;
                    //MessageBox.Show("pred: " + p1.Body.Length);
                    p1 = Polynomial.Opt(p1);
                    //MessageBox.Show("po: " + p1.Body.Length);
                }
                return p1;
            }

            static public Polynomial Opt(Polynomial p1)
            {
                Decimal[] d1 = p1.Body;
                int dec = 0;
                for (int i = p1.Body.Length - 1; i >= 0; i--)
                {
                    if (d1[i] != 0)
                    {
                        break;
                    }
                    else
                    {
                        dec += (d1[i] == 0 ? 1 : 0);
                    }
                }
                //MessageBox.Show("pred!: " + p1.Body.Length);
                Array.Resize(ref d1, d1.Length - dec);
                p1 = new Polynomial(d1);
                //MessageBox.Show("po!: " + p1.Body.Length);
                return p1;
            }

pd1 = Polynomial.Derive(p77, 1);
pd2 = Polynomial.Derive(p77, 2);

tak pd2 bude 2. derivácia polynómu

Polynomial pOut = p1;   //:-((((

Polynomial pOut = Polynomial.Clone(p1);
//Polynomial pOut = p1 + new Polynomial(new Decimal[] { 0 });

public struct PolynomRoots {}

PolynomRoots AllRoots;

public struct PolynomRoots {}

public struct PolynomRoots
        {
            public int index_r;
            public int index_c;
            public Decimal[] realRoots;
            public ComplexNumber[] complexRoots;
        }

            //Metóda zistenia počtu reálnych a komplexných koreňov
            static public PolynomRoots FindRoots(Polynomial p)
            {
                PolynomRoots AllRoots;
                AllRoots.index_r = 0;
                AllRoots.index_c = 0;
                AllRoots.realRoots = new Decimal[p.Body.Length];
                AllRoots.complexRoots = new ComplexNumber[p.Body.Length];

                //Zistí počet reálnych koreňov v každom intervale
                CountOfRoots[] countOfRoots = Polynomial.ComputeCountOfRoots(p, Interval, SturmSeries, AllRoots);

        public class BigNumbers
        {
            public Byte[] body { get; set; }
            public int DecimalSeparator { get; set; }
            public Boolean Sign { get; set; }           //true = <0, inf>; false = <-inf, 0)

           public BigNumbers(String iNumber)
            {
                Regex rgx = new Regex("[^0-9-\\.]");
                String siNumber = rgx.Replace(iNumber, "");
               
                if (siNumber == "" || siNumber.Substring(0, 2) == ".-" || siNumber.Length - siNumber.Replace(".", "").Length > 1)
                {
                    siNumber = "n/a";
                }
                else
                {
                    //Je číslo záporné?
                    Sign = true;
                    if (siNumber.Substring(0, 1) == "-")
                    {
                        Sign = false;
                    }
                    siNumber = siNumber.Replace("-", "");

                    //Je desatinná bodka na prípustnom mieste?
                    int DecSep = siNumber.IndexOf(".");
                    if (DecSep == 0)
                    {
                        siNumber.Replace(".", "0");
                        DecimalSeparator = siNumber.Length - 1;
                    }
                    else if (siNumber.IndexOf(".") == -1)
                    {
                        DecimalSeparator = 0;
                    }
                    else
                    {
                        DecimalSeparator = siNumber.Length - DecSep - 1;
                        siNumber = siNumber.Replace(".", "");
                    }

                    //Odstráni neplatné nuly zo začiatku a konca čísla
                    while (siNumber.Substring(0, 1) == "0" && siNumber.Length - DecimalSeparator > 1)
                    {
                        siNumber = siNumber.Substring(1, siNumber.Length - 1);
                    }

                    while (siNumber.Substring(siNumber.Length - 1, 1) == "0" && DecimalSeparator > 0)
                    {
                        siNumber = siNumber.Substring(0, siNumber.Length - 1);
                        DecimalSeparator--;
                    }
                   
                    //Skonvertuje String do poľa Byte
                    Byte[] sbody = new Byte[siNumber.Length * sizeof(char)];
                    body = new Byte[siNumber.Length];
                    System.Buffer.BlockCopy(siNumber.ToCharArray(), 0, sbody, 0, sbody.Length);
                    for (int i = 0; i < sbody.Length / 2; i++) body[i] = (Byte)(sbody[i * 2] - 48);
                    return;
                }
            }

BigNumbers c2 = new BigNumbers("-12.4553");

Byte[] c2.body = Byte[]{1, 2, 4, 5, 5, 3};
Boolean c2.Sign = false;
int c2.DecimalSeparator = 4;

Array.Resize(ref c2.body, c2.body.Length - 1);

Byte[] tst = c2.body;
Array.Resize(ref tst, tst.Length - 1);
c2.body = tst;

tst

public class BigNumbers

            static public Boolean operator ==(BigNumbers n1, BigNumbers n2)
            {
                if (n1.body.Length != n2.body.Length) return false;
                for (int i = 0; i < n1.body.Length; i++) if (n1.body[i] != n2.body[i]) return false;
                return n1.DecimalSeparator == n2.DecimalSeparator && n1.Sign == n2.Sign;
            }

            static public Boolean operator !=(BigNumbers n1, BigNumbers n2)
            {
                return !(n1 == n2);
            }

private void CheckMatrix_Click(object sender, EventArgs e)

static public PolynomRoots FindRoots(Polynomial p)