C#---牛顿迭代法求解非线性方程组

最新推荐文章于 2024-06-05 19:44:36 发布
最新推荐文章于 2024-06-05 19:44:36 发布
阅读量5.8k 收藏 26
点赞数 5
分类专栏： C#

NewtonMethod.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/// <summary>
/// 非线性方程组
/// by Ted
/// 2013.6
/// </summary>
/// 
namespace NewtonIteration
{
    class NewtonMethod
    {
        private NonlinearEquations _Equations; //非线性方程组
        private NonlinearEquation[,] _JacobiEquations; //雅克比方程(_EquationNum行,_UnknowNum列)
        private int _UnknowNum; //未知数的个数
        private int _EquationNum; //方程的个数
        private int _MaxIterativeTime;// 最大迭代次数
        private double _Precision; // 精度
        private double[] _StartValue; // 初值矩阵
        private double[] _EndValue; // 计算结果

        public double[] EndValue
        {
            get { return _EndValue; }
        }

        /// <summary>
        /// 默认构造函数
        /// </summary>
        public NewtonMethod()
        {
        }

        /// <summary>
        /// 通过非线性方程组构造牛顿迭代
        /// </summary>
        /// <param name="e">原始方程组</param>
        /// <param name="u">未知数个数</param>
        /// <param name="n">方程的个数</param>
        /// <param name="m">最大迭代次数</param>
        /// <param name="p">精度</param>
        /// <param name="s">初值</param>
        public NewtonMethod(NonlinearEquations e, int u, int n, int m, double p, double[] s)
        {
            _UnknowNum = u;
            _EquationNum = n;
            _MaxIterativeTime = m;
            _Precision = p;
            _StartValue = new double[u];
            for (int i = 0; i < u; i++)
            {
                _StartValue[i] = s[i];
            }
            _Equations = new NonlinearEquations();
            _Equations.Clear();
            for (int i = 0; i < n; i++)
            {
                _Equations.Add(e[i]);
            }
            _JacobiEquations = new NonlinearEquation[_EquationNum, _UnknowNum];
            for (int i = 0; i < _EquationNum; i++)
            {
                for (int j = 0; j < _UnknowNum; j++)
                {
                    _JacobiEquations[i, j] = new NonlinearEquation(_UnknowNum);
                    _JacobiEquations[i, j] = PartialDifferential(_Equations[i], j);
                }
            }
            _EndValue = new double[u];
        }

        /// <summary>
        /// 非线性方程e对未知数n求偏微分
        /// </summary>
        /// <param name="e">原始方程</param>
        /// <param name="n">未知数n从0开始计数</param>
        /// <returns></returns>
        private NonlinearEquation PartialDifferential(NonlinearEquation e, int n)
        {
            NonlinearEquation result = new NonlinearEquation(e._UnknowNum);
            for (int i = 0; i < e._UnknowNum; i++)
            {
                if (i != n)
                {
                    result._Coefficient[i] = 0;
                    result._Power[i] = 0;
                }
            }

            if (e._Power[n] > 1)
            {
                result._Power[n] = e._Power[n] - 1; // 降次
                result._Coefficient[n] = e._Coefficient[n] * e._Power[n]; // 系数乘以次数
                result._Constant = 0; // 常数项归零
            }
            else
            {
                //降次后变成常数项
                result._Power[n] = 1; // 次数归1
                result._Coefficient[n] = 0; // 系数归0
                result._Constant = -e._Coefficient[n]; // 移项
            }
            return result;
        }

        /// <summary>
        /// 根据初值构造雅克比矩阵
        /// </summary>
        /// <param name="x">初值矩阵</param>
        private double[,] JacobiMatrix(double[] x)
        {
            double[,] JacobiM = new double[_EquationNum, _UnknowNum];
            for (int i = 0; i < _EquationNum; i++)
            {
                for (int j = 0; j < _UnknowNum; j++)
                {
                    JacobiM[i, j] = _JacobiEquations[i, j].EquationValue(x);
                }
            }
            return JacobiM;
        }

        /// <summary>
        /// 返回方程组e的系数矩阵
        /// </summary>
        /// <param name="e">方程组</param>
        private double[,] CoefficientMatrix(NonlinearEquations e)
        {
            double[,] c = new double[_EquationNum, _UnknowNum];
            for (int i = 0; i < _EquationNum; i++)
            {
                for (int j = 0; j < _UnknowNum; j++)
                {
                    c[i, j] = e[i]._Coefficient[j];
                }
            }
            return c;
        }

        /// <summary>
        /// 返回方程组e的系数矩阵
        /// </summary>
        /// <param name="e">方程组</param>
        private double[,] CoefficientMatrix(NonlinearEquation[] e)
        {
            double[,] c = new double[_EquationNum, _UnknowNum];
            for (int i = 0; i < _EquationNum; i++)
            {
                for (int j = 0; j < _UnknowNum; j++)
                {
                    c[i, j] = e[i]._Coefficient[j];
                }
            }
            return c;
        }

        /// <summary>
        /// 返回方程组e的常数项矩阵
        /// </summary>
        /// <param name="e">方程组</param>
        private double[] ConstantMatrix(NonlinearEquations e)
        {
            double[] y = new double[_EquationNum];
            for (int i = 0; i < _EquationNum; i++)
            {
                y[i] = e[i]._Constant;
            }
            return y;
        }

        /// <summary>
        /// 返回方程组e的常数项矩阵
        /// </summary>
        /// <param name="e">方程组</param>
        private double[] ConstantMatrix(NonlinearEquation[] e)
        {
            double[] y = new double[_EquationNum];
            for (int i = 0; i < _EquationNum; i++)
            {
                y[i] = e[i]._Constant;
            }
            return y;
        }

        /// <summary>
        /// 返回方程组e的增广矩阵
        /// </summary>
        /// <param name="e">方程组</param>
        private double[,] AugmentationMatrix(NonlinearEquations e)
        {
            double[,] a = new double[_EquationNum, _UnknowNum + 1];
            for (int i = 0; i < _EquationNum; i++)
            {
                for (int j = 0; j < _UnknowNum; j++)
                {
                    a[i, j] = e[i]._Coefficient[j];
                }
                a[i, _UnknowNum] = e[i]._Constant;
            }
            return a;
        }

        /// <summary>
        /// 返回方程组e的增广矩阵
        /// </summary>
        /// <param name="e">方程组</param>
        private double[,] AugmentationMatrix(NonlinearEquation[] e)
        {
            double[,] a = new double[_EquationNum, _UnknowNum + 1];
            for (int i = 0; i < _EquationNum; i++)
            {
                for (int j = 0; j < _UnknowNum; j++)
                {
                    a[i, j] = e[i]._Coefficient[j];
                }
                a[i, _UnknowNum] = e[i]._Constant;
            }
            return a;
        }

        /// <summary>
        /// 判断一个浮点数是否等于0
        /// </summary>
        private bool IsDoubleZero(double v)
        {
            if (v < 0.0001 && v > -0.0001)
            {
                return true;
            }
            return false;
        }

        /// <summary>
        /// 判断方程组是否为线性
        /// </summary>
        private bool IsEquationsLinear()
        {
            for (int i = 0; i < _EquationNum; i++)
            {
                for (int j = 0; j < _UnknowNum; j++)
                {
                    if (_Equations[i]._Power[j] >= 2) { return false; }
                }
            }
            return true;
        }

        /// <summary>
        /// 根据系数矩阵c和常数项y求解线性方程组
        /// </summary>
        /// <param name="c">系数矩阵</param>
        /// <param name="y">常数项矩阵</param>
        /// <returns >value="0" 线性方程组无解</returns>
        /// <returns >value="1" 线性方程组有唯一解</returns>
        /// <returns >value="2" 线性方程组有无穷解</returns>
        private int LinearEquations(double[,] c, double[] y, ref double[] x)
        {
            // 行_EquationNum
            // 列_UnknowNum
            x = new double[_UnknowNum];
            int ResultForm = 1;

            #region 奇次线性方程组
            bool ZeroY = true;
            for (int i = 0; i < _EquationNum; i++)
            {
                if (!IsDoubleZero(y[i])) { ZeroY = false; break; }
            }
            #endregion

            #region 交换列主
            for (int i = 0; i < _UnknowNum; i++)
            {
                for (int j = i + 1; j < _EquationNum; j++)
                {
                    double MainValue = Math.Abs(c[i, i]); //列主的绝对值大小
                    int MainLine = i; //列主的行号
                    if (MainValue < Math.Abs(c[j, i]))
                    {
                        MainLine = j;
                        MainValue = Math.Abs(c[j, i]);
                        double temp;
                        for (int k = 0; k < _UnknowNum; k++)
                        {
                            temp = c[i, k]; c[i, k] = c[MainLine, k]; c[MainLine, k] = temp;
                        }
                        temp = y[i]; y[i] = y[MainLine]; y[MainLine] = temp;
                    }
                }
            }
            #endregion

            #region 消元
            for (int i = 0; i < _UnknowNum; i++)
            {
                if (!IsDoubleZero(c[i, i]))
                {
                    for (int j = i + 1; j < _EquationNum; j++)
                    {
                        double ratio = c[j, i] / c[i, i];
                        for (int k = 0; k < i + 1; k++)
                        {
                            c[j, k] = 0;
                        }
                        for (int k = i + 1; k < _UnknowNum; k++)
                        {
                            c[j, k] = c[j, k] - ratio * c[i, k];
                        }
                        y[j] = y[j] - ratio * y[i];
                    }
                }
            }
            #endregion

            #region 判断解的性质
            int FirstZeroColumn = 0; // 第一次系数全为0的行号
            for (int i = 0; i < _EquationNum; i++)
            {
                bool IsColumnZero = true;
                for (int j = 0; j < _UnknowNum; j++)
                {
                    // 这一行的元素全部为0
                    if (!IsDoubleZero(c[i, j])) { IsColumnZero = false; break; }
                }
                if (IsColumnZero) { break; }
                FirstZeroColumn++;
            }
            if (FirstZeroColumn < _EquationNum)
            {
                // 有系数全为0的行
                if (!IsDoubleZero(y[FirstZeroColumn])) { return 0; } //无解
                double CoefficientMatrixRank = FirstZeroColumn; //系数矩阵的秩
                if (CoefficientMatrixRank == _UnknowNum) { ResultForm = 1; } // 唯一解
                else if (CoefficientMatrixRank < _UnknowNum) { ResultForm = 2; } // 无穷解
                else { ResultForm = 2; }
            }
            else { ResultForm = 1; }
            #endregion

            #region 回代
            if (!ZeroY)
            {
                //回代
                for (int i = 0; i < _UnknowNum; i++)
                {
                    for (int j = _UnknowNum - 1; j >= 0; j--)
                    {
                        double Value = y[j];
                        for (int k = j + 1; k < _UnknowNum; k++)
                        {
                            Value = Value - c[j, k] * x[k];
                        }
                        x[j] = Value / c[j, j];
                    }
                }
            }
            else
            {
                // 齐次线性方程组,有一组零解
                for (int i = 0; i < _UnknowNum; i++) { x[i] = 0; }
            }
            #endregion

            return ResultForm;
        }

        /// <summary>
        /// 使用牛顿迭代法求非线性方程组
        /// </summary>
        /// <returns >value="0" 线性方程组无解</returns>
        /// <returns >value="1" 线性方程组有唯一解</returns>
        /// <returns >value="2" 线性方程组有无穷解</returns>
        /// <returns >value="3" 非线性方程组求解失败</returns>
        /// <returns >value="4" 非线性方程组求解成功</returns>
        /// <returns >value="5" 非线性方程组达到最大迭代次数</returns>
        public int NewtonValue()
        {
            if (IsEquationsLinear())
            {
                //是线性方程组
                double[,] c = new double[_EquationNum, _UnknowNum];
                double[] y = new double[_EquationNum];
                c = CoefficientMatrix(_Equations);
                y = ConstantMatrix(_Equations);
                return LinearEquations(c, y, ref _EndValue);
            }
            else
            {
                //非线性方程组,牛顿迭代法
                bool IsCirculate = false;
                int IterativeTime = 0;
                double[] x = new double[_UnknowNum];
                for (int j = 0; j < _UnknowNum; j++) { x[j] = _StartValue[j]; }
                do
                {
                    IsCirculate = false;
                    double[,] c = JacobiMatrix(x);
                    double[] y = new double[_EquationNum];
                    for (int j = 0; j < _EquationNum; j++) { y[j] = -_Equations[j].EquationValue(x); }
                    double[] detx = new double[_UnknowNum];
                    if (LinearEquations(c, y, ref detx) == 0) return 3;
                    for (int j = 0; j < _UnknowNum; j++) { x[j] += detx[j]; }
                    // 当差值小于初值时则迭代终止
                    for (int j = 0; j < _UnknowNum; j++)
                    {
                        if (Math.Abs(detx[j]) >= _Precision)
                        {
                            IsCirculate = true;
                            break;
                        }
                    }
                    IterativeTime++;
                    if (IterativeTime >= _MaxIterativeTime) { break; } // 达到最大迭代次数
                } while (IsCirculate);
                for (int j = 0; j < _UnknowNum; j++) { _EndValue[j] = x[j]; }
                if (!IsCirculate) { return 4; }
                if (IterativeTime >= _MaxIterativeTime) { return 5; }
                return 3;
            }
        }
    }
}

NonlinearEquations.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using System.Text;

/// <summary>
/// 非线性方程组
/// by Ted
/// 2013.6
/// </summary>

namespace NewtonIteration
{
    class NonlinearEquations : CollectionBase
    {
        /// <summary>
        /// 默认构造函数
        /// </summary>
        public NonlinearEquations()
        {
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="value"></param>
        public NonlinearEquations(NonlinearEquations Equations)
        {
            AddRange(Equations);
        }

        /// <summary>
        /// 构造函数
        /// </summary>
        /// <param name="value"></param>
        public NonlinearEquations(NonlinearEquation[] Equations)
        {
            AddRange(Equations);
        }

        /// <summary>
        /// 索引符
        /// </summary>
        /// <param name="index"></param>
        public NonlinearEquation this[int index]
        {
            get { return (NonlinearEquation)List[index]; }
            set { List[index] = value; }
        }

        /// <summary>
        /// 添加一个非线性方程
        /// </summary>
        /// <param name="newEquation"></param>
        public void Add(NonlinearEquation newEquation)
        {
            List.Add(newEquation);
        }

        /// <summary>
        /// 移除一个非线性方程
        /// </summary>
        /// <param name="oldEquation"></param>
        public void Remove(NonlinearEquation oldEquation)
        {
            List.Remove(oldEquation);
        }

        /// <summary>
        /// 根据值确定该方程在方程组中的索引
        /// </summary>
        /// <param name="currentEquation"></param>
        public int IndexOf(NonlinearEquation currentEquation)
        {
            return List.IndexOf(currentEquation);
        }

        /// <summary>
        /// 查看该方程是否在方程组中
        /// </summary>
        /// <param name="currentEquation"></param>
        public bool Contains(NonlinearEquation currentEquation)
        {
            return List.Contains(currentEquation);
        }

        /// <summary>
        /// 插入一个新的非线性方程
        /// </summary>
        /// <param name="currentEquation"></param>
        public void Insert(int index, NonlinearEquation currentEquation)
        {
            List.Insert(index, currentEquation);
        }

        /// <summary>
        /// 添加非线性方程数组到当前集合
        /// </summary>
        /// <param name="Equations"></param>
        public void AddRange(NonlinearEquation[] Equations)
        {
            for (int i = 0; i < Equations.Length; i++)
            {
                this.Add(Equations[i]);
            }
        }

        /// <summary>
        /// 添加非线性方程集合到当前集合
        /// </summary>
        /// <param name="Equations"></param>
        public void AddRange(NonlinearEquations Equations)
        {
            for (int i = 0; i < Equations.Capacity; i++)
            {
                Add((NonlinearEquation)Equations.List[i]);
            }
        }
    }
}

NonlinearEquation.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NewtonIteration
{
    class NonlinearEquation
    {
        public int _UnknowNum; // 未知数的个数
        public double[] _Coefficient; // 未知数的系数
        public int[] _Power; // 未知数的次数(权),次数为0表示常数
        public double _Constant; //常数项

        /// <summary>
        /// 默认构造函数
        /// </summary>
        public NonlinearEquation()
        {
            _UnknowNum = 0;
        }

        /// <summary>
        /// 构造一个带有n个未知数的非线性方程
        /// </summary>
        /// <param name="n">未知数的个数</param>
        public NonlinearEquation(int n)
        {
            _UnknowNum = n;
            _Coefficient = new double[n];
            _Power = new int[n];
        }

        /// <summary>
        /// 默认
        /// </summary>
        public void InitEquation()
        {
            for (int i = 0; i < _UnknowNum; i++)
            {
                _Coefficient[i] = 0;
                _Power[i] = 1;
            }
            _Constant = 0;
        }

        /// <summary>
        /// 把方程转化成字符串输出
        /// </summary>
        public string EquationToString()
        {
            if (_UnknowNum <= 0) return null;
            string equation = "";

            bool IsCoefficientAllZero = true;
            for (int i = 0; i < _UnknowNum; i++)
            {
                if (!IsDoubleZero(_Coefficient[i])) { IsCoefficientAllZero = false; break; }
            }
            if (IsCoefficientAllZero)
            {
                // 系数全为0
                equation += "0";
            }
            else
            {
                bool IsAddFirst = true;
                for (int i = 0; i < _UnknowNum; i++)
                {
                    if (_Coefficient[i] < 0)
                    {
                        if (i > 0 && !IsAddFirst)
                            equation += " + ";
                        // 系数小于0,系数加括号
                        equation += "(";
                        equation += _Coefficient[i].ToString();
                        equation += ")*X";
                        equation += (i + 1).ToString();
                        if (_Power[i] > 1)
                        {
                            equation += "^";
                            equation += _Power[i].ToString();
                        }
                        if (IsAddFirst) IsAddFirst = false;
                    }
                    else if (_Coefficient[i] > 0)
                    {
                        if (i > 0 && !IsAddFirst)
                            equation += " + ";
                        // 系数大于0,系数不加括号
                        equation += _Coefficient[i].ToString();
                        equation += "*X";
                        equation += (i + 1).ToString();
                        if (_Power[i] > 1)
                        {
                            equation += "^";
                            equation += _Power[i].ToString();
                        }
                        if (IsAddFirst) IsAddFirst = false;
                    }
                    // 系数等于0,不输出
                }
            }
            equation += " = ";
            equation += _Constant.ToString();
            return equation;
        }

        /// <summary>
        /// 设置方程未知数的值并输出
        /// </summary>
        public double EquationValue(double[] x)
        {
            double y = 0;
            for (int i = 0; i < _UnknowNum; i++)
            {
                double result = 0;
                if (_Coefficient[i] != 0)
                {
                    result = 1;
                    for (int j = 0; j < _Power[i]; j++)
                    {
                        // 次数
                        result *= x[i];
                    }
                    result *= _Coefficient[i]; // 系数
                }
                y += result;
            }
            y -= _Constant; // 常数项移项
            return y;
        }

        /// <summary>
        /// 判断一个浮点数是否等于0
        /// </summary>
        private bool IsDoubleZero(double v)
        {
            if (v < 0.0001 && v > -0.0001)
            {
                return true;
            }
            return false;
        }
    }
}

Program.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;

namespace NewtonIteration
{
    class Program
    {
        static void Main(string[] args)
        {
            int _UnknowNum = 2;                  // 未知数的个数
            int _EquationNum = 2;                // 方程的个数
            int _MaxIterativeTime = 100;          // 最大迭代次数
            double _Precision = 0.001;           // 精度
            double[] _StartValue = {1, 1};       // 初值矩阵
            double[] _EndValue;                  // 计算结果
            NonlinearEquations _Equations;       // 非线性方程组
            NewtonMethod _Newton;                // 牛顿迭代式

            // 赋值
            _Equations = new NonlinearEquations();
            NonlinearEquation[] newEquations = new NonlinearEquation[_EquationNum];
            double [,]coefficient = new double[2,2]{{1, 2},{2, 1}};
            int [,]power = new int[2, 2] { { 1, 1 }, { 2, 2 } };
            double []constant = new double[]{3, 5};

            for (int i = 0; i < _EquationNum; i++)
            {
                newEquations[i] = new NonlinearEquation(_UnknowNum);
                for (int j = 0; j < _UnknowNum; j++)
                {
                    newEquations[i]._Coefficient[j] = coefficient[i,j];
                    newEquations[i]._Power[j] = power[i,j];
                }
                newEquations[i]._Constant = constant[i];
            }
            _Equations.Clear();
            _Equations.AddRange(newEquations);

            // 调用牛顿迭代法
            if (_UnknowNum > 0 || _EquationNum > 0 || _MaxIterativeTime > 0 || _Precision > 0)
            {
                _Newton = new NewtonMethod(_Equations, _UnknowNum, _EquationNum, _MaxIterativeTime, _Precision, _StartValue);
                int CalculateResult = _Newton.NewtonValue();
                _EndValue = _Newton.EndValue;
                string mesg = "";
                // 将结果显示在屏幕上
                switch (CalculateResult)
                {
                    case 0:
                        mesg = "线性方程组求解失败！线性方程组无解。";
                        break;
                    case 1:
                        mesg = "线性方程组求解成功！有且仅有一组解。";
                        break;
                    case 2:
                        mesg = "线性方程组求解失败！有无穷多解。";
                        break;
                    case 3:
                        mesg = "非线性方程组求解失败！";
                        break;
                    case 4:
                        mesg = "非线性方程组求解成功！";
                        break;
                    case 5:
                        mesg = "达到最大迭代次数！";
                        break;
                }
                Console.WriteLine(mesg);

                if (CalculateResult == 1 || CalculateResult == 4 || CalculateResult == 5)
                {
                    for (int i = 1; i < _UnknowNum + 1; i++)
                    {
                        string x = "x" + i.ToString() + "=" + _EndValue[i - 1].ToString();
                        Console.WriteLine(x);
                    }
                }
            }
            else
            {
                Console.WriteLine("参数不全！");
                return;
            }

            Console.ReadLine();
        }
    }
}

这里写图片描述
这里写图片描述

谛听-
关注
  • 5
    点赞
  • 踩
  • 26
    收藏
    觉得还不错? 一键收藏
  • 15
    评论
专栏目录
[算法设计与分析]4.1.3迭代法解方程(牛顿迭代法+二分法解方程)
A beginner's learning path
03-31 906
#include&lt;stdio.h&gt; #include&lt;iostream&gt; #include&lt;math.h&gt; using namespace std; void NewtonIteration();//牛顿迭代法求解方程 void DichotomySolving();//二分法求解方程 int main () { NewtonIteration()...
c语言求解非线性方程组_非线性方程组求解之牛顿法
weixin_30863333的博客
12-07 933
牛顿法者，基于Taylor展开的一种方法也。若带入解，恒等于0.总可以用Taylor级数展开。二阶导数不是向量而是矩阵。后面还有三阶项四阶项……随着n的增加趋于无穷小的值。只取一阶项，这样右边便是线性的。求逆矩阵，注意那个-1p虽然叫“步长”但其实是一个向量，于是称其为“方向”。那么xa可求。牛顿通式新的解是原来的解+P啥啥输入计算机先给初始点（Ntm一定要有初始解）x0不在x*的位置，其实是远离...
C# 求三次和非线性方程的根MathNet.RootFinding
微小冷的学习笔记
12-20 1448
这些静态类一般提供三种求根方法，分别是FindRoot，FindRootExpand以及TryFindRoot，下表列出这些静态类，以及这些静态类支持哪种求根方案。对于三次方程，RootFinding提供了更加便捷的函数Cubic，其调用方方法非常简单，仍以上述函数。为例，Cubic提供了求实根的函数RealRoots，其输入参数为a0,a1,a2，对应方程。最后只得到一个根，说明另外两个根是复数，Cubic提供了三次复数求解器，示例如下。下面以二分法为例，解读一下这些静态函数的用法。
C#实现牛顿迭代法求解非线性方程组
01-17
计算方法常用算法，牛顿迭代法求解方程组，可以输入线性或非线性方程组，IDE为VS2010，.NET搭建用户界面，报错功能完善。
C++,牛顿法解非线性方程组
最新发布
2301_81831359的博客
06-05 328
—代码中的各个函数和各个数组维数需要根据不同的情况进行改变才可以使用，这里运用两个例题来测试代码的可行性。——————如有错误，欢迎指正(#^.^#)例题二只需要改变例题一代码中的函数即可。
C语言 Newton迭代法解非线性方程组
11-25
设计思想：非线性方程组包含两个非线性方程及两个位置元，按Newton迭代公式进行迭代求解，当迭代误差小于给定精度水平时，取最终的X1，X2为所得方程的解。
C#---最速下降+牛顿迭代求二元非线性方程组
新博客：https://aping-dev.com/
01-10 2353
求解非线性方程组 即 Newton.cs using System; using System.Collections.Generic; using System.Linq; using System.Text; namespace NewtonIteration { class Newton { int _MaxIterativeTime =
拟牛顿法求解非线性方程组
weixin_43464554的博客
04-06 3459
文章目录牛顿法求解非线性方程组次梯度法案例Python代码 牛顿法求解非线性方程组 假设有非线性方程组 f(x)=0f(x)=0f(x)=0, 解为x∗x^{*}x∗ f(x∗)=f(x~)+∂f(x~)∂x(x∗−x~)+12!∂2f(x~)∂x2(x∗−x~)2+13!∂3f(x~)∂x3(x∗−x~)3+..=0\begin{aligned} f\left(x^{*}\right) &=f(\tilde{x})+\frac{\partial f(\tilde{x})}{\partial x}\
C#语言的各阶牛顿迭代法比较（有源码）
12-20
在C#编程环境下，我们可以利用牛顿迭代法来解决各种问题，比如求解复杂的数学方程或者优化问题。本文将深入探讨牛顿迭代法的原理及其在C#中的实现，包括一阶、三阶、五阶和六阶的收敛形式。 首先，牛顿迭代法的基本...
C#实现的一元四次方程求解源代码
06-02
然而，卡尔丹公式计算过程复杂，不易实现，因此在实际编程中，通常采用数值方法，如牛顿迭代法或者二分法来求解。 在C#中，可以创建一个名为`QuarticEquationSolver`的类，该类包含一个方法`Solve`用于求解四次方程...
C#非线性方程组算法
08-07
在C#中，解决非线性方程组的方法之一是使用牛顿-拉弗森法（Newton-Raphson method），这是一种迭代方法。该方法基于函数的切线近似，通过不断地迭代改进根的估计值，直到达到预设的精度要求。具体步骤如下： 1. ...
C#--解方程组之Seidel迭代法
DX奥特曼的博客
05-06 2011
简介高斯-赛德尔迭代法是解线性方程组的常用迭代法之一，设线性方程组为高斯-赛德尔迭代法的迭代公式为当然，此处假定 ，在很多情况下，它比简单迭代法收敛快，它和简单迭代法的不同点在于计算 时，利用了刚刚迭代出的的值，当系数矩阵 A 严格对角占优或对称正定时，高斯-赛德尔迭代法必收敛。迭代公式的实现 public void Calcu6() { int count...
Unity中使用C#以【拟牛顿法】来求解非线性方程组
穿裤子的云
03-11 619
python的scipy中有一个fsolver()方法，一键求解，C#中有什么对应的包和api吗？
非线性方程（组）求解
hanmo22357的博客
11-01 3184
（更新中） 非线性方程组的求解是数学中的一大难点，但是我们可以通过计算机的运算快速求出非线性方程组的近似解，下面给出四种求解非线性方程组的方法：二分法、不动点迭代法 以下的内容均用Python语言实现，所定义的函数可以直接使用（用来写数值分析（or计算方法）的作业），需要可以自取 1.二分法： 原理就是高数中的方程的根的存在定理：若一个区间的两端点的函数值一正一负，则该区间内至少有一个根。因此可以每次将区间长度二等分，直到区间足够小或者所得到的区间的两端点函数值同号为止。 下面是二分法的代码： 使用方法：函
C#实现Math.Sqrt函数 -- 牛顿迭代法
qq_41946341的博客
11-21 1045
/// <summary> /// 开平方根(牛顿迭代法) /// </summary> /// <param name="c"></param> /// <returns></returns> public static decimal Sqrt(decimal c) { if (c < 0) { return decimal.MinValue; } decimal e = 1e-
计算方法（一）用C#实现数值迭代
weixin_30412013的博客
09-10 1124
平时，经常会遇到解方程，计算方法中常用的有二分法（精度太低，迭代次数多，一般没人用）,牛顿迭代法，弦截法，网上大多都是C++或者Java的实现代码，很少有C#的，我在本科毕业论文中用到了这些，那时也需要做一个winfrom，所以就用了C#，因此今天正好借这篇文章，把我的代码修改一下，公布出来，当然，代码有很多不足，扩展性也比较差，所以还希望大家多多指教喽。 public static...
c#迭代
马里奥的专栏
08-06 1205
摘要：迭代器是C#2.0中添加的功能，它能够使我们在类或结构中支持foreach迭代，而不必实现整个IEnumerable/IEnumerable接口。今天我们就一块看一下什么是c#中的迭代器吧。 主要内容： 1.foreach的运行机制 2.传统集合的遍历 3.使用迭代器 一、foreach的运行机制 我们在程序中经常会用到foreach，如果你把它理解成是f
算法分析与设计-迭代法求解方程（组）的根（详解）
热门推荐
Akatsuki
06-17 2万+
算法分析设计课之期末考试前的重要算法复习总结。。。以下内容大多都摘抄自上课的课件的内容，但是课件没有解方程的完整代码，于是自己又写了写代码，仅供参考。首先，迭代法解方程的实质是按照下列步骤构造一个序列x0,x1,…,xn,来逐步逼近方程f(x)=0的解:1）选取适当的初值x0；2）确定迭代格式，即建立迭代关系，需要将方程f(x)=0改写为x=φ(x)的等价形式；3) 构造序列x0，x1，……，...
迭代法解方程组
qq_1300258993的博客
04-25 2270
问题描述： 使用迭代法求解方程组初始值为0，0，0 问题分析： 将方程组的各个未知数分别移到等式左边，并且未知数前面的所有参数化为1，再改成迭代式得： 然后将初始值代入迭代方程组，通过多次运行解出答案 迭代法解方程组 输入： 输入题目参数 #include<cstdio> double x=0,y=0,z=0; void fact(double x1,double x2,dou...
评论 15
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值