数值计算方法中如何构造迭代公式？

Posted 2023-04-04

数值计算方法中如何构造迭代公式？如图所示

参考技术A |ψ'(x)-3|<1
即： 2<ψ'(x)<4
设 f(x)=ψ(x)-x
f'(x)=ψ'(x)-1
所以： 1<f'(x)<3
用牛顿法: x := x-f(x)/f'(x)
迭代公式
x := x- (ψ(x)-x)/(ψ'(x)-1)

计算方法用C#实现数值迭代

    在工科，经常会遇到解方程，计算方法中常用的有二分法（精度太低，迭代次数多，一般没人用）,牛顿迭代法，弦截法，网上大多都是C++或者Java的实现代码，很少有C#的，我在本科毕业论文中用到了这些，那时也需要做一个winfrom，所以就用了C#，因此今天正好借篇文章，把我的代码修改一下，公布出来，方便学弟学妹或者其他人员使用，当然，代码有很多不足，扩展性也比较差，所以还希望大家多多指教喽。

        /// <summary>
        /// 二分法
        /// </summary>
        /// <param name="fun">fun是一个委托，代表了一个y=f(x)的一元方程</param>
        /// <param name="x1">隔跟区间的左端点</param>
        /// <param name="x2">隔跟区间的右端点</param>
        /// <param name="e">迭代精度</param>
        /// <returns>符合迭代精度的方程的解</returns>
        public static double Half(Func<double, double> fun, double x1, double x2, double e)
        {
            double x = 0;
            while (Math.Abs(x2 - x1) > e)
            {
                x = (x1 + x2) / 2;
                if (fun(x1) * fun(x) < 0)
                {
                    x2 = x;
                }
                else if (fun(x2) * fun(x) < 0)
                {
                    x1 = x;
                }
                else if (0 == fun(x))
                {
                    return x;
                }
            }
            return x;
        }

        /// <summary>
        /// 牛顿迭代法
        /// </summary>
        /// <param name="fun">fun是一个委托，代表了一个y=f(x)的一元方程</param>
        /// <param name="fun_k">上面的这个函数的一阶倒数y=f‘(x)</param>
        /// <param name="x1">方程的初始解</param>
        /// <param name="n">迭代次数</param>
        /// <returns>符合迭代次数的方程的解</returns>
        public static double Newton(Func<double, double> fun, Func<double, double> fun_k, double x1, int n)
        {
            int count = 0;
            double x2 = 0;
            while (count < n)
            {
                x2 = x1 - fun(x1) / fun_k(x1);
                x1 = x2;
                count++;
            }
            return x2;
        }

        /// <summary>
        /// 单点弦截法
        /// </summary>
        /// <param name="fun">fun是一个泛型委托，代表了一个y=f(x)的一元方程</param>
        /// <param name="x1">方程隔跟区间的左端点</param>
        /// <param name="x2">方程隔跟区间的右端点</param>
        /// <param name="n">迭代次数</param>
        /// <returns>符合迭代次数的方程的解</returns>
        public static double Single(Func<double, double> fun, double x1, double x2, int n)
        {
            int count = 0;
            double x0 = x1;
            while (count < n)
            {
                x2 = x0 - (x2 - x1) / (fun(x2) - fun(x1)) * fun(x1);
                count++;
            }
            return x2;
        }

        /// <summary>
        /// 割线法
        /// </summary>
        /// <param name="fun">fun是一个泛型委托，代表了一个y=f(x)的一元方程</param>
        /// <param name="x1">方程隔跟区间的左端点</param>
        /// <param name="x2">方程隔跟区间的右端点</param>
        /// <param name="n">迭代次数</param>
        /// <returns>符合迭代次数的方程的解</returns>
        public static double Sec(Func<double, double> fun, double x1, double x2, int n)
        {
            int count = 0;
            double x3 = 0;
            while (count < n)
            {
                x3 = x2 - (x2 - x1) / (fun(x2) - fun(x1)) * fun(x2);
                x1 = x2;
                x2 = x3;
                count++;
            }
            return x3;
        }