Accord.Math.Optimization.BoundedBroydenFletcherGoldfarbShanno.daxpy C# (CSharp) Method

        private static void daxpy(int n, double da,
             double[] dx, int _dx_offset, int incx, double[] dy, int _dy_offset, int incy)
        {

            int i = 0;
            int ix = 0;
            int iy = 0;
            int m = 0;
            int mp1 = 0;
            if ((n <= 0))
            {
                return;
            }

            if ((da == 0.0e0))
            {
                return;
            }

            if (((incx == 1) && (incy == 1)))
            {
                // *
                // *        code for both increments equal to 1
                // *
                // *
                // *        clean-up loop
                // *
                m = (n) % (4);
                if ((m != 0))
                {
                    {
                        for (i = 1; i <= m; i++)
                        {
                            dy[(i - (1)) + _dy_offset] = (dy[(i - (1)) + _dy_offset]
                                + (da * dx[(i - (1)) + _dx_offset]));
                        }
                    }
                }

                if ((n < 4))
                {
                    return;
                }

                mp1 = (m + 1);
                {
                    int _i_inc = 4;
                    for (i = mp1; i <= n; i += _i_inc)
                    {
                        dy[(i - (1)) + _dy_offset] = (dy[(i - (1)) + _dy_offset]
                            + (da * dx[(i - (1)) + _dx_offset]));
                        dy[((i + 1) - (1)) + _dy_offset] = (dy[((i + 1) - (1)) + _dy_offset]
                            + (da * dx[((i + 1) - (1)) + _dx_offset]));
                        dy[((i + 2) - (1)) + _dy_offset] = (dy[((i + 2) - (1)) + _dy_offset]
                            + (da * dx[((i + 2) - (1)) + _dx_offset]));
                        dy[((i + 3) - (1)) + _dy_offset] = (dy[((i + 3) - (1)) + _dy_offset]
                            + (da * dx[((i + 3) - (1)) + _dx_offset]));
                    }
                }
            }
            else
            {
                // *
                // *        code for unequal increments or equal increments
                // *          not equal to 1
                // *
                ix = 1;
                iy = 1;
                if ((incx < 0))
                {
                    ix = (((((-(n)) + 1)) * incx) + 1);
                }
                if ((incy < 0))
                {
                    iy = (((((-(n)) + 1)) * incy) + 1);
                }
                {
                    for (i = 1; i <= n; i++)
                    {
                        dy[(iy - (1)) + _dy_offset] = (dy[(iy - (1)) + _dy_offset]
                            + (da * dx[(ix - (1)) + _dx_offset]));
                        ix = (ix + incx);
                        iy = (iy + incy);
                    }
                }
            }
            return;
        }
    }