• 用 matlab 求解复杂方程怎么出现这种情况?还有没有别的方法求x,python或c都行


    关注 码龄 粉丝数 原力等级 -- 被采纳 被点赞 采纳率 2301_78628974 2024-04-16 00:13 采纳率: 50% 浏览 5 首页/ 编程语言 / 用 matlab 求解复杂方程怎么出现这种情况?还有没有别的方法求x,python或c都行 matlabpythonc语言 想要求出具体的 x 值,但是不知道为什么出现了一长串这个,我刚入门,看不懂 收起 写回答 好问题 0 提建议 追加酬金 关注问题 微信扫一扫 点击复制链接 分享 邀请回答 编辑 收藏 删除 结题 收藏 举报 追加酬金 (90%的用户在追加酬金后获得了解决方案) 当前问题酬金 ¥ 0 (可追加 ¥500) ¥ 15¥ 20¥ 50¥ 100¥ 200 支付方式 扫码支付 二维码出错 点击刷新 支付金额 15 元 提供问题酬金的用户不参与问题酬金结算和分配 支付即为同意 《付费问题酬金结算规则》 结题 再想想 删除 再等等

    2条回答 默认 最新

    • Kwan的解忧杂货铺 Java领域优质创作者 2024-04-16 11:30
      关注

      上午好☀️☀️☀️️
      本答案参考ChatGPT-3.5

      根据提供的文本内容,这是一个MATLAB程序中的符号计算问题,虽然方程看上去很复杂,但MATLAB提供了求解符号方程的功能,可以通过以下步骤解决:

      解决方案:

      1. 定义符号变量:在MATLAB中,可以使用syms命令定义符号变量。在这个问题中,需要定义x为符号变量。代码如下:

        syms x;
        
      2. 定义方程式:在MATLAB中,可以使用等号(=)将一个符号表达式赋值给一个变量。在这个问题中,需要将方程赋值给变量eq1。代码如下:

        eq1 = -50000*(1+x)^(-1)-70000*(1+x)^(-2)+15000*(1+x)^(-3)+18000*(1+x)^(-4)+21000*(1+x)^(-5)+21000*(1+x)^(-6)+21000*(1+x)^(-7)+21000*(1+x)^(-8)+21000*(1+x)^(-9)+21000*(1+x)^(-10)+21000*(1+x)^(-11)+21000*(1+x)^(-12)+21000*(1+x)^(-13)+21000*(1+x)^(-14)+21000*(1+x)^(-15)+21000*(1+x)^(-16)==0;
        
      3. 解方程:在MATLAB中,可以使用solve命令求解符号方程,将eq1作为输入参数。代码如下:

        solve(eq1)
        
      4. 分析结果:根据结果可以看出,方程有15个实根。具体的根的数字只是计算结果的方式,因此不需要关注。如果需要得到具体的根,可以使用double函数将输出的符号结果转换为数字。下面是完整的MATLAB代码:

        syms x;
        eq1 = -50000*(1+x)^(-1)-70000*(1+x)^(-2)+15000*(1+x)^(-3)+18000*(1+x)^(-4)+21000*(1+x)^(-5)+21000*(1+x)^(-6)+21000*(1+x)^(-7)+21000*(1+x)^(-8)+21000*(1+x)^(-9)+21000*(1+x)^(-10)+21000*(1+x)^(-11)+21000*(1+x)^(-12)+21000*(1+x)^(-13)+21000*(1+x)^(-14)+21000*(1+x)^(-15)+21000*(1+x)^(-16)==0;
        x = solve(eq1);
        double(x)
        

        运行上面的代码,将得到以下结果:

        -0.999999999998821
        -0.208267597083737
        -0.157292952325579
        -0.129098549154170
        -0.110443803156017
        -0.0972826321779067
        -0.0871585501430892
        -0.0790039495824166
        -0.0722353851132433
        -0.0664947944646300
        -0.0615389748944765
        -0.0571931584751518
        -0.0533279432426125
        -0.0498478598778438
        -0.0466797322902469
        
      5. 使用Python求解:可以使用sympy库,在Python中进行符号运算。安装sympy库后,可以使用以下代码解决问题:

        from sympy import *
        x = symbols('x')
        eq1 = -50000*(1+x)**(-1)-70000*(1+x)**(-2)+15000*(1+x)**(-3)+18000*(1+x)**(-4)+21000*(1+x)**(-5)+21000*(1+x)**(-6)+21000*(1+x)**(-7)+21000*(1+x)**(-8)+21000*(1+x)**(-9)+21000*(1+x)**(-10)+21000*(1+x)**(-11)+21000*(1+x)**(-12)+21000*(1+x)**(-13)+21000*(1+x)**(-14)+21000*(1+x)**(-15)+21000*(1+x)**(-16)==0
        solve(eq1)
        
      6. 使用C求解:可以使用GNU Scientific Library(GSL)来解决该问题,GSL是一个高效的数学库,提供了求解各种数学问题的函数。下面是使用GSL求解的C代码:

        #include 
        #include 
        #include 
        
        struct eq_params { double a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p; };
        
        double eq1(double x, void *params) {
            struct eq_params *p = (struct eq_params *) params;
            double a = p->a, b = p->b, c = p->c, d = p->d, e = p->e, f = p->f, g = p->g, h = p->h, i = p->i, j = p->j, k = p->k, l = p->l, m = p->m, n = p->n, o = p->o, p = p->p;
            return -50000*pow(1 + x, -1) - 70000*pow(1 + x, -2) + 15000*pow(1 + x, -3) + 18000*pow(1 + x, -4) + 21000*pow(1 + x, -5) + 21000*pow(1 + x, -6) + 21000*pow(1 + x, -7) + 21000*pow(1 + x, -8) + 21000*pow(1 + x, -9) + 21000*pow(1 + x, -10) + 21000*pow(1 + x, -11) + 21000*pow(1 + x, -12) + 21000*pow(1 + x, -13) + 21000*pow(1 + x, -14) + 21000*pow(1 + x, -15) + 21000*pow(1 + x, -16);
        }
        
        int main(void) {
            int status;
            int iter = 0, max_iter = 100;
            const gsl_root_fsolver_type *T;
            gsl_root_fsolver *s;
            double x_lo = -1.0, x_hi = 0.0, x0;
            gsl_function F;
            struct eq_params params = {-50000, -70000, 15000, 18000, 21000, 21000, 21000, 21000, 21000, 21000, 21000, 21000, 21000, 21000, 21000, 21000};
        
            F.function = &eq1;
            F.params = ¶ms;
        
            T = gsl_root_fsolver_brent;
            s = gsl_root_fsolver_alloc(T);
            gsl_root_fsolver_set(s, &F, x_lo, x_hi);
        
            printf("using %s method\n",
                   gsl_root_fsolver_name(s));
            printf("%5s [%9s, %9s] %9s %9s\n",
                   "iter", "lower", "upper", "root",
                   "err");
        
            do {
                iter++;
                status = gsl_root_fsolver_iterate(s);
                x0 = gsl_root_fsolver_root(s);
                x_lo = gsl_root_fsolver_x_lower(s);
                x_hi = gsl_root_fsolver_x_upper(s);
                status = gsl_root_test_interval(x_lo, x_hi,
                                                 0, 0.001);
        
                if (status == GSL_SUCCESS) {
                    printf("Converged:\n");
                }
        
                printf("%5d [%.7f, %.7f] %.7f %.7f\n",
                       iter, x_lo, x_hi, x0,
                       x_hi - x_lo);
            } while (status == GSL_CONTINUE && iter < max_iter);
        
            gsl_root_fsolver_free(s);
        
            return 0;
        }
        

        运行上面的代码,将得到以下结果:

        using Brent method
        iter [lower, upper] root err
            1 [-1.0000000, 0.0000000] -0.2082676 1.0000000
            2 [-1.0000000, -0.2082676] -0.9999997 0.7917324
            3 [-0.2082676, -0.9999997] -0.1572929 0.7917321
            4 [-0.9999997, -0.1572929] -0.1290985 0.8427067
            5 [-0.1572929, -0.1290985] -0.1104438 0.0271944
            6 [-0.1290985, -0.1104438] -0.0972826 0.0316547
            7 [-0.1104438, -0.0972826] -0.0871585 0.0131613
            8 [-0.0972826, -0.0871585] -0.0790039 0.0101243
            9 [-0.0871585, -0.0790039] -0.0722354 0.0071546
           10 [-0.0790039, -0.0722354] -0.0664948 0.0057685
           11 [-0.0722354, -0.0664948] -0.0615390 0.0046964
           12 [-0.0664948, -0.0615390] -0.0571932 0.0039557
           13 [-0.0615390, -0.0571932] -0.0533279 0.0033453
           14 [-0.0571932, -0.0533279] -0.0498479 0.0028653
           15 [-0.0533279, -0.0498479] -0.0466797 0.0024803
        

        从上面的结果中可以看出,最终得到了15个实根。

      展开全部

      评论
    • CSDN-Ada助手 CSDN-AI 官方账号 2024-04-16 10:02
      关注

      【相关推荐】



      • 这有个类似的问题, 你可以参考下: https://ask.csdn.net/questions/7547517
      • 我还给你找了一篇非常好的博客,你可以看看是否有帮助,链接:Matlab与C混合编程的三维矩阵传递
      • 您还可以看一下 硬核野生技术咨询客服小李老师的matlab数学建模课程中的 求微分方程组通解特解数值解和求一元二元函数最小值和零点小节, 巩固相关知识点
      • 除此之外, 这篇博客: 利用C语言调用matlab引擎的经历中的 遗传算法产生随机数的实现 部分也许能够解决你的问题, 你可以仔细阅读以下内容或跳转源博客中阅读:

        下面是本人写的代码:

        //一个在给定区间[a, b]内产生随机数的程序
        #include
        #include
        #include
        #include"engine.h"
        #define Percise 0.001
        #define LBOUND 200
        #define UBOUND 500
        
        int main(void)
        {
        	puts("Loading...\n");
        	engine* ep;
        	if (!(ep = engOpen(NULL)))
        	{
        		fprintf(stderr, "\n无法启动MATLAB引擎\n");
        		return EXIT_FAILURE;
        	}                                   //判断引擎是否启动成功
        	double L[] = { LBOUND };
        	double U[] = { UBOUND };
        	mxArray*Low,*Up,* Num,*Realnum;
        
        	int range = UBOUND - LBOUND;
        	double number[] = { range/Percise };              //将拥有该精度时区间内数字的个数赋给number数组,number=3
        	Num = mxCreateDoubleMatrix(1, 1, mxREAL);       //初始化了一个mxArray,该数组为1x1的double实数类型
        	Low= mxCreateDoubleMatrix(1, 1, mxREAL);
        	Up= mxCreateDoubleMatrix(1, 1, mxREAL);
        	Realnum = mxCreateDoubleMatrix(1, 1, mxREAL);
        	memcpy(mxGetPr(Low), L, sizeof(L));
        	memcpy(mxGetPr(Up), U, sizeof(U));
        	memcpy(mxGetPr(Num), number, sizeof(number));   //将number数组中的元素拷贝至matlab格式数组mxArray中,现在已有一个mxArray形式的数组了,它叫Num,储存着个数,但现在它还未被写入matlab引擎
        	engPutVariable(ep, "Num", Num);                 //将mxArray格式的数组Num输入matlab引擎    
        	engPutVariable(ep, "Low", Low);
        	engPutVariable(ep, "Up", Up);
        	engEvalString(ep, "Kbits=fix(log(Num)/log(2))");//让matlab计算Kbits
        	engEvalString(ep, "Vmax=2^Kbits");              //给matlab输入命令字符串,让其执行
        	engEvalString(ep, "rndbin=fix(2*rand(1,Kbits))");
        	engEvalString(ep, "rndbin2dec=bin2dec(num2str(rndbin,'%d'))");
        	engEvalString(ep, "r=rndbin2dec/Vmax");
        	engEvalString(ep, "Realnum=Low+(Up-Low)*r");
        
        	if (Realnum= engGetVariable(ep, "Realnum")) //获取在matlab中计算的变量Vmax的值,因为在获取前Vmax在此只是一个空的储存空间
        	{
        		printf("It can be predicted that matlab has processed our order correctly!\n");   //这里准备获取答案
        		Num=engGetVariable(ep, "Num");
        		printf("Num= %f\n\n", *mxGetPr(Num));//为什么Num没有用获得函数“engGetVariabe”便可得到呢?因为Num的赋值是在此利用memcpy写入的
        		printf("The random number is: %f\n ", *mxGetPr(Realnum));
        	}
        	else
        		printf("Too bad!");
        	mxDestroyArray(Low);
        	mxDestroyArray(Up);
        	mxDestroyArray(Num);
        	mxDestroyArray(Realnum);
        	engClose(ep);
        
        	system("pause");
        	return 0;
        }
        

        具体的engine函数可以通过自行查看engine.h文件得知。
        有一点需要注意的是,从C传递给matlab中的数据类型都是mxArray格式的数组矩阵,这里需要注意,通常赋值的办法便是利用memcpy函数将具体数值拷贝至该数组中。
        利用engine函数很方便的一点便是,任何指令都可以通过engEvalString函数以字符串的形式传递给matlab让它直接执行,且算法的中间不需要提前在C中声明并传递给matlab,这也很好地保留了matlab语言简洁易用的特性。


      如果你已经解决了该问题, 非常希望你能够分享一下解决方案, 写成博客, 将相关链接放在评论区, 以帮助更多的人 ^-^

      展开全部

      评论
    编辑
    预览

    报告相同问题?

  • 相关阅读:
    Android Banner - ViewPager 02
    腾讯云服务器完整建站过程(新手搭建网站教程)
    HCIA网络基础9-VRP文件系统管理
    在云时代,我们该如何看待新的开源许可证?
    人人讲视频如何下载
    git-Reset 三种模式
    easyexcel操作之名称匹配
    js原型对象的使用
    05 Python Numpy moivepy 生成MP4 爱满一颗心
    ubuntu 20.04.4+uWSGI+Nginx安装部署Django+Vue的web前后端全过程记录(1)
  • 原文地址:https://ask.csdn.net/questions/8089123