Решить систему ДУ методом Эйлера - C#

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

Здравствуйте. Будьте добры, подсобите. Начну по порядку. Есть система ДУ, надо решить методом Эйлера. Если для одного уравнения я могу сообразить

static double VpuskV (double angle, double l, double Ss, double V)
        {
            return V *= (Math.Sin(angle) + (l * 2 * Math.Sin(angle) * Math.Cos(angle)) / 2)
              / (2 / (Ss - 1) + (1 - Math.Cos(angle) + (l / 4) * (1 - (2 * Math.Cos(angle) * Math.Cos(angle) - 1))));

        }
private void button1_Click(object sender, EventArgs e)
        {
            double angle = 0 * Math.PI / 180;
            double angle1 = 180 * Math.PI / 180;
            int n = Convert.ToInt32(textBox8.Text);
            double h = (angle1 - angle) / n;
            double V1 = V;
            double V = Vc;
            for (int i = 1; i <= n; i++)
            {
                double f1 = VpuskV(angle, l, Ss, V);
                angle += h;
                V += f1 * h;
                V1 = V;
            }
            string temp = "";
            temp += Convert.ToString(V);
            textBox21.Text = temp;
          }

то для системы я, мягко говоря, слабоват.) Плюсом в системе такая заноза, что значение "V" присутствует и во втором, и в третьем уравнениях (аналогичная ситуация и с искомыми значениями второго и третьего уравнений -- также присутствуют в друг друге). Может у кого-нибудь найдется пример, кто-нибудь подскажет что дельное? (Так понимаю, надо через массивы действовать?)

Решение задачи: «Решить систему ДУ методом Эйлера»

textual
                            Листинг программы 
                        

                                internal class MethodEuler : INotifyPropertyChanged
    {
        #region protected Fields
 
        protected double _endInterval;
 
        protected Func<double, double, double> _func;
 
        protected double _h;
 
        protected double _x0;
 
        protected  double _y0;
 
        #endregion protected  Fields
 
        #region Public Constructors
 
        /// <summary>
        /// Инициализирует новый обьект <see cref="MethodEuler"/> класса.
        /// </summary>
        public MethodEuler ()
            : this ( 0.001, -10, 0 )
        {
        }
 
        /// <summary>
        /// Инициализирует новый обьект <see cref="MethodEuler"/> класса.
        /// </summary>
        /// <param name="H">Шаг сетки.</param>
        /// <param name="X0">Начальное условие.</param>
        /// <param name="Y0">Начальное условие.</param>
        public MethodEuler ( double H = 0.001, double X0 = -10, double Y0 = 0 )
        {
            this._h = H;
            this._x0 = X0;
            this._y0 = Y0;
        }
 
        #endregion Public Constructors
 
        #region Public Events
 
        /// <summary>
        /// Происходит при изменении значения свойства.
        /// </summary>
        public  event PropertyChangedEventHandler PropertyChanged;
 
        #endregion Public Events
 
        #region Public Properties
 
        /// <summary>
        /// Получает или задает конечный интервал по оси X.
        /// </summary>
        /// <value>
        /// Точка конца отрезка.
        /// </value>
        public double EndInterval
        {
            get
            {
                return _endInterval;
            }
 
            set
            {
                SetField ( ref _endInterval, value );
            }
        }
 
        /// <summary>
        /// Функция F(x, y).
        /// </summary>
        /// <value>
        /// Функция F(x, y).
        /// </value>
        public Func<double, double, double> Func
        {
            get
            {
                return _func;
            }
 
            set
            {
                SetField ( ref _func, value );
            }
        }
 
        /// <summary>
        /// Получает или задает шаг сетки.
        /// </summary>
        /// <value>
        /// Шаг сетки.
        /// </value>
        public double H
        {
            get
            {
                return _h;
            }
 
            set
            {
                SetField ( ref _h, value );
            }
        }
 
        /// <summary>
        /// Получает или задает начальное условие x0.
        /// </summary>
        /// <value>
        /// Начальное условие x0.
        /// </value>
        public double X0
        {
            get
            {
                return _x0;
            }
 
            set
            {
                SetField ( ref _x0, value );
            }
        }
 
        /// <summary>
        /// Получает или задает начальное условие y0.
        /// </summary>
        /// <value>
        /// Начальное условие y0.
        /// </value>
        public double Y0
        {
            get
            {
                return _y0;
            }
 
            set
            {
                SetField ( ref _y0, value );
            }
        }
 
        #endregion Public Properties
 
        #region Public Methods
 
        public IEnumerable<Tuple<double, double>> GetSolution ()
        {
            double nextX = X0;
            double nextY = Y0;
 
            for ( double i = X0; Math.Round ( i, 5 ) <= EndInterval; i += H )
            {
                yield return new Tuple<double, double> ( nextX, nextY );
 
                nextY = nextY + Func ( nextX, nextY ) * H;
                nextX += H;
                nextX = Math.Round ( nextX, 5 );
            }
        }
 
        public IEnumerable<Tuple<double, double>> GetSolution ( double x0, double y0, double h )
        {
            this.X0 = x0;
            this.Y0 = y0;
            this.H = h;
 
            return GetSolution ();
        }
 
        #endregion Public Methods
 
        #region Protected Methods
 
        /// <summary>
        /// Called when [property changed].
        /// </summary>
        /// <param name="propertyName">Name of the property.</param>
        protected void OnPropertyChanged ( string propertyName )
        {
            PropertyChangedEventHandler handler = PropertyChanged;
            if ( handler != null )
                handler ( null, new PropertyChangedEventArgs ( propertyName ) );
        }
 
        /// <summary>
        /// Sets the field.
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="field">The field.</param>
        /// <param name="value">The value.</param>
        /// <param name="propertyName">Name of the property.</param>
        /// <returns></returns>
        protected bool SetField<T> ( ref T field, T value, [CallerMemberName] string propertyName = null )
        {
            if ( EqualityComparer<T>.Default.Equals ( field, value ) )
                return false;
 
            field = value;
            OnPropertyChanged ( propertyName );
 
            return true;
        }
 
        #endregion Protected Methods
    }
                        