public override int go()
        {
            int    i, j, m;
            double tmp, tmp1;

            double[,] tmat = new double[5, 5];
            double[,,] tv  = new double[isiz2, isiz1, 5];

            Exchange_102.setParameters(rsd, k);
            Exchange_102.go();

            for (j = jend - 1; j >= jst - 1; j--)
            {
                for (i = iend - 1; i >= ist - 1; i--)
                {
                    for (m = 0; m < 5; m++)
                    {
                        tv[j, i, m] = omega * (udz[j, i, 0, m] * rsd[k, j + 2, i + 2, 0]
                                               + udz[j, i, 1, m] * rsd[k, j + 2, i + 2, 1]
                                               + udz[j, i, 2, m] * rsd[k, j + 2, i + 2, 2]
                                               + udz[j, i, 3, m] * rsd[k, j + 2, i + 2, 3]
                                               + udz[j, i, 4, m] * rsd[k, j + 2, i + 2, 4]);
                    }
                }
            }

            for (j = jend - 1; j >= jst - 1; j--)
            {
                for (i = iend - 1; i >= ist - 1; i--)
                {
                    for (m = 0; m < 5; m++)
                    {
                        tv[j, i, m] = tv[j, i, m]
                                      + omega * (udy[j, i, 0, m] * rsd[k - 1, j + 3, i + 2, 0]
                                                 + udx[j, i, 0, m] * rsd[k - 1, j + 2, i + 3, 0]
                                                 + udy[j, i, 1, m] * rsd[k - 1, j + 3, i + 2, 1]
                                                 + udx[j, i, 1, m] * rsd[k - 1, j + 2, i + 3, 1]
                                                 + udy[j, i, 2, m] * rsd[k - 1, j + 3, i + 2, 2]
                                                 + udx[j, i, 2, m] * rsd[k - 1, j + 2, i + 3, 2]
                                                 + udy[j, i, 3, m] * rsd[k - 1, j + 3, i + 2, 3]
                                                 + udx[j, i, 3, m] * rsd[k - 1, j + 2, i + 3, 3]
                                                 + udy[j, i, 4, m] * rsd[k - 1, j + 3, i + 2, 4]
                                                 + udx[j, i, 4, m] * rsd[k - 1, j + 2, i + 3, 4]);
                    }

                    for (m = 0; m < 5; m++)
                    {
                        tmat[0, m] = d[j, i, 0, m];
                        tmat[1, m] = d[j, i, 1, m];
                        tmat[2, m] = d[j, i, 2, m];
                        tmat[3, m] = d[j, i, 3, m];
                        tmat[4, m] = d[j, i, 4, m];
                    }

                    tmp1        = 1.0d / tmat[0, 0];
                    tmp         = tmp1 * tmat[0, 1];
                    tmat[1, 1]  = tmat[1, 1] - tmp * tmat[1, 0];
                    tmat[2, 1]  = tmat[2, 1] - tmp * tmat[2, 0];
                    tmat[3, 1]  = tmat[3, 1] - tmp * tmat[3, 0];
                    tmat[4, 1]  = tmat[4, 1] - tmp * tmat[4, 0];
                    tv[j, i, 1] = tv[j, i, 1] - tv[j, i, 0] * tmp;

                    tmp         = tmp1 * tmat[0, 2];
                    tmat[1, 2]  = tmat[1, 2] - tmp * tmat[1, 0];
                    tmat[2, 2]  = tmat[2, 2] - tmp * tmat[2, 0];
                    tmat[3, 2]  = tmat[3, 2] - tmp * tmat[3, 0];
                    tmat[4, 2]  = tmat[4, 2] - tmp * tmat[4, 0];
                    tv[j, i, 2] = tv[j, i, 2] - tv[j, i, 0] * tmp;

                    tmp         = tmp1 * tmat[0, 3];
                    tmat[1, 3]  = tmat[1, 3] - tmp * tmat[1, 0];
                    tmat[2, 3]  = tmat[2, 3] - tmp * tmat[2, 0];
                    tmat[3, 3]  = tmat[3, 3] - tmp * tmat[3, 0];
                    tmat[4, 3]  = tmat[4, 3] - tmp * tmat[4, 0];
                    tv[j, i, 3] = tv[j, i, 3] - tv[j, i, 0] * tmp;

                    tmp         = tmp1 * tmat[0, 4];
                    tmat[1, 4]  = tmat[1, 4] - tmp * tmat[1, 0];
                    tmat[2, 4]  = tmat[2, 4] - tmp * tmat[2, 0];
                    tmat[3, 4]  = tmat[3, 4] - tmp * tmat[3, 0];
                    tmat[4, 4]  = tmat[4, 4] - tmp * tmat[4, 0];
                    tv[j, i, 4] = tv[j, i, 4] - tv[j, i, 0] * tmp;

                    tmp1        = 1.0d / tmat[1, 1];
                    tmp         = tmp1 * tmat[1, 2];
                    tmat[2, 2]  = tmat[2, 2] - tmp * tmat[2, 1];
                    tmat[3, 2]  = tmat[3, 2] - tmp * tmat[3, 1];
                    tmat[4, 2]  = tmat[4, 2] - tmp * tmat[4, 1];
                    tv[j, i, 2] = tv[j, i, 2] - tv[j, i, 1] * tmp;

                    tmp         = tmp1 * tmat[1, 3];
                    tmat[2, 3]  = tmat[2, 3] - tmp * tmat[2, 1];
                    tmat[3, 3]  = tmat[3, 3] - tmp * tmat[3, 1];
                    tmat[4, 3]  = tmat[4, 3] - tmp * tmat[4, 1];
                    tv[j, i, 3] = tv[j, i, 3] - tv[j, i, 1] * tmp;

                    tmp         = tmp1 * tmat[1, 4];
                    tmat[2, 4]  = tmat[2, 4] - tmp * tmat[2, 1];
                    tmat[3, 4]  = tmat[3, 4] - tmp * tmat[3, 1];
                    tmat[4, 4]  = tmat[4, 4] - tmp * tmat[4, 1];
                    tv[j, i, 4] = tv[j, i, 4] - tv[j, i, 1] * tmp;

                    tmp1        = 1.0d / tmat[2, 2];
                    tmp         = tmp1 * tmat[2, 3];
                    tmat[3, 3]  = tmat[3, 3] - tmp * tmat[3, 2];
                    tmat[4, 3]  = tmat[4, 3] - tmp * tmat[4, 2];
                    tv[j, i, 3] = tv[j, i, 3] - tv[j, i, 2] * tmp;

                    tmp         = tmp1 * tmat[2, 4];
                    tmat[3, 4]  = tmat[3, 4] - tmp * tmat[3, 2];
                    tmat[4, 4]  = tmat[4, 4] - tmp * tmat[4, 2];
                    tv[j, i, 4] = tv[j, i, 4] - tv[j, i, 2] * tmp;

                    tmp1        = 1.0d / tmat[3, 3];
                    tmp         = tmp1 * tmat[3, 4];
                    tmat[4, 4]  = tmat[4, 4] - tmp * tmat[4, 3];
                    tv[j, i, 4] = tv[j, i, 4] - tv[j, i, 3] * tmp;

                    tv[j, i, 4] = tv[j, i, 4] / tmat[4, 4];
                    tv[j, i, 3] = tv[j, i, 3] - tmat[4, 3] * tv[j, i, 4];
                    tv[j, i, 3] = tv[j, i, 3] / tmat[3, 3];
                    tv[j, i, 2] = tv[j, i, 2] - tmat[3, 2] * tv[j, i, 3] - tmat[4, 2] * tv[j, i, 4];
                    tv[j, i, 2] = tv[j, i, 2] / tmat[2, 2];
                    tv[j, i, 1] = tv[j, i, 1] - tmat[2, 1] * tv[j, i, 2] - tmat[3, 1] * tv[j, i, 3] - tmat[4, 1] * tv[j, i, 4];
                    tv[j, i, 1] = tv[j, i, 1] / tmat[1, 1];
                    tv[j, i, 0] = tv[j, i, 0] - tmat[1, 0] * tv[j, i, 1] - tmat[2, 0] * tv[j, i, 2] - tmat[3, 0] * tv[j, i, 3] - tmat[4, 0] * tv[j, i, 4];
                    tv[j, i, 0] = tv[j, i, 0] / tmat[0, 0];

                    rsd[k - 1, j + 2, i + 2, 0] = rsd[k - 1, j + 2, i + 2, 0] - tv[j, i, 0];
                    rsd[k - 1, j + 2, i + 2, 1] = rsd[k - 1, j + 2, i + 2, 1] - tv[j, i, 1];
                    rsd[k - 1, j + 2, i + 2, 2] = rsd[k - 1, j + 2, i + 2, 2] - tv[j, i, 2];
                    rsd[k - 1, j + 2, i + 2, 3] = rsd[k - 1, j + 2, i + 2, 3] - tv[j, i, 3];
                    rsd[k - 1, j + 2, i + 2, 4] = rsd[k - 1, j + 2, i + 2, 4] - tv[j, i, 4];
                }
            }

            Exchange_113.setParameters(rsd, k);
            Exchange_113.go();
            return(0);
        }
        public override int go()
        {
            int    i, j, m;
            double tmp, tmp1;

            double[,] tmat = new double[5, 5];

            Exchange_102.setParameters(rsd, k);
            Exchange_102.go();

            for (j = jst; j <= jend; j++)
            {
                for (i = ist; i <= iend; i++)
                {
                    for (m = 1; m <= 5; m++)
                    {
                        rsd[k - 1, j + 1, i + 1, m - 1] = rsd[k - 1, j + 1, i + 1, m - 1]
                                                          - omega * (ldz[j - 1, i - 1, 0, m - 1] * rsd[k - 2, j + 1, i + 1, 0]
                                                                     + ldz[j - 1, i - 1, 1, m - 1] * rsd[k - 2, j + 1, i + 1, 1]
                                                                     + ldz[j - 1, i - 1, 2, m - 1] * rsd[k - 2, j + 1, i + 1, 2]
                                                                     + ldz[j - 1, i - 1, 3, m - 1] * rsd[k - 2, j + 1, i + 1, 3]
                                                                     + ldz[j - 1, i - 1, 4, m - 1] * rsd[k - 2, j + 1, i + 1, 4]);
                    }
                }
            }

            for (j = jst; j <= jend; j++)
            {
                for (i = ist; i <= iend; i++)
                {
                    for (m = 1; m <= 5; m++)
                    {
                        rsd[k - 1, j + 1, i + 1, m - 1] = rsd[k - 1, j + 1, i + 1, m - 1]
                                                          - omega * (ldy[j - 1, i - 1, 0, m - 1] * rsd[k - 1, j, i + 1, 0]
                                                                     + ldx[j - 1, i - 1, 0, m - 1] * rsd[k - 1, j + 1, i, 0]
                                                                     + ldy[j - 1, i - 1, 1, m - 1] * rsd[k - 1, j, i + 1, 1]
                                                                     + ldx[j - 1, i - 1, 1, m - 1] * rsd[k - 1, j + 1, i, 1]
                                                                     + ldy[j - 1, i - 1, 2, m - 1] * rsd[k - 1, j, i + 1, 2]
                                                                     + ldx[j - 1, i - 1, 2, m - 1] * rsd[k - 1, j + 1, i, 2]
                                                                     + ldy[j - 1, i - 1, 3, m - 1] * rsd[k - 1, j, i + 1, 3]
                                                                     + ldx[j - 1, i - 1, 3, m - 1] * rsd[k - 1, j + 1, i, 3]
                                                                     + ldy[j - 1, i - 1, 4, m - 1] * rsd[k - 1, j, i + 1, 4]
                                                                     + ldx[j - 1, i - 1, 4, m - 1] * rsd[k - 1, j + 1, i, 4]);
                    }

                    //---------------------------------------------------------------------
                    //   diagonal block inversion
                    //
                    //   forward elimination
                    //---------------------------------------------------------------------
                    for (m = 0; m < 5; m++)
                    {
                        tmat[0, m] = d[j - 1, i - 1, 0, m];
                        tmat[1, m] = d[j - 1, i - 1, 1, m];
                        tmat[2, m] = d[j - 1, i - 1, 2, m];
                        tmat[3, m] = d[j - 1, i - 1, 3, m];
                        tmat[4, m] = d[j - 1, i - 1, 4, m];
                    }

                    tmp1       = 1.0d / tmat[0, 0];
                    tmp        = tmp1 * tmat[0, 1];
                    tmat[1, 1] = tmat[1, 1] - tmp * tmat[1, 0];
                    tmat[2, 1] = tmat[2, 1] - tmp * tmat[2, 0];
                    tmat[3, 1] = tmat[3, 1] - tmp * tmat[3, 0];
                    tmat[4, 1] = tmat[4, 1] - tmp * tmat[4, 0];
                    rsd[k - 1, j + 1, i + 1, 1] = rsd[k - 1, j + 1, i + 1, 1] - rsd[k - 1, j + 1, i + 1, 0] * tmp;

                    tmp        = tmp1 * tmat[0, 2];
                    tmat[1, 2] = tmat[1, 2] - tmp * tmat[1, 0];
                    tmat[2, 2] = tmat[2, 2] - tmp * tmat[2, 0];
                    tmat[3, 2] = tmat[3, 2] - tmp * tmat[3, 0];
                    tmat[4, 2] = tmat[4, 2] - tmp * tmat[4, 0];
                    rsd[k - 1, j + 1, i + 1, 2] = rsd[k - 1, j + 1, i + 1, 2] - rsd[k - 1, j + 1, i + 1, 0] * tmp;

                    tmp        = tmp1 * tmat[0, 3];
                    tmat[1, 3] = tmat[1, 3] - tmp * tmat[1, 0];
                    tmat[2, 3] = tmat[2, 3] - tmp * tmat[2, 0];
                    tmat[3, 3] = tmat[3, 3] - tmp * tmat[3, 0];
                    tmat[4, 3] = tmat[4, 3] - tmp * tmat[4, 0];
                    rsd[k - 1, j + 1, i + 1, 3] = rsd[k - 1, j + 1, i + 1, 3] - rsd[k - 1, j + 1, i + 1, 0] * tmp;

                    tmp        = tmp1 * tmat[0, 4];
                    tmat[1, 4] = tmat[1, 4] - tmp * tmat[1, 0];
                    tmat[2, 4] = tmat[2, 4] - tmp * tmat[2, 0];
                    tmat[3, 4] = tmat[3, 4] - tmp * tmat[3, 0];
                    tmat[4, 4] = tmat[4, 4] - tmp * tmat[4, 0];
                    rsd[k - 1, j + 1, i + 1, 4] = rsd[k - 1, j + 1, i + 1, 4] - rsd[k - 1, j + 1, i + 1, 0] * tmp;

                    tmp1       = 1.0d / tmat[1, 1];
                    tmp        = tmp1 * tmat[1, 2];
                    tmat[2, 2] = tmat[2, 2] - tmp * tmat[2, 1];
                    tmat[3, 2] = tmat[3, 2] - tmp * tmat[3, 1];
                    tmat[4, 2] = tmat[4, 2] - tmp * tmat[4, 1];
                    rsd[k - 1, j + 1, i + 1, 2] = rsd[k - 1, j + 1, i + 1, 2] - rsd[k - 1, j + 1, i + 1, 1] * tmp;

                    tmp        = tmp1 * tmat[1, 3];
                    tmat[2, 3] = tmat[2, 3] - tmp * tmat[2, 1];
                    tmat[3, 3] = tmat[3, 3] - tmp * tmat[3, 1];
                    tmat[4, 3] = tmat[4, 3] - tmp * tmat[4, 1];
                    rsd[k - 1, j + 1, i + 1, 3] = rsd[k - 1, j + 1, i + 1, 3] - rsd[k - 1, j + 1, i + 1, 1] * tmp;

                    tmp        = tmp1 * tmat[1, 4];
                    tmat[2, 4] = tmat[2, 4] - tmp * tmat[2, 1];
                    tmat[3, 4] = tmat[3, 4] - tmp * tmat[3, 1];
                    tmat[4, 4] = tmat[4, 4] - tmp * tmat[4, 1];
                    rsd[k - 1, j + 1, i + 1, 4] = rsd[k - 1, j + 1, i + 1, 4] - rsd[k - 1, j + 1, i + 1, 1] * tmp;

                    tmp1       = 1.0d / tmat[2, 2];
                    tmp        = tmp1 * tmat[2, 3];
                    tmat[3, 3] = tmat[3, 3] - tmp * tmat[3, 2];
                    tmat[4, 3] = tmat[4, 3] - tmp * tmat[4, 2];
                    rsd[k - 1, j + 1, i + 1, 3] = rsd[k - 1, j + 1, i + 1, 3] - rsd[k - 1, j + 1, i + 1, 2] * tmp;

                    tmp        = tmp1 * tmat[2, 4];
                    tmat[3, 4] = tmat[3, 4] - tmp * tmat[3, 2];
                    tmat[4, 4] = tmat[4, 4] - tmp * tmat[4, 2];
                    rsd[k - 1, j + 1, i + 1, 4] = rsd[k - 1, j + 1, i + 1, 4] - rsd[k - 1, j + 1, i + 1, 2] * tmp;

                    tmp1       = 1.0d / tmat[3, 3];
                    tmp        = tmp1 * tmat[3, 4];
                    tmat[4, 4] = tmat[4, 4] - tmp * tmat[4, 3];
                    rsd[k - 1, j + 1, i + 1, 4] = rsd[k - 1, j + 1, i + 1, 4] - rsd[k - 1, j + 1, i + 1, 3] * tmp;

                    //---------------------------------------------------------------------
                    //   back substitution
                    //---------------------------------------------------------------------

                    rsd[k - 1, j + 1, i + 1, 4] = rsd[k - 1, j + 1, i + 1, 4] / tmat[4, 4];
                    rsd[k - 1, j + 1, i + 1, 3] = rsd[k - 1, j + 1, i + 1, 3] - tmat[4, 3] * rsd[k - 1, j + 1, i + 1, 4];
                    rsd[k - 1, j + 1, i + 1, 3] = rsd[k - 1, j + 1, i + 1, 3] / tmat[3, 3];
                    rsd[k - 1, j + 1, i + 1, 2] = rsd[k - 1, j + 1, i + 1, 2] - tmat[3, 2] * rsd[k - 1, j + 1, i + 1, 3] - tmat[4, 2] *
                                                  rsd[k - 1, j + 1, i + 1, 4];
                    rsd[k - 1, j + 1, i + 1, 2] = rsd[k - 1, j + 1, i + 1, 2] / tmat[2, 2];
                    rsd[k - 1, j + 1, i + 1, 1] = rsd[k - 1, j + 1, i + 1, 1] - tmat[2, 1] * rsd[k - 1, j + 1, i + 1, 2] - tmat[3, 1] *
                                                  rsd[k - 1, j + 1, i + 1, 3] - tmat[4, 1] *
                                                  rsd[k - 1, j + 1, i + 1, 4];
                    rsd[k - 1, j + 1, i + 1, 1] = rsd[k - 1, j + 1, i + 1, 1] / tmat[1, 1];
                    rsd[k - 1, j + 1, i + 1, 0] = rsd[k - 1, j + 1, i + 1, 0] - tmat[1, 0] * rsd[k - 1, j + 1, i + 1, 1] -
                                                  tmat[2, 0] * rsd[k - 1, j + 1, i + 1, 2] -
                                                  tmat[3, 0] * rsd[k - 1, j + 1, i + 1, 3] -
                                                  tmat[4, 0] * rsd[k - 1, j + 1, i + 1, 4];
                    rsd[k - 1, j + 1, i + 1, 0] = rsd[k - 1, j + 1, i + 1, 0] / tmat[0, 0];
                }
            }

            Exchange_113.setParameters(rsd, k);
            Exchange_113.go();

            /*  for(j=jst; j<=jend; j++)
             *            {
             *    for(i = ist; i<= iend; i++)
             *                    {
             *                            for(m = 0; m< 5; m++)
             *                            Console.WriteLine("rsd4[" + (k-1) + "," + (j+1) + "," + (i+1) + "," + (m) +"] = " + rsd[k-1, j+1, i+1, m]);
             *                    }
             *            }*/

            return(0);
        }