在这篇文章中，我们将带领您了解js加减乘除精确计算的全貌，包括js加减乘除精确计算怎么算的相关情况。同时，我们还将为您介绍有关15.加减乘除计算机代码、BigDecimal实现精确的加减乘除、C++实
在这篇文章中，我们将带领您了解js加减乘除精确计算的全貌，包括js加减乘除精确计算怎么算的相关情况。同时，我们还将为您介绍有关15.加减乘除计算机代码、BigDecimal实现精确的加减乘除、C++实现加减乘除计算器、Excel怎么批量计算加减乘除_Excel批量计算加减乘除的详细教程的知识，以帮助您更好地理解这个主题。
本文目录一览：- js加减乘除精确计算（js加减乘除精确计算怎么算）
- 15.加减乘除计算机代码
- BigDecimal实现精确的加减乘除
- C++实现加减乘除计算器
- Excel怎么批量计算加减乘除_Excel批量计算加减乘除的详细教程
js加减乘除精确计算（js加减乘除精确计算怎么算）
Javascript精确计算时的bug
JS无法进行精确计算的bug
在做CRM，二代审核需求审核详情页面时。需要按比例（后端传类似0.8的小数）把用户输入的数字显示在不同的地方。
在做dubheInvest = invest * (1 - ratio);运算时发现问题。具体如下：
示例代码:
console.log( 1 - 0.8 ); //输出 0.19999999999999996
console.log( 6 * 0.7 ); //输出 4.199999999999999
console.log( 0.1 + 0.2 ); //输出 0.30000000000000004
console.log( 0.1 + 0.7 ); //输出 0.7999999999999999
console.log( 1.2 / 0.2 ); //输出 5.999999999999999
通过上面举出的例子可以看到，原生的js运算结果不一定准确，会丢失精度。
解决方案
解决方案的原理是，将浮点数乘以（扩大）10的n次方倍，把浮点数变为整数后再进行相应的运算，最后将得到的结果除以（缩小）10的n次方倍。
原理示例：
将 console.log(1-0.8); 变为 console.log((1 * 10 - 0.8 * 10) / 10); 即可得到正确的值
根据上述原理，可以封装一些方法出来解决此类问题。如下所示（Math.pow(x, y);表示求x的y次方）：
//加
function floatAdd(arg1,arg2){
var r1,r2,m;
try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2));
return (arg1*m+arg2*m)/m;
}
//减
function floatSub(arg1,arg2){
var r1,r2,m,n;
try{r1=arg1.toString().split(".")[1].length}catch(e){r1=0}
try{r2=arg2.toString().split(".")[1].length}catch(e){r2=0}
m=Math.pow(10,Math.max(r1,r2));
//动态控制精度长度
n=(r1>=r2)?r1:r2;
return ((arg1*m-arg2*m)/m).toFixed(n);
}
//乘
function floatMul(arg1,arg2) {
var m=0,s1=arg1.toString(),s2=arg2.toString();
try{m+=s1.split(".")[1].length}catch(e){}
try{m+=s2.split(".")[1].length}catch(e){}
return Number(s1.replace(".",""))*Number(s2.replace(".",""))/Math.pow(10,m);
}
//除
function floatDiv(arg1,arg2){
var t1=0,t2=0,r1,r2;
try{t1=arg1.toString().split(".")[1].length}catch(e){}
try{t2=arg2.toString().split(".")[1].length}catch(e){}
r1=Number(arg1.toString().replace(".",""));
r2=Number(arg2.toString().replace(".",""));
return (r1/r2)*Math.pow(10,t2-t1);
}
15.加减乘除计算机代码
一.代码是简易的加减乘除计算器
代码如下：
1 #############
2 import sys
3 print(''运算为加减乘除，输入Q或者q或者空退出，运算格式为：\n1+1\n1-1\n1*1\n1/1'')
4 while True:
5 num = input(''请输入你需要运算的式子:'')
6 num_clear = num.replace('' '','''').upper() #这里直接处理字符串里空格号转化为空字符，并且字母转化为大写方便后面判断是否输入的有字母
7 if num_clear == ''Q'' or num_clear == ''q'': #这里只要输入的是这个两个字母就直接退出
8 sys.exit()
9 elif num_clear == '''' or num_clear.isupper() == True or num_clear.isdigit() == True:
10 #这里判断的是为了防止用户输入的字符串为空丶字母都为大写的丶纯数字的全部不正规重新输入
11 #string.islower()：字符串中的字母全为小写则返回True，否则返回False
12 #string.isupper()：字符串中的字母全为大写则返回True，否则返回False
13 #string.isdigit()：如果string只包含数字，则返回True，否则返回False
14 #string.isspace()：字符串中只包含空白字符，返回True，否则返回False
15 print(''请输入正确的运算方式：'')
16 continue
17 for var in num_clear:
18 if var in [''+'',''-'',''*'',''/'']:
19 index = num_clear.find(var)
20 num_left,num_right = num_clear.split(var,1)[0],num_clear.split(var,1)[1] #这一步是符号拆分字符串列表各个取值
21 break
22 if num_left.isdigit() != True or num_right.isdigit() != True:
23 print(''请输入正规的运算式子'')
24 continue
25 num_left,num_right = float(num_left),float(num_right)
26 if num[index] == ''+'':
27 print(''>>>>运算结果='',num_left+num_right)
28 elif num[index] == ''-'':
29 print(''>>>>运算结果='',num_left-num_right)
30 elif num[index] == ''*'':
31 print(''>>>>运算结果='',num_left*num_right)
32 else:
33 print(''>>>>运算结果='',num_left/num_right)
下面为代码演示结果：
BigDecimal实现精确的加减乘除
float和double类型的主要设计目的是为了科学计算和工程计算。它们执行二进制浮点运算，这是为了在广域数值范围上提供较为精确的快速近似计算而精心设计的。然而，它们没有提供完全精确的结果，所以不应该被用于要求精确结果的场合。float和double类型对于货币计算尤为不合适，因为要让一个float或者double精确地表示0.1(或者10的任何负数次方值)是不可能的。下图列举一些加减乘除计算出现的问题：
public static void main(String[] args) {
System.out.println("double加法:" + (10.2 + 20.9));
System.out.println("double减法:" + (1.0 - 0.9));
System.out.println("double乘法:" + (5.4 * 3.0));
System.out.println("double除法:" + (0.6 / 0.2));
}运算结果：
要进行精确的加减乘除请使用java.math.BigDecimal提供的方法，下面的工具类是根据BigDecimal编写的：
import java.math.BigDecimal;
/**
*
* @Description : 精确计算
* @time 创建时间 : 2016年2月18日
* @author : DeanFan
* @Copyright (c) 2016
* @version
*/
public class MathUtils {
/**
*
* Description : 加法运算,保留精度(四舍五入)
* @param v1
* @param v2
* @param scale 精度
* @author DeanFan
*/
public static double add(double v1, double v2, int scale) {
return MathUtils.add(Double.toString(v1), Double.toString(v2), scale);
}
/**
*
* Description : 加法运算,保留精度(四舍五入)
* @param v1
* @param v2
* @param scale 精度
* @author DeanFan
*/
public static double add(String v1, String v2, int scale) {
return MathUtils.add(v1, v2, scale, BigDecimal.ROUND_HALF_UP);
}
/**
*
* Description : 加法运算,按舍入类别保留精度
* @param v1
* @param v2
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double add(double v1, double v2, int scale, int roundType) {
return MathUtils.add(Double.toString(v1), Double.toString(v2), scale, roundType);
}
/**
*
* Description : 加法运算,按舍入类别保留精度
* @param v1
* @param v2
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double add(String v1, String v2, int scale, int roundType) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.add(b2).setScale(scale, roundType).doubleValue();
}
/**
*
* Description : 减法运算,保留精度(四舍五入)
* @param v1 被减数
* @param v2 减数
* @param scale 精度
* @author DeanFan
*/
public static double subtract(double v1, double v2, int scale) {
return MathUtils.subtract(Double.toString(v1), Double.toString(v2), scale);
}
/**
*
* Description : 减法运算,保留精度(四舍五入)
* @param v1 被减数
* @param v2 减数
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double subtract(String v1, String v2, int scale) {
return MathUtils.subtract(v1, v2, scale, BigDecimal.ROUND_HALF_UP);
}
/**
*
* Description : 减法运算,按舍入类别保留精度
* @param v1 被减数
* @param v2 减数
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double subtract(double v1, double v2, int scale, int roundType) {
return MathUtils.subtract(Double.toString(v1), Double.toString(v2), scale, roundType);
}
/**
*
* Description : 减法运算,按舍入类别保留精度
* @param v1 被减数
* @param v2 减数
* @param scale 精度
* @author DeanFan
*/
public static double subtract(String v1, String v2, int scale, int roundType) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.subtract(b2).setScale(scale, roundType).doubleValue();
}
/**
*
* Description : 乘法运算,保留精度(四舍五入)
* @param v1
* @param v2
* @param scale 精度
* @author DeanFan
*/
public static double multiply(double v1, double v2, int scale) {
return MathUtils.multiply(Double.toString(v1), Double.toString(v2), scale);
}
/**
*
* Description : 乘法运算,保留精度(四舍五入)
* @param v1
* @param v2
* @param scale 精度
* @author DeanFan
*/
public static double multiply(String v1, String v2, int scale) {
return MathUtils.multiply(v1, v2, scale, BigDecimal.ROUND_HALF_UP);
}
/**
*
* Description : 乘法运算,按舍入类别保留精度
* @param v1
* @param v2
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double multiply(double v1, double v2, int scale, int roundType) {
return MathUtils.multiply(Double.toString(v1), Double.toString(v2), scale, roundType);
}
/**
*
* Description : 乘法运算,按舍入类别保留精度
* @param v1
* @param v2
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double multiply(String v1, String v2, int scale, int roundType) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.multiply(b2).setScale(scale, roundType).doubleValue();
}
/**
*
* Description : 除法运算,保留精度(四舍五入)
* @param v1 被除数
* @param v2 除数
* @param scale 精度
* @author DeanFan
*/
public static double divide(double v1, double v2, int scale) {
return MathUtils.divide(Double.toString(v1), Double.toString(v2), scale);
}
/**
*
* Description : 除法运算,保留精度(四舍五入)
* @param v1 被除数
* @param v2 除数
* @param scale 精度
* @author DeanFan
*/
public static double divide(String v1, String v2, int scale) {
return MathUtils.divide(v1, v2, scale, BigDecimal.ROUND_HALF_UP);
}
/**
*
* Description : 除法运算,按舍入类别保留精度
* @param v1 被除数
* @param v2 除数
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double divide(double v1, double v2, int scale, int roundType) {
return MathUtils.divide(Double.toString(v1), Double.toString(v2), scale, roundType);
}
/**
*
* Description : 除法运算,按舍入类别保留精度
* @param v1 被除数
* @param v2 除数
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double divide(String v1, String v2, int scale, int roundType) {
if (Double.valueOf(v2) == 0.0) {
throw new ArithmeticException("/ by zero");
}
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b1 = new BigDecimal(v1);
BigDecimal b2 = new BigDecimal(v2);
return b1.divide(b2, scale, roundType).doubleValue();
}
/**
*
* Description : 四舍五入
* @param v
* @param scale 精度
* @author DeanFan
*/
public static double round(double v, int scale) {
return MathUtils.round(Double.toString(v), scale);
}
/**
*
* Description : 四舍五入
* @param v
* @param scale 精度
* @author DeanFan
*/
public static double round(String v, int scale) {
return MathUtils.round(v, scale, BigDecimal.ROUND_HALF_UP);
}
/**
*
* Description : 按舍入类别保留精度
* @param v
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double round(double v, int scale, int roundType) {
return MathUtils.round(Double.toString(v), scale, roundType);
}
/**
*
* Description : 按舍入类别保留精度
* @param v
* @param scale 精度
* @param roundType 舍入类别<br>
* 例：BigDecimal.ROUND_HALF_UP
* @author DeanFan
*/
public static double round(String v, int scale, int roundType) {
if (scale < 0) {
throw new IllegalArgumentException("The scale must be a positive integer or zero");
}
BigDecimal b = new BigDecimal(v);
return b.setScale(scale, roundType).doubleValue();
}
}
利用工具类运算：
public static void main(String[] args) {
int scale = 2;
System.out.println("double加法:" + add(10.2, 20.9, scale));
System.out.println("double减法:" + subtract(1.0, 0.9, scale));
System.out.println("double乘法:" + multiply(5.4, 3.0, scale));
System.out.println("double除法:" + divide(0.6, 0.2, scale));
}运算结果：
C++实现加减乘除计算器
本文实例为大家分享了C++实现加减乘除计算器的具体代码，供大家参考，具体内容如下
#include <iostream>
#include <conio.h>
#include <string>
void main()
{
char str[0xFF];
do
{
system("cls");
float a{};
float b{};
int count = 1;
int isOperating = -1;
bool isFirst = true;
std::string text{ "按任意键重置，继续计算\n" };
std::cout << "------计算机------\n";
std::cout << "请输入加减乘除：";
std::cin >> str;
for (int i = strlen(str) - 1; i >= 0; i--)
{
float* num = isFirst ? &b : &a;
switch (str[i])
{
case ''*'':
isOperating = 0;
break;
case ''/'':
isOperating = 1;
break;
case ''+'':
isOperating = 2;
break;
case ''-'':
isOperating = 3;
break;
}
if (!isFirst&&!isdigit(str[i])&& str[i]<=127&& str[i]>=0)
{
isOperating = 4;
text = "暂只支持正整数加减乘除，不能输入中文,其他符号或运算符\n按任意键重新输入\n";
break;
}
if (isOperating != -1 && count != 1 && isFirst)
{
isFirst = false;
count = 1;
if (i == 0 || i == strlen(str) - 1)
{
isOperating = 4;
break;
}
continue;
}
*num += ((int)str[i] - 48) * count;
count *= 10;
}
switch (isOperating)
{
case 0:
std::cout << "结果为:" << a * b << std::endl;
break;
case 1:
if (a == 0)
text = "除数不能为0\n按任意键重置，继续计算\n";
else
std::cout << "结果为:" << a / b << std::endl;
break;
case 2:
std::cout << "结果为:" << a + b << std::endl;
break;
case 3:
std::cout << "结果为:" << a - b << std::endl;
break;
default:
text = text == "按任意键重置，继续计算\n" ? "错误格式,按任意键重新输入\n" : text;
}
std::cout << text;
_getch();
} while (true);
}用string接受做太简单了，用char数组比较好玩
#include<iostream>
using namespace std;
int main()
{
double a,b;
char op;
cout << "enter a" << endl;
cin >> a;
cout << "enter operator" << endl;
cin >> op;
cout << "enter b" << endl;
cin >> b;
double result;
if (op==''+'')
{
result = a + b;
}
else if (op==''-'')
{
result = a-b;
}
else if (op==''*'')
{
result = a*b;
}
else if (op==''/''){
if (b==0){
cout << "cannot devided by 0\n";
return 0;
}
else{
result =a/b;
}
}
else
{
cout << "invalid operator\n";
return 0；
}
cout << "result is " << result << endl;
return 0;
}以上就是本文的全部内容，希望对大家的学习有所帮助，也希望大家多多支持。
您可能感兴趣的文章:
- c++编写简单的计算器程序
- 简单实现C++复数计算器
- C/C++实现日期计算器的示例代码
- C++有限状态机实现计算器小程序
- C/C++经典实例之模拟计算器示例代码
- C++实现简单计算器
- C++实现四则混合运算计算器
- C++实现简单计算器功能
- C++实现分数计算器
- 基于C++实现简单日期计算器
Excel怎么批量计算加减乘除_Excel批量计算加减乘除的详细教程
您是否需要快速高效地在 excel 中批量执行加减乘除计算？php小编小新为您带来了一个详细指南，介绍如何使用 excel 的内置函数和公式轻松实现批量计算。继续阅读，了解分步说明和示例，让您掌握在 excel 中批量计算的技巧，快速处理大量数据并提高工作效率。
我们以下方的这张表格为例子。
我们先点击【公式】选项栏，在里面选择【定义名称】，在名称中我们填写计算，当然了你也可以填写你所需要的的。然后在引用位置中我们输入=evaluate(A2)，注意这个括号里的A2是你要计算的单元格，按实际情况来定。
输入好后我们点击确定，然后定为到计算结果显示的单元格，在【定义名称】下方的【用于公式】菜单中选择刚刚我们设置好的【计算】。
然后回车填充，之后全部单元格填充就搞定啦。
以上就是Excel怎么批量计算加减乘除_Excel批量计算加减乘除的详细教程的详细内容，更多请关注php中文网其它相关文章！
关于js加减乘除精确计算和js加减乘除精确计算怎么算的介绍现已完结，谢谢您的耐心阅读，如果想了解更多关于15.加减乘除计算机代码、BigDecimal实现精确的加减乘除、C++实现加减乘除计算器、Excel怎么批量计算加减乘除_Excel批量计算加减乘除的详细教程的相关知识，请在本站寻找。
本文标签：
![[转帖]Ubuntu 安装 Wine方法（ubuntu如何安装wine）](https://www.gvkun.com/zb_users/cache/thumbs/4c83df0e2303284d68480d1b1378581d-180-120-1.jpg)
