精华内容
下载资源
问答
  • 并找到config-extensions.def以记事本打开,在最后加上clearwindow]enable=1enable_editor=0enable_shell=1clear-window=2.2基础数学运算基本的加减乘除、取余取整运算等,注意与matlab中^的不同,python中的为*...

    o55g08d9dv.jpg广告关闭

    腾讯云11.11云上盛惠 ,精选热门产品助力上云,云服务器首年88元起,买的越多返的越多,最高返5000元!

    零基础python教程032期 循环的嵌套使用,灵活运用循环语句零基础python教程033期 循环中的else语句,感叹人生苦短,我学python零基础python教程034期random随机数开发猜数字游戏零基础python教程035期exec和eval字符串转python执行妙用零基础python教程036期 如何判断偶数? 零基础python教程037期 四种数字三角形...

    基本的加减乘除python可以直接运算数字,也可以加print进行运算. 1+12>>> 2-11>>> 2*36>>> 431.3333333333333333^ 与 **python当中^符号,区别于matlab,在python中,^用两个**表示,如3的平方为3**2,**3表示立方,**4表示4次方,依次类推>>> 3**2 # **2 表示2次方9>>> 3**3 # **3 表示3次方27>>> 3**481取余数...

    python概述简介 python是一种解释性,面向对象,动态数据类型的高级程序语言, 解释型,无编译过程,逐行解释为二进制 交互性,直接执行程序 应用广泛, 编译型...只有加减乘除 从左到右先找到第一个乘除法 —— 重复# 所有的乘除法都做完了#计算加减 —— 加减法# 只有一个数了 就可以结束了collection# collections...

    功能说明:使用python编写一个计算器,实现简单的加减乘除功能。 程序的逻辑很简单,取出括号,计算里面的乘除加减,结果替换原括号内容,再循环直到最终结果。 难点在于正则匹配字符和计算细节上,怎么很好协调配合并正确获得结果。 逻辑图:? 程序目录:main.py ###程序入口checkstr.py ###字符检测checkbrackets...

    笔记内容:运算符笔记日期:2017-10-21----运算符python支持以下类型的运算符:算术运算符比较(关系)运算符赋值运算符逻辑运算符位运算符成员运算符身份运算符运算符优先级1. 算术运算符算术运算符也就是加减乘除取余之类的. 以下使用实际代码演示python所有算术运算符的使用方式:1.a=212.b=103.c=04.5.c=a+b6...

    desktopworkspacepythonworkspacemachine-learningasstescsv2019_student_teacher.csvstudent_teacher = pandas.read_csv(path,encoding=gbk)#print(type(student_teacher)) # panda.core.frame.dataframe就像numpy中的numpy.array序号 int64准考证号 int64姓名 object报考专业代码int64报考专业 object研究方向 ...

    只有两个值:真、假 true false 除了各种数据类型,python语言还用类型来表示函数、模块、类型本身、对象的方法、编译后的python代码、运行时信息等等。 因此,python具备很强的动态性。 1.2. 6 运算符计算机可以进行的运算有很多种,可不只加减乘除这么简单,运算按种类可分为算数运算、比较运算、逻辑运算、赋值...

    一.算术运算符? 简称加减乘除,直接上代码:a = 10b = 20c = 30 # 其实上面三行代码使用一行就能完成# a,b,c = 10,20,30 # 经典写法print(a - b = ,(a - b))print(a - c = %d % (a - c))print(a - b + c = {}.format(a-b+c))输出结果:a - b = -10a - c = -20a - b + c = 20注意:如果关于print函数和format函数的...

    qh77pkorr5.png

    (1)ctrl+f6是restart(2)下载或右击另存为clearwindow.py,保存在python xlibidlelib目录下,并找到config-extensions.def以记事本打开,在最后加上clearwindow]enable=1enable_editor=0enable_shell=1clear-window=2.2基础数学运算基本的加减乘除、取余取整运算等,注意与matlab中幂^的不同,python中的幂为**2.3...

    python内置了一系列的常用函数,以便于我们使用python。 基本的数据操作基本都是一些数学运算(当然除了加减乘除)、逻辑操作、集合操作、基本io操作,然后就是对于语言自身的反射操作,还有就是字符串操作。 官方文档: https:docs.python.org3libraryfunctions.html? highlight=built#ascii 截图如下:? 简单做一下...

    常用表达式1、简单加减乘除: >>> a=4>>> b=5>>> a+b,a-b(9, -1)>>> a*3,b2(12, 2.5)>>> a%3,b**2(1, 25)>>> a>> a>bfalse>>> a==bfalse常用表达式二、除法:真除法、floor除法xy:在python3.0中是真除法,无论任何类型都会保留小数部分。 515.0>>> 933.0xy:截掉余数并针对数字类型保留类型 >>> 53 1>>> 924>>> 5. ...

    igt4pip78s.gif

    为了讲解关于模块的调用方法,假如我们有一个计算加减乘除的模块文件calculator.py,代码如下:# ! usrbinenv python# -*- coding:utf-8 _*-@author:何以解忧@blog(个人博客地址):shuopython.com@wechat official account(微信公众号):猿说python@github:www.github.com @file:calculator.py@time:20191011 21:25 @...

    还是要强调一下python的变量和数据类型的关系,变量只是对某个对象的引用或者说代号、名字、调用等等,变量本身没有数据类型的概念 。 只有1,hello这一类对象才具有数据类型的概念。 python 支持三种不同的数字类型,整数、浮点数和复数。 整数通常被称为整型,数值为正或者负,不带小数点。 python 3的整型可以当做...

    本篇将介绍python的函数式编程,介绍高阶函数的原理函数式编程函数是python内建支持的一种封装,我们通过把大段代码拆成函数,通过一层一层的函数调用,就可以把复杂任务分解成简单的任务,这种分解可以称之为面向过程的程序设计。 函数就是面向过程的程序设计的基本单元。 而函数式编程(请注意多了一个“式”字)—...

    一、python介绍介绍 python的创始人为吉多·范罗苏姆(guido van rossum)。 1989年的圣诞节期间,guido开始写能够解释python语言语法的解释器。 python这个名字,来自guido所挚爱的电视剧monty python’s flying circus。 他希望这个新的叫做python的语言,能符合他的理想:创造一种c和shell之间,功能全面,易学...

    1 python中的保留字保留字也叫做关键字,不能把它们用在任何标识符名称,可以使用以下命令来查看python的保留字1 import keyword2 print(keyword.kwlist)2普通数据类型int、float、complex 1 # int为整数类型,可以将浮点型强制转化成整形 2 a = 10.0 3 print(type(a)) 4 a = int(a) 5print(type(a)) 6 7 # float为...

    f6lytwmdx9.png

    外层变量,可以被内层变量使用 内层变量,无法被外层变量使用 二、三元运算result=值1if条件else值2如果条件为真:result = 值1如果条件为假:result = 值2三、进制二进制,01八进制,01234567十进制,0123456789十六进制,0123456789abcdefpython基础对于python,一切事物都是对象,对象基于类创建? 所以,以下这些...

    总第272篇原创1 两个时间模块python与时间相关的内置模块有:time 和 datetime. 其中,time模块提供各种操作时间的函数,datetime模块定义了如下几个类型:datetime.date:日期类,常用的属性有 year,month, day; datetime.time:时间类,常用的属性有 hour, minute, second, microsecond; datetime.datetime:日期...

    python编程其实就是在处理各种各样的数据,有数字(0,1,2,3),字符(a,b,frog,你好;)还有逻辑true和false等等。 1.python基本元素:数字有了数字类型,python就可以进行各种数据运算(加减乘除以及高级运算)>>>print(123)>>>123print(1+2)>>>3print(3*5)>>>152.python基本元素字符和字符串以及引号有了字符和...

    gbs0o8csew.jpeg

    介绍完这些背景知识后,现在可以聊聊python3.9 里面的合并操作符号了。 合并操作符很简单,跟加减乘除类似 >>> d1 = {a: 1, b: 2}>>> d2 = {c: 3, d:4}>>> d1 | d2{a: 1, b: 2, c: 3, d: 4}>>> d2 | d1{c: 3, d: 4, a: 1, b: 2,| 操作符就是字典合并操作符,而且合并的字典是有序的。 合并操作符返回的是一个新的字典...

    展开全文
  • 大数(超过计算机最大处理类型位数)的、乘、除、等的MATLAB计算方法。 最近需要做大数计算,且要求结果精度与原始数据一致(不能使用科学计数等近似解)。所以总结分享一些“超大正整数的基本运算方法”,...

    by HPC_ZY

    最近需要做大数计算,且要求结果精度与原始数据一致(不能使用科学计数等近似解)。所以总结分享一些“超大正整数的基本运算方法”,如加、减、乘、除、幂等

    一、基本原理

    uint32(unsigned int)型可表示的最大数为(2321)(2^{32}-1),uint64(unsigned long long)型可表示的最大数为(2641)(2^{64}-1),超过这样的数就没法直接计算了。
    但是我们知道加减乘除的本质还是按位计算,所以我们可以将大数拆分为多个小位数。
    根据这个原理最合适的就是使用字符串的形式,这样就将上限从最大数据类型变成了计算机最大内存
    下面我们就来研究字符串格式的加减乘除,首先分享MATLAB中的实现方法,然后改写成C。

    注:本文仅研究正整数,暂不涉及负数与小数

    二、MATLAB简单实现

    1. 加(+)

    任意大数相加,主要原理:
    1)按位相加
    2)满十进一

    %% 大数加(输入为字符串格式)
    function out = OLNadd(a,b)
    
    % 转数字矩阵(为了逻辑方便,我们将数字反序)
    mata = a(end:-1:1)-'0';
    matb = b(end:-1:1)-'0';
    
    % 计算位数
    la = length(a);
    lb = length(b);
    
    % 初始化
    if la>=lb
        digitStart = lb;
        matout = [mata,0];
        mattmp = matb;
    else
        digitStart = la;
        matout = [matb,0];
        mattmp = mata;
    end
    
    % 循环求解
    for k = digitStart:-1:1
        % 位求和,满十进一
        tmp = matout(k)+mattmp(k);
        if tmp<10
            matout(k) = tmp;
        else
            matout(k) = tmp-10;
            matout(k+1) = matout(k+1)+1;
        end
    end
    
    % 转字符
    out = char(matout(end:-1:1)+'0');
    if out(1) == '0'
        out(1) = [];
    end
    
    end
    

    2. 减(-)

    任意大数相减,主要原理:
    1)比较大小,以大减小
    2)符号由大小关系决定
    3)按位相减
    4)不够向前借位

    %% 大数减(输入为字符串格式)
    function out = OLNsub(a,b)
    
    % 转数字矩阵(为了逻辑方便,我们将数字反序)
    mata = a(end:-1:1)-'0';
    matb = b(end:-1:1)-'0';
    
    % 计算位数
    la = length(a);
    lb = length(b);
    
    % 初始化
    isEqual = 0;
    if la>lb % 默认用大的减小的(正负号由大小关系决定)
        digitEnd = lb;
        matout = [mata,0];
        mattmp = matb;
        flag = 1; % 结果为正
    elseif la<lb
        digitEnd = la;
        matout = [matb,0];
        mattmp = mata;
        flag = 0;   % 结果为负
    else
        % 对比第一个不相等的位数,谁大谁小
        idx = find(a~=b,1);
        if ~isempty(idx)
            if a(idx)>b(idx)
                digitEnd = lb;
                matout = [mata,0];
                mattmp = matb;
                flag = 1; % 结果为正
            else
                digitEnd = la;
                matout = [matb,0];
                mattmp = mata;
                flag = 0;   % 结果为负
            end
        else % 如果为空,说明两个数完全一致
            isEqual = 1;
        end
    end
    
    if ~isEqual 
        % 循环求解
        for k = 1:digitEnd
            % 位求差,不足借一
            if matout(k)>=mattmp(k)
                matout(k) = matout(k)-mattmp(k);
            else
                matout(k) = 10+matout(k)-mattmp(k);
                borrow = 1;
                while 1 % 不够减时往前借,直到借到为止。
                    if matout(k+borrow)>=1 % 够借ok
                        matout(k+borrow) = matout(k+borrow)-1;
                        break
                    else % 不够,再往前
                        matout(k+borrow) = 10+matout(k+borrow)-1;
                        borrow = borrow+1;
                    end
                end
            end
        end
        % 转字符
        out = char(matout(end:-1:1)+'0');
        while out(1)=='0'      
                out(1) = [];
        end
        if ~flag
            out = ['-',out];
        end
    else
        out = '0';
    end
    
    end
    

    3. 乘(*)

    任意大数相乘,主要原理:
    1)按位求积
    2)结果累加

    %% 大数乘(输入为字符串格式)
    function out = OLNmult(a,b)
    
    % 转数字矩阵(为了逻辑方便,我们将数字反序)
    mata = a(end:-1:1)-'0';
    matb = b(end:-1:1)-'0';
    
    % 计算位数
    la = length(a);
    lb = length(b);
    
    % 初始化
    matout = zeros(1,la+lb);
    
    % 循环求解
    for i = 1:la
        if mata(i)==0
            continue
        end
        for j = 1:lb
            if matb(j)==0
                continue
            end       
            % 位求积,分高低位
            valtmp = mata(i)*matb(j);
            valup = floor(valtmp/10);
            vallow = valtmp-valup*10;
            % 低位求和
            idx = i+j-1;
            val = matout(idx)+vallow;
            if val<10
                matout(idx) = val;
            else
                matout(idx) = val-10;
                matout(idx+1) = matout(idx+1)+1;
            end
            % 求高位
            idx = i+j;
            val = matout(idx)+valup;
            if val<10
                matout(idx) = val;
            else
                matout(idx) = val-10;
                matout(idx+1) = matout(idx+1)+1;
            end
        end
    end
    
    % 转字符
    out = char(matout(end:-1:1)+'0');
    while out(1)=='0'
        out(1) = [];
    end
    
    if ~flag
        out = ['-',out];
    end
    
    end
    

    4. 除(/)

    被除数任意大,除数<99999999<99999999
    (原因是在除法中,被除数符合分配律,除数不符合。对于超过类型允许的除数,我不知道怎么处理。所以采取的思路是将被除数拆分为类型允许的大小,即<2321=4294967295<2^{32}-1 = 4294967295(十位数),拆分的被除数最大只能为999999999999999999(九位数),进而得到除数最多为9999999999999999(八位数),主要原理:
    1)按位求商,不足移位(即用最高位/除数,不够除则用最高两位,还不够用最高三位,以此类推)
    2)高位余数,加至低位

    %% 大数除(输入为字符串格式)
    function [out,remainder] = OLNdiv(a,b)
    
    % 转数字矩阵(为了逻辑方便,我们将数字反序)
    mata = a(end:-1:1)-'0';
    matb = b(end:-1:1)-'0';
    
    % 计算位数
    la = length(a);
    lb = length(b);
    
    % 转数字(按四位分组)
    numa = mata(end:-1:1);
    numb = 0;
    for k = 1:lb
        numb = numb+matb(k)*10^(k-1);
    end
    
    % 分组除保存结果
    res = zeros(1,la); %
    remainder = 0; % 每次计算的余数
    for i = 1:la
        divisor = numa(i)+remainder*10; % 被除数 = 上一组的余数*10000+这一组
        remainder = rem(divisor,numb);
        res(i) = (divisor-remainder)/numb; 
    end
    
    % 转字符
    remainder = num2str(remainder);
    out = char(res+'0');
    while out(1)=='0'
        out(1) = [];
    end
    if ~flag
        out = ['-',out];
    end
    
    end
    

    5. 幂(^)

    底数指数任意大。主要原理:
    1)循环大数乘

    %% 大数幂(输入为字符串格式)
    function out = OLNpow(a,b)
    
    % 转数字矩阵(为了逻辑方便,我们将数字反序)
    matb = b(end:-1:1)-'0';
    
    % 计算位数
    lb = length(matb);
    
    % 初始化
    n = -1;
    for k = 1:lb
    n = n+matb(k)*10^(k-1);
    end
    % 循环乘(直接利用大数乘法,偷下懒)
    tmp = a;
    for k = 1:n 
       tmp = OLNmult(tmp,a);
    end
    out = tmp;
    
    end
    

    三、测试

    1. 准确性测试
      首先测试各个算法结果是否正确,我们用int64能支持的数字进行,如下
    %% 加
    ca = '68924355';
    cb = '411533';
    
    cc = OLNadd(ca,cb); % 字符计算
    nc = str2double(ca)+str2double(cb); % 数字计算
    
    disp('加:')
    disp([ca,' + ', cb,' = ',cc])
    disp(['标准答案 = ',num2str(nc)])
    disp(' ')
    
    
    %%% 基本测试
    ca = '985355';
    cb = '411533';
    
    cc = OLNsub(ca,cb); % 字符计算
    nc = str2double(ca)-str2double(cb); % 数字计算
    
    disp('减-基本测试:');
    disp([ca,' - ', cb,' = ',cc])
    disp(['标准答案 = ',num2str(nc)])
    disp(' ')
    
    % 小减大测试
    ca = '85355';
    cb = '411533';
    
    cc = OLNsub(ca,cb); % 字符计算
    nc = str2double(ca)-str2double(cb); % 数字计算
    
    disp('减-小减大测试:')
    disp([ca,' - ', cb,' = ',cc])
    disp(['标准答案 = ',num2str(nc)])
    disp(' ')
    
    % 借位测试
    ca = '100000';
    cb = '1';
    
    cc = OLNsub(ca,cb); % 字符计算
    nc = str2double(ca)-str2double(cb); % 数字计算
    
    disp('减-借位测试:')
    disp([ca,' - ', cb,' = ',cc])
    disp(['标准答案 = ',num2str(nc)])
    disp(' ')
    
    
    %% 乘
    ca = '996655';
    cb = '872233';
    
    cc = OLNmult(ca,cb); % 字符计算
    nc = str2double(ca)*str2double(cb); % 数字计算
    
    disp('乘:')
    disp([ca,' * ', cb,' = ',cc])
    disp(['标准答案 = ',num2str(nc)])
    disp(' ')
    
    
    %%% 整除测试
    ca = '869315380615';
    cb = '872233';
    
    [cc,cr] = OLNdiv(ca,cb); % 字符计算
    nr = rem(str2double(ca),str2double(cb)); % 余数计算
    nc = (str2double(ca)-nr)/str2double(cb); % 数字计算
    
    disp('除-整除测试:')
    disp([ca,' / ', cb,' = ', cc,' 余 ',cr])
    disp(['标准答案 = ',num2str(nc),' 余 ',num2str(nr)])
    disp(' ')
    
    % 非整除测试
    ca = '88772211996655';
    cb = '872233';
    
    [cc,cr] = OLNdiv(ca,cb); % 字符计算
    nr = rem(str2double(ca),str2double(cb)); % 余数计算
    nc = (str2double(ca)-nr)/str2double(cb); % 数字计算
    
    disp('除-非整除测试:')
    disp([ca,' / ', cb,' = ', cc,' 余 ',cr])
    disp(['标准答案 = ',num2str(nc),' 余 ',num2str(nr)])
    disp(' ')
    
    %% 幂
    ca = '16';
    cb = '11';
    
    cc = OLNpow(ca,cb); % 字符计算
    nc = str2double(ca)^str2double(cb); % 数字计算
    
    disp('幂:')
    disp([ca,' ^ ', cb,' = ',cc])
    disp(['标准答案 = ',num2str(nc)])
    disp(' ')
    
    

    结果如下,完全一致,接下来可以放心测试大数

    在这里插入图片描述


    1. 大数测试
      使用超大数字进行测试
    %% 加
    ca = '22368936111988924355';
    cb = '118897773322411533';
    
    cc = OLNadd(ca,cb); % 字符计算
    
    disp('加:')
    disp([ca,' + ', cb]),disp([' = ',cc])
    disp(' ')
    
    
    %% 减
    ca = '22368936111988924355';
    cb = '118897773322411533';
    
    cc = OLNsub(ca,cb); % 字符计算
    
    disp('减:');
    disp([ca,' - ', cb]),disp([' = ',cc])
    disp(' ')
    
    
    %% 乘
    ca = '789123996655';
    cb = '432987872233';
    
    cc = OLNmult(ca,cb); % 字符计算
    
    disp('乘:')
    disp([ca,' * ', cb]),disp([' = ',cc])
    disp(' ')
    
    
    %% 除
    ca = '12345678988772211996655';
    cb = '32872233';
    
    [cc,cr] = OLNdiv(ca,cb); % 字符计算
    
    disp('除')
    disp([ca,' / ', cb]),disp([' = ',cc,' 余 ',cr])
    disp(' ')
    
    
    %% 幂
    ca = '541';
    cb = '25';
    
    cc = OLNpow(ca,cb); % 字符计算
    
    disp('幂:')
    disp([ca,' ^ ', cb]),disp([' = ',cc])
    disp(' ')
    

    结果如下
    在这里插入图片描述


    四、关于优化

    1. 为了理解方便所以函数写法有累赘的地方,自己使用时可合理优化。
    2. 有大佬提出,加减乘除可以在二进制计算中完成。
    3. 关于幂运算中,指数太大计算时间会爆表,可以改写为快速幂方法。
    4. 我没有加入判断语句,即使输入的不是数字还是会计算,可以加上。
    5. 可以对输入加上符号,这样就能进行负数计算。
    6. 关于小数计算,加减乘很简单,只要判断小数点位置即可。除法则需要在此基础上加上计算精度(小数后保留几位)。关于幂,底数为小数类似乘法,但指数为小数就要配合开方。

    五、其他

    1、该方法的C实现可看另一篇文章《C/C++大数的加减乘除幂运算》。撰写中……
    2、函数与测试代码文中已全部公开,如果嫌懒得复制且已开通会员,可以在这里下载demo

    展开全文
  • Python/Numpy之加减乘除开方平方值三角函数等算数运算 import numpy as np a = np.array([1,2,3]) b = np.array([2,3,4]) 加法: add1 = a + b add2 = np.add(a,b) 减法: sub1 = a - b sub2 = np.subtract(a,b...

    Python/Numpy之加减乘除开方平方幂值三角函数等算数运算

    import numpy as np
    a = np.array([1,2,3])
    b = np.array([2,3,4])

    1. 加法:
      add1 = a + b
      add2 = np.add(a,b)
    2. 减法:
      sub1 = a - b
      sub2 = np.subtract(a,b)
    3. 乘法:
      mul1 = a * b
      mul2 = np.multiply(a,b)
    4. 除法:
      div1 = a / b
      div2 = np.divide(a,b)
    5. 幂指运算开方、平方、指数、对数:
      sqrtx = np.sqrt(a) # 开方
      powerx = np.power(a,2) # 平方
      expx = np.exp(a)
      logx = np.log(a)
    6. 三角函数:
      sinx = np.sin(a)
      cosx = np.cos(a)
    >>> import numpy as np
    >>> a = np.array([1,2,3])
    >>> b = np.array([2,3,4])
    # 减法运算
    >>> sub1 = a - b
    >>> sub1
    array([-1, -1, -1])
    >>> sub2 = np.subtract(a,b)
    >>> sub2
    array([-1, -1, -1])
    # 加法运算
    >>> add1 = a + b
    >>> add1
    array([3, 5, 7])
    >>> add2 = np.add(a,b)
    >>> add2
    array([3, 5, 7])
    # 除法运算
    >>> div1 = a / b
    >>> div1
    array([0.5       , 0.66666667, 0.75      ])
    >>> div2 = np.divide(a,b)
    >>> div2
    array([0.5       , 0.66666667, 0.75      ])
    # 乘法运算
    >>> mul1 = a * b
    >>> mul1
    array([ 2,  6, 12])
    >>> mul2 = np.multiply(a,b)
    >>> mul2
    array([ 2,  6, 12])
    # 三角函数
    >>> sinx = np.sin(a)
    >>> sinx
    array([0.84147098, 0.90929743, 0.14112001])
    >>> cosx = np.cos(a)
    >>> cosx
    array([ 0.54030231, -0.41614684, -0.9899925 ])
    >>> tanx = np.tan(a)
    >>> tanx
    array([ 1.55740772, -2.18503986, -0.14254654])
    # 幂指数运算
    >>> expx = np.exp(a)
    >>> expx
    array([ 2.71828183,  7.3890561 , 20.08553692])
    >>> logx = np.log(a)
    >>> logx
    array([0.        , 0.69314718, 1.09861229])
    # 开方运算
    >>> sqrtx = np.sqrt(a)
    >>> sqrtx
    array([1.        , 1.41421356, 1.73205081])
    # 平方运算
    >>> powerx = np.power(a,2)
    >>> powerx
    array([1, 4, 9], dtype=int32)
    

    三角函数采用的是弧度制,如np.sin(np.pi/2)=1
    更多Python数据科学相关见专题Python数据科学技能索引

    展开全文
  • 利用栈实现加减乘除幂功能

    千次阅读 2016-04-09 14:59:10
    如何用栈来实现加减乘除幂的运算呢?应考虑下面几点。 1.分别用一个栈x存符号,另一个栈y存数值。 2.遇到数字就压栈,遇到符号ch要比较栈顶的符号与当前的符号ch,编写一个判别函数prev,若能进行运算,则返回真,...

    如何用栈来实现加减乘除幂的运算呢?应考虑下面几点。

    1.分别用一个栈x存符号,另一个栈y存数值。

    2.遇到数字就压栈,遇到符号ch要比较栈顶的符号与当前的符号ch,编写一个判别函数prev,若能进行运算,则返回真,不能返回假.以下是判别函数的几种情况:

    (1)如果栈顶符号为* ^ / 则不用考虑输入拿来比较的符号,直接返回真。

    (2)如果栈顶符号和拿来比较的符号ch为+或者-,也返回真.

    (3)其他遇到栈顶元素为括号或者栈顶符号为+or-,而ch为* / ^等等情况,直接返回假。

    代码如下:

     

    bool prev(char s1,char s2 ){                    //判断符号s1 与 s2 的优先级别的函数
        if(s1=='^'||s1=='*'||s1=='/')                 //如果栈顶符号为* ^ / 则不用考虑输入拿来比较的符号,直接返回真
            return true;
        else if((s1=='+'||s1=='-')&&(s2=='+'||s2=='-'))      //如果栈顶符号和拿来比较的符号为+或者-,也返回真
            return true;
            else
            return false;                                  //其他情况都返回假
        }

    3.编写计算函数result,并将计算结果压入栈中,注意计算的是当前输入符号ch前面的符号,计算完后要将当前符号ch压入符号栈内。

     

     

    void result(char ch,SeqStack<T> &s)                 //计算并将计算结果压入栈中
    {
        T x,y,result;
        x=s.Pop();
        y=s.Pop();
        switch(ch)
        {
            case '+':result=y+x;break;
            case '-':result=y-x;break;
            case '*':result=y*x;break;
            case '/':result=y/x;break;
            case '^':result=pow(y,x);break;
        }
        s.Push(result);
        return ;
    }


    具体代码如下:

     

     

    #include <iostream>
    #include <cstring>
    #include <cmath>
    #include <cstdio>
    #include <cstdlib>
    #include <assert.h>
    #define Max 100
    using namespace std;
    bool prev(char s1,char s2 ){                    //判断符号s1 与 s2 的优先级别的函数
        if(s1=='^'||s1=='*'||s1=='/')                 //如果栈顶符号为* ^ / 则不用考虑输入拿来比较的符号,直接返回真
            return true;
        else if((s1=='+'||s1=='-')&&(s2=='+'||s2=='-'))//如果栈顶符号和拿来比较的符号为+或者-,也返回真
            return true;
            else
            return false;                                  //其他情况都返回假
        }
    
    template <class T>
    class SeqStack
    {
    public:
        SeqStack():top(-1){}
        ~SeqStack(){top=-1;}
        T Pop();
        T getTop();
        void Push(T x);
        bool IsEmpty();
        bool IsFull();
    private:
        T A[Max];
        int top;
    };
    template <class T>
    void result(char ch,SeqStack<T> &s)                 //计算并将计算结果压入栈中
    {
        T x,y,result;
        x=s.Pop();
        y=s.Pop();
        switch(ch)
        {
            case '+':result=y+x;break;
            case '-':result=y-x;break;
            case '*':result=y*x;break;
            case '/':result=y/x;break;
            case '^':result=pow(y,x);break;
        }
        s.Push(result);
        return ;
    }
    int main()
    {
        SeqStack<char> x;                                           //符号栈
        SeqStack<double> y;                                       //数值栈
        char ch,c;
        double operand;
        x.Push('0');
        while(1)
        {
            cin.get(ch);
            if(ch=='+'||ch=='-'||ch=='*'||ch=='/')  //若是+-*/则要与符号栈栈顶元素比较,决定是否运算
            {
                c=x.getTop();             //c保存当前栈顶值
               while(prev(c,ch))         //符号比较返回真,则要计算,循环直到栈内能计算的符号全部计算
                {
                    result(c,y);            //注意计算时使用的是符号栈中栈顶符号
                    x.Pop();                //弹出刚刚计算过的符号c
                    c=x.getTop();           //c保存当前符号栈栈顶的元素进行循环
                }
                x.Push(ch);                  //计算结束压入刚刚输入的符号
            }
            else if(ch=='^'||ch=='(')        //遇到符号^或者(直接压栈,不用考虑比较符号和计算
                x.Push(ch);
            else if(ch==')')                 //遇到右括号,要对栈中元素进行循环计算,直到遇到左括号(
            {
                c=x.getTop();
                while(c!='(')                //此时的循环条件不是判断符号,遇到符号就要计算,因为括号里前面的元素,已经按优先级计算好
                {
                    result(c,y);
                    x.Pop();
                    c=x.getTop();
                }
                x.Pop();                        //弹出(符号
            }
            else if(isdigit(ch))                //是数字,放回输入流,重新输入数字,压栈
            {
                cin.putback(ch);
                cin>>operand;
                y.Push(operand);
    
            }
            else if(ch=='\n')                  //遇到回车符,计算栈中仍未计算的数字,跳出循环
            {
                c=x.getTop();
                while(c!='0')
                {
                    result(c,y);
                    x.Pop();
                    c=x.getTop();
                }
                cout<<y.Pop()<<endl;break;
            }
        }
    
        return 0;
    }
    template <class T>
    T SeqStack<T>::Pop()
    {
        assert(top!=-1);
        T x;
        x=A[top];
        top--;
        return x;
    }
    template <class T>
    void SeqStack<T>::Push(T x)
    {
        assert(top!=Max-1);
        top++;
        A[top]=x;
        return ;
    }
    template <class T>
    T SeqStack<T>::getTop()
    {
        assert(top!=-1);
        return A[top];
    }
    template <class T>
    bool SeqStack<T>::IsEmpty()
    {
        if(top==-1) return true;
        else return false ;
    }
    template <class T>
    bool SeqStack<T>::IsFull()
    {
        if(top==Max-1)return true;
        else return false;
    }

     

     

     

     

     



     

    展开全文
  • 加减乘除,平方,立方,开方,三角函数。但这只是我的作业,仅仅只能看看哦,希望有所启发哦~~~
  • c#自己做的一个简单计算器,可以实现加减乘除混合运算,但运算中不能有负数,仅供参考!大神勿喷!
  • 本文详细介绍了OpenCV-Python图像的加减乘除幂开方对数及位运算相关的函数及语法,并总结了相关函数的作用。OpenCV中图像存储为矩阵,因此图像的运算其实就是矩阵的运算。图像的运算主要包括图像基础算术运算、图像...
  • 运用mfc制作的科学计算器,具有基本加减乘除运算以及三角函数运算等
  • BigDecimal加减乘除计算

    2020-10-10 14:49:05
    对Bigdecimal类型值进行加减乘除绝对值的运算,其实就是Bigdecimal的类方法的一些调用。 加法:add()函数 减法:subtract()函数 乘法:multiply()函数 除法:divide()函数 绝对值:abs()函数 public static void ...
  • java.math.BigDecimal BigDecimal 在做运算的时候不能直接运算,得调用方法,以下简介: 是不可变的、任意精度的有...其值为该数的非标度值乘以10的负scale次,即为(unscaledValue * 10-scale)。 常用方法: ...
  • 学习JavaScripts第二站:JavaScript编程中的加减乘除 文章目录学习JavaScripts第二站:JavaScript编程中的加减乘除js运算顺序 学而时习之,不亦乐乎。 既然我们要运用javascript来操纵不同的数据,那么运算就是无论...
  • 计算器应该能够完成由、乘、除运算符构成的复合算术表达式的求解,允许使用括号 计算器能够完成运算和阶乘运算,其中,运算可以采用M^N的方式输入 提前说明: 该程序由一个类实现,可通过调用solve方法...
  • using System; using System.Collections.Generic; using System.ComponentModel; using System.Data; using System.Drawing; using System.Linq; using System.Text;...using System.Threading.Task...
  • #include<stdio.h> int f(int a,int b) { return a+b; } int g(int a,int b) { return a-b; } int x(int a,int b) { return a*b; } int y(int a,int b) { return a/b; } ...a,
  • 其中比较特殊的地方是实现了单元函数的计算(新引入了一个栈来存储函数,然后在右括号的结算后push进目标栈) #include <stdio.h> #include "genlib.h" #include "simpio.h" #include "strlib.h" #include ...
  • 信息安全原理 作业3  HW2. Large number arithmetic Write a +-*/ algorithm for large integers. (10 point)Implement the DH algorithm. (5 point) 继承上个版本的,目前最新版,暂无...// author: amrz
  • ‍数学里面的加减乘除,就是运算符,但是 Python 的运算符更多样,更复杂,分为算术运算符、比较运算符、赋值运算符、位运算符、逻辑运算符、成员运算符、身份运算符。为了更直观的看到运算符...
  • 第二天学Python:加减乘除取余乘幂

    千次阅读 2020-04-18 13:30:23
    加减乘除取余乘幂 ...
  • 不用加减乘除做加法

    2018-03-23 10:31:00
    分析:两个数相加不让用加减乘除,那肯定就是位运算了啊,用位运算模拟加法挺简单的,如果有快速的基础的话很容易能想到,按位异或然后按位与左移一位,直到按位与为0,在草稿纸上稍微画一下就能理解。不过我还是...
  • 本人在学习C++面向对象编程时的练习... //框架:构造出来两个复数,利用运算符重载输出加减乘除 // 利用虚函数继承计算传入的实数和复数的运算 Complex cr3 = c1 + c2; cout ; system("pause"); return 0; }
  • 为简单起见,我们这里假设只涉及加减乘除和小括号,并且操作数都是正整数,不涉及更加复杂的数据或运算。 计算思路: 使用两个栈,stack0用于存储操作数,stack1用于存储操作符 从左往右扫描,遇到操作数入栈stack0 ...
  • 高精度 大数 加减乘除问题
  • 有加减的是群,有加减乘的是环,有加减乘除的是域。域一定是环,环一定是群。 举个简单的例子,整数集是环但不是域,有理数集是域。 再举个复杂点的例子,形如ax+b的整系数多项式构成的集合,是群但不是环。 ...
  • 常用加减乘除等方法汇总直接上代码,逻辑简单,代码如下:&lt;!DOCTYPE html&gt; &lt;html lang="en"&gt; &lt;head&gt; &lt;meta charset="UTF-8"&gt; &...
  • 给一个例题吧:求卡特兰数 ...主要要学会使用模板中的各种运算函数。有注释,其实就是一个模拟的过程,大家自己看,应该比较易懂(感谢 kuangbin 大神) #include <iostream> #include <cstdio> #includ...
  • // // main.c // Function_pointer // // Created by mac on 15/8/2. ...// 要求:通过函数指针求两个整数的和、差、积、商。 ...//知识点:函数指针就是一个指向函数的指针,通过指针指向要调用的函...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,473
精华内容 1,789
关键字:

幂函数加减乘除