`
weixuanfeng
  • 浏览: 7834 次
  • 性别: Icon_minigender_1
  • 来自: 深圳
最近访客 更多访客>>
bigyean
文章分类
社区版块
存档分类

看看，输入19²为什么得不到预期结果，9^3就可以，这是计算器的代码，别改乱了，关键处理²次方

FP算法CC++C# 
阅读更多
/*
* 文 件 名:  Calc.java
* 描    述:  <描述>
* 修 改 人:  韦旋枫 CEA00260
* 修改时间:  2011-5-12
* 修改内容:  <修改内容>
*/
package com.xuanfeng.test;

import java.text.DecimalFormat;
import java.util.StringTokenizer;

/**
* <一句话功能简述> <功能详细描述>
*
* @author 姓名 工号
* @version [版本号, 2011-5-12]
* @see [相关类/方法]
* @since [产品/模块版本]
*/
public class Calc
{
    static Calc calc = new Calc();
   
    public static void main(String[] args)
    {
//        calc.process("9^3+9-sin60");
         calc.process("19²");
    }
   
    /*
     * 整个计算核心，只要将表达式的整个字符串传入calc().process()就可以实行计算了 算法包括以下几部分： 1、计算部分 process(String str) 当然，这是建立在查错无错误的情况下 2、数据格式化
     * FP(double n) 使数据有相当的精确度 3、阶乘算法 N(double n) 计算n!，将结果返回 4、错误提示 showError(int code ,String str) 将错误返回
     */
    public Calc()
    {
       
    }
   
    // 保存原来的算式样子，为了输出时好看，因计算时，算式样子被改变
    public String str_old;
   
    // 控制DRG按键，true为角度，false为弧度
    public boolean drg_flag = true;
   
    // π 3.14
    public double pi = Math.PI;
   
    final int MAXLEN = 500;
   
    /*
     * 计算表达式 从左向右扫描，数字入number栈，运算符入operator栈 +-基本优先级为1，×÷基本优先级为2，log ln sin cos tan n!基本优先级为3，√^基本优先级为4
     * 括号内层运算符比外层同级运算符优先级高4 当前运算符优先级高于栈顶压栈，低于栈顶弹出一个运算符与两个数进行运算 重复直到当前运算符大于栈顶 扫描完后对剩下的运算符与数字依次计算
     */
    public void process(String str)
    {
        // weightPlus为同一（）下的基本优先级，weightTemp临时记录优先级的变化
        int weightPlus = 0;
       
        // topOp为weight[]，operator[]的计数器；
        int topOp = 0;
       
        // topNum为number[]的计数器
        int topNum = 0;
       
        // flag为正负数的计数器，1为正数，-1为负数
        int flag = 1;
       
        int weightTemp = 0;
       
        // 保存operator栈中运算符的优先级，以topOp计数
        int weight[];
       
        // 保存数字，以topNum计数
        double number[];
       
        // operator[]保存运算符，以topOp计数
        char ch, ch_gai, operator[];
       
        // 记录数字，str以+-×÷()sctgl!√^分段，+-×÷()sctgl!√^字符之间的字符串即为数字
        String num;
       
        weight = new int[MAXLEN];
       
        number = new double[MAXLEN];
       
        operator = new char[MAXLEN];
       
        // String expression1 = str;
       
        StringTokenizer expToken = new StringTokenizer(str, "+-×÷()sctgl!√^²³");
       
        int i = 0;
       
        while (i < str.length())
        {
            ch = str.charAt(i);
           
            if (i == 0)
            {
                if (ch == '-')
                    flag = -1;
            }
            else if (str.charAt(i - 1) == '(' && ch == '-')
                flag = -1;
           
            if (ch <= '9' && ch >= '0' || ch == '.' || ch == 'E')
            {
                num = expToken.nextToken();
                ch_gai = ch;
               
                while (i < str.length() && (ch_gai <= '9' && ch_gai >= '0' || ch_gai == '.' || ch_gai == 'E'))
                {
                    ch_gai = str.charAt(i++);
                }
               
                if (i >= str.length())
                {
                    i -= 1;
                }
                else
                {
                    i -= 2;
                }
               
                if (num.compareTo(".") == 0)
                {
                    number[topNum++] = 0;
                }
                else
                {
                    number[topNum++] = Double.parseDouble(num) * flag;
                    flag = 1;
                }
            }
            if (ch == '(')
            {
                weightPlus += 4;
            }
            if (ch == ')')
            {
                weightPlus -= 4;
            }
           
            if (ch == '-' && flag == 1 || ch == '+' || ch == '×' || ch == '÷' || ch == 's' || ch == 'c' || ch == 't'
                || ch == 'g' || ch == 'l' || ch == '!' || ch == '√' || ch == '^' || ch == '²' || ch == '³')
            {
                switch (ch)
                {
                    case '+':
                    case '-':
                        weightTemp = 1 + weightPlus;
                        break;
                    case '×':
                    case '÷':
                        weightTemp = 2 + weightPlus;
                        break;
                    case 's':
                    case 'c':
                    case 't':
                    case 'g':
                    case 'l':
                    case '!':
                        weightTemp = 3 + weightPlus;
                        break;
                    // case '^':
                    // case '√':
                    default:
                        weightTemp = 4 + weightPlus;
                        break;
                }
               
                if (topOp == 0 || weight[topOp - 1] < weightTemp)
                {
                    weight[topOp] = weightTemp;
                    operator[topOp] = ch;
                    topOp++;
                }
                else
                {
                    while (topOp > 0 && weight[topOp - 1] >= weightTemp)
                    {
                        switch (operator[topOp - 1])
                        {
                            case '+':
                                number[topNum - 2] += number[topNum - 1];
                                break;
                           
                            case '-':
                                number[topNum - 2] -= number[topNum - 1];
                               
                            case '×':
                                number[topNum - 2] *= number[topNum - 1];
                                break;
                           
                            case '÷':
                                if (number[topNum - 1] == 0)
                                {
                                    showError(1, str_old);
                                    return;
                                }
                                number[topNum - 2] /= number[topNum - 1];
                                break;
                           
                            case '√':
                                if (number[topNum - 1] == 0 || (number[topNum - 2] < 0 && number[topNum - 1] % 2 == 0))
                                {
                                    showError(2, str_old);
                                    return;
                                }
                                number[topNum - 2] = Math.pow(number[topNum - 2], 1 / number[topNum - 1]);
                                break;
                           
                            case '^':
                                number[topNum - 2] = Math.pow(number[topNum - 2], number[topNum - 1]);
                                break;
                           
                            case '²':
                                number[topNum] = Math.pow(number[topNum], 2);
                                break;
                           
                            case '³':
                                number[topNum] = Math.pow(number[topNum], 3);
                                break;
                           
                            case 's':
                                if (drg_flag == true)
                                {
                                    number[topNum - 1] = Math.sin((number[topNum - 1] / 180) * pi);
                                }
                                else
                                {
                                    number[topNum - 1] = Math.sin(number[topNum - 1]);
                                }
                                topNum++;
                                break;
                           
                            case 'c':
                                if (drg_flag == true)
                                {
                                    number[topNum - 1] = Math.cos((number[topNum - 1] / 180) * pi);
                                }
                                else
                                {
                                    number[topNum - 1] = Math.cos(number[topNum - 1]);
                                }
                                topNum++;
                                break;
                           
                            case 't':
                                if (drg_flag == true)
                                {
                                    if ((Math.abs(number[topNum - 1]) / 90) % 2 == 1)
                                    {
                                        showError(2, str_old);
                                        return;
                                    }
                                    number[topNum - 1] = Math.tan((number[topNum - 1] / 180) * pi);
                                }
                                else
                                {
                                    if ((Math.abs(number[topNum - 1]) / (pi / 2)) % 2 == 1)
                                    {
                                        showError(2, str_old);
                                        return;
                                    }
                                   
                                    number[topNum - 1] = Math.tan(number[topNum - 1]);
                                }
                                topNum++;
                                break;
                           
                            case 'g':
                                if (number[topNum - 1] <= 0)
                                {
                                    showError(2, str_old);
                                    return;
                                }
                                number[topNum - 1] = Math.log10(number[topNum - 1]);
                                topNum++;
                                break;
                           
                            case 'l':
                                if (number[topNum - 1] <= 0)
                                {
                                    showError(2, str_old);
                                    return;
                                }
                                number[topNum - 1] = Math.log(number[topNum - 1]);
                                topNum++;
                                break;
                           
                            case '!':
                                if (number[topNum - 1] > 170)
                                {
                                    showError(3, str_old);
                                    return;
                                }
                                else if (number[topNum - 1] < 0)
                                {
                                    showError(2, str_old);
                                    return;
                                }
                                number[topNum - 1] = n(number[topNum - 1]);
                                topNum++;
                                break;
                        }
                        switch (operator[topOp])
                        {
                           
                            case '²':
                                number[topNum] = Math.pow(number[topNum], 2);
                                break;
                           
                            case '³':
                                number[topNum] = Math.pow(number[topNum], 3);
                                break;
                        }
                       
                        topNum--;
                        topOp--;
                    }
                    weight[topOp] = weightTemp;
                    operator[topOp] = ch;
                    topOp++;
                }
            }
            i++;
        }
       
        while (topOp > 0)
        {
            switch (operator[topOp - 1])
            {
                case '+':
                    number[topNum - 2] += number[topNum - 1];
                    break;
               
                case '-':
                    number[topNum - 2] -= number[topNum - 1];
                    break;
               
                case '×':
                    number[topNum - 2] *= number[topNum - 1];
                    break;
               
                case '÷':
                    if (number[topNum - 1] == 0)
                    {
                        showError(1, str_old);
                        return;
                    }
                    number[topNum - 2] /= number[topNum - 1];
                    break;
               
                case '√':
                    if (number[topNum - 1] == 0 || (number[topNum - 2] < 0 && number[topNum - 1] % 2 == 0))
                    {
                        showError(2, str_old);
                        return;
                    }
                    number[topNum - 2] = Math.pow(number[topNum - 2], 1 / number[topNum - 1]);
                    break;
               
                case '^':
                    number[topNum - 2] = Math.pow(number[topNum - 2], number[topNum - 1]);
                    break;
               
               
                case 's':
                    if (drg_flag == true)
                    {
                        number[topNum - 1] = Math.sin((number[topNum - 1] / 180) * pi);
                    }
                    else
                    {
                        number[topNum - 1] = Math.sin(number[topNum - 1]);
                    }
                    topNum++;
                    break;
               
                case 'c':
                    if (drg_flag == true)
                    {
                        number[topNum - 1] = Math.cos((number[topNum - 1] / 180) * pi);
                    }
                    else
                    {
                        number[topNum - 1] = Math.cos(number[topNum - 1]);
                    }
                    topNum++;
                    break;
               
                case 't':
                    if (drg_flag == true)
                    {
                        if ((Math.abs(number[topNum - 1]) / 90) % 2 == 1)
                        {
                            showError(2, str_old);
                            return;
                        }
                        number[topNum - 1] = Math.tan((number[topNum - 1] / 180) * pi);
                    }
                    else
                    {
                        if ((Math.abs(number[topNum - 1]) / (pi / 2)) % 2 == 1)
                        {
                            showError(2, str_old);
                            return;
                        }
                        number[topNum - 1] = Math.tan(number[topNum - 1]);
                    }
                    topNum++;
                    break;
               
                case 'g':
                    if (number[topNum - 1] <= 0)
                    {
                        showError(2, str_old);
                        return;
                    }
                    number[topNum - 1] = Math.log10(number[topNum - 1]);
                    topNum++;
                    break;
               
                case 'l':
                    if (number[topNum - 1] <= 0)
                    {
                        showError(2, str_old);
                        return;
                    }
                    number[topNum - 1] = Math.log(number[topNum - 1]);
                    topNum++;
                    break;
               
                case '!':
                    if (number[topNum - 1] > 170)
                    {
                        showError(3, str_old);
                        return;
                    }
                    else if (number[topNum - 1] < 0)
                    {
                        showError(2, str_old);
                        return;
                    }
                    number[topNum - 1] = n(number[topNum - 1]);
                    topNum++;
                    break;
            }

            switch (operator[topOp])
            {
               
                case '²':
                    number[topNum] = Math.pow(number[topNum], 2);
                    break;
               
                case '³':
                    number[topNum] = Math.pow(number[topNum], 3);
                    break;
            }
            topNum--;
            topOp--;
        }
       
        if (number[0] > 7.3E306)
        {
            showError(3, str_old);
            // input.setText("\""+str_old+"\": 太大了，我不行了");
            return;
        }
       
        System.out.println(String.valueOf(fp(number[0])));
       
        // input.setText(String.valueOf(fp(number[0]))); // 输出最终结果
       
        // tip.setText("计算完毕，要继续请按归零键 C");
       
        // mem.setText(str_old + "=" + String.valueOf(fp(number[0])));
       
    }
   
    /*
     * FP = floating point 控制小数位数，达到精度 否则会出现 0.6-0.2=0.39999999999999997的情况，用FP即可解决，使得数为0.4 本格式精度为15位
     */
    public double fp(double n)
    {
        DecimalFormat format = new DecimalFormat("0.#############");
       
        return Double.parseDouble(format.format(n));
    }
   
    /*
     * 阶乘算法
     */
    public double n(double n)
    {
        int i = 0;
       
        double sum = 1;
       
        for (i = 1; i <= n; i++)
        {
            sum = sum * i;
        }
        return sum;
    }
   
    /*
     * 错误提示，按了"="之后，若计算式在process()过程中，出现错误，则进行提示
     */
    public void showError(int code, String str)
    {
        String message = "";
       
        switch (code)
        {
            case 1:
                message = "零不能作除数";
                break;
           
            case 2:
                message = "函数格式错误";
                break;
           
            case 3:
                message = "值太大了，我不行了";
        }
       
        System.out.println("\"" + str + "\"" + ": " + message);
        // input.setText("\"" + str + "\"" + ": " + message);
       
        // tip.setText(message + "\n" + "计算完毕，要继续请按归零键 C");
    }
   
}
分享到：
| clearcase命令
评论
发表评论

您还没有登录,请您登录后再发表评论

相关推荐

    C#面积计算器源代码

    在本项目中，"C#面积计算器源代码"是一个简单的应用程序，它允许用户计算不同几何图形的面积。这个程序的核心是使用C#编程语言来实现各种图形面积计算的算法。以下是一些关于这个项目的详细知识点： 1. **C#语言...

    C#复数计算器 不含源代码

    在本项目中，我们关注的是一个基于C#编程语言实现的复数计算器应用。复数是数学中的一个重要概念，它扩展了实数的概念，引入了虚部，使得我们可以解决一些在实数范围内无法解决的问题。C#作为一种现代化的、面向对象...

    复数计算器源代码

    通过分析这个项目的源代码，我们可以学习到关于复数运算和C++编程的多个知识点。 首先，我们要了解复数。复数由实部和虚部构成，形式为a + bi，其中a是实部，b是虚部，i是虚数单位，i² = -1。复数运算遵循代数规则...

    圆形体体积计算器——C语言代码

    在提供的压缩文件中，我们可以找到源代码文件“圆形体体积计算器.c”，这应该是实现上述功能的代码。通过查看并分析这个文件，可以进一步学习C语言的基础语法、函数定义、变量声明、条件语句、循环以及输入输出操作...

    开发标准体重计算器

    在开发一个标准体重计算器的过程中，我们首先需要理解其基本功能：根据用户的身体指标（如身高、性别、年龄等）计算出适宜的体重范围。这样的工具通常基于BMI（Body Mass Index，身体质量指数）来评估健康状况。对于...

    计算器.zip

    最后，"计算器9"可能是源代码文件或者工程文件的名字，包含计算器项目的源代码，可能包括头文件、主程序、LCD驱动函数、四则运算函数等。通过分析和编译这些代码，你可以深入了解51单片机与LCD1602的集成应用，以及...

    高级计算器和最小二乘法计算器

    尽管这个计算器并不具备最小二乘法功能，但可以作为对比，展示出高级计算器与基础计算器的区别。 在实际应用中，C++程序员可能会使用更高级的库，如Eigen库进行矩阵运算，或者使用OpenCV库进行图像和数据处理，这些...

    专门计算面积的计算器

    这个计算器可能采用了用户友好的界面，让用户只需输入相关的尺寸参数，就可以快速得到结果。同时，它也可能提供了单位转换功能，使得不同单位间的换算变得更加容易。如果允许用户自定义添加新的计算类型，那么可能...

    方程、分数计算器，特别是分数计算功能强大

    方程和分数计算器是一款专为解决数学问题设计的软件工具，尤其在处理分数运算方面表现出色。这款计算器不仅能够帮助用户解决线性、二次、甚至更复杂的方程，还提供了全面的分数运算功能，使计算过程更为精确和简便。...

    《Android》BMI指数计算器

    在Android平台上开发一款BMI指数计算器应用，涉及到许多关键的编程概念和技术。首先，我们需要理解BMI指数的基本计算方法，它是通过体重（单位：公斤）除以身高（单位：米）的平方来得到的。公式可以表示为：BMI = ...

    【BMI指数计算器V1.0】项目实战

    这个项目的核心是设计并实现一个能够计算BMI（Body Mass Index，身体质量指数）的软件工具，通过输入体重和身高数据，用户可以快速了解自己的健康状况。 首先，我们需要理解BMI指数的计算公式。BMI=体重（kg）/身高...

    安卓身高体重计算器

    这款应用程序适用于Android操作系统，用户可以轻松在手机上进行操作。 一、BMI概念与计算方法 身体质量指数（BMI）是衡量人体肥胖程度的一个国际通用标准，通过体重（公斤）除以身高（米）的平方来得出。公式如下...

    复数计算器C++写的喔

    这个计算器可以接受复数作为输入，执行基本的复数运算，并返回结果。通过学习和理解这个代码，你可以进一步掌握C++的面向对象编程技巧，以及复数运算的数学原理。这不仅有助于提升编程技能，也有助于理解和解决更...

    安卓Android源码——BMI健康计算器.zip

    在这个BMI计算器项目中，我们可以学习到如何在Android环境中搭建用户界面、处理用户输入、进行数学计算以及展示结果。 1. **用户界面设计**： - 使用XML布局文件创建UI元素，如EditText用于输入体重和身高，Button...

    android资源-BMI计算器

    这两个输入字段可以是EditText控件，提供数字键盘以方便用户输入。此外，一个计算按钮触发计算过程，并显示结果。结果显示在一个TextView控件中，可能还会包含BMI分类（如正常、偏轻、偏重等）。 **二、数据处理** ...

    mfc 写的复数计算器

    例如，用户输入的复数可以通过DDX_Text函数绑定到对话框的数据成员，然后进行有效性检查，如确保输入是合法的数字。 5. **复数运算** 在MFC应用中，可以定义复数类（CComplex），包含实部和虚部两个成员变量，并...

    复数计算器 很简单

    用户可以在文本框中输入复数，如“3+4i”或“2-5i”，然后选择相应的运算符，点击计算按钮，程序会解析输入的复数，执行相应的数学运算，并将结果展示出来。这涉及到字符串处理、复数运算以及控件更新等多个环节。 ...

    圆弧计算器-半径、夹角、弧长相互计算器

    例如，如果你知道一个圆的半径是10米，而你想要找到对应的弧长，只需输入半径和夹角（比如30度），计算器会自动给出弧长，即5π/3米（约等于5.24米）。反之，如果你已知弧长和夹角，也可以计算出半径。同样，如果给...

    激光光束参数计算器V3.0

    激光光束参数计算器V3.0是一款专为激光技术人员设计的专业计算工具，相较于之前的Excel版本，此软件提供了更直观、便捷的操作界面。该软件的主要功能是帮助用户计算和分析激光光束的各种关键参数，这对于理解和优化...

    复频域计算器.rar

    《复频域计算器——深入解析与应用》 “复频域计算器.rar”是一个专为处理复数和复频域线性方程组设计的独立可执行文件，适用于.NET框架3.5及以上版本。该计算器的独特之处在于其专门针对复数运算和复频域分析进行...

Magicbox
Global site tag (gtag.js) - Google Analytics