当前位置： 首页 > news >正文

高精度算法

news 来源：原创 2025/5/2 17:59:23

目录

高精度加法

代码说明：

高精度加法（整数）

高精度加法（浮点数）

 高精度加法（含符号）       

高精度减法

代码说明：

高精度减法（整数）

 高精度减法（浮点数）

高精度乘法

代码说明：

高精度乘法（整数）

 高精度乘法（浮点数）

 高精度除法

高精度除法（整数）

 高精度除法（浮点数）

代码说明：

高精度加法

代码说明：

  1. 高精度加法（整数）：

    • 首先确保两个字符串长度相等，较短的字符串在前面补零。

    • 从最低位开始逐位相加，并处理进位。

    • 最后反转结果字符串得到正确的顺序。

  2. 高精度加法（浮点数）：

    • 将浮点数分为整数部分和小数部分。

    • 分别对整数部分和小数部分进行高精度加法。

    • 处理小数部分相加后可能产生的进位。

    • 最后合并整数部分和小数部分得到最终结果。

高精度加法（整数）

// 高精度加法（整数）
string addBigInt(string num1, string num2) {
	// 确保num1是较长的字符串
	if (num1.length() < num2.length()) {
		swap(num1, num2);
	}
	
	// 补零使两个字符串长度相等
	while (num2.length() < num1.length()) {
		num2 = '0' + num2;
	}
	
	string result;
	int carry = 0;
	for (int i = num1.length() - 1; i >= 0; --i) {
		int digit1 = num1[i] - '0';
		int digit2 = num2[i] - '0';
		int sum = digit1 + digit2 + carry;
		carry = sum / 10;
		result.push_back((sum % 10) + '0');
	}
	
	// 如果最后还有进位
	if (carry) {
		result.push_back(carry + '0');
	}
	
	// 反转结果字符串
	reverse(result.begin(), result.end());
	
	return result;
}

高精度加法（浮点数）

// 高精度加法（浮点数）
string addBigFloat(string num1, string num2) {
	// 分离整数部分和小数部分
	size_t dot1 = num1.find('.');
	size_t dot2 = num2.find('.');
	
	string intPart1 = (dot1 == string::npos) ? num1 : num1.substr(0, dot1);
	string fracPart1 = (dot1 == string::npos) ? "" : num1.substr(dot1 + 1);
	
	string intPart2 = (dot2 == string::npos) ? num2 : num2.substr(0, dot2);
	string fracPart2 = (dot2 == string::npos) ? "" : num2.substr(dot2 + 1);
	
	// 补零使小数部分长度相等
	while (fracPart1.length() < fracPart2.length()) {
		fracPart1.push_back('0');
	}
	while (fracPart2.length() < fracPart1.length()) {
		fracPart2.push_back('0');
	}
	
	// 小数部分相加
	string fracSum = addBigInt(fracPart1, fracPart2);
	int carry = 0;
	if (fracSum.length() > fracPart1.length()) {
		carry = 1;
		fracSum = fracSum.substr(1);
	}
	
	// 整数部分相加
	string intSum = addBigInt(intPart1, intPart2);
	if (carry) {
		intSum = addBigInt(intSum, "1");
	}
	
	// 合并整数部分和小数部分
	return intSum + "." + fracSum;
}

 高精度加法（含符号）       

负号使用高精度减法， 正好使用高精度加法（可选择有无符号）

高精度减法

代码说明：

  1. 整数减法：

    • 处理大整数减法，确保 num_1 \geq num_2，否则交换并标记结果为负数。

    • 反转字符串，从最低位开始逐位相减，处理借位。

    • 去掉前导零并返回结果。

  2. 浮点数减法：

    • 补齐小数部分长度，确保两个数的小数位数相同。

    • 移除小数点，将浮点数视为整数进行减法运算。

    • 重新插入小数点并去掉多余的零。

高精度减法（整数）

// 高精度减法（整数）
string subtractBigIntegers(string num1, string num2) {
	// 确保 num1 >= num2，否则交换并标记结果为负数
	bool negative = false;
	if (num1.length() < num2.length() || (num1.length() == num2.length() && num1 < num2)) {
		swap(num1, num2);
		negative = true;
	}
	
	// 反转字符串以便从最低位开始计算
	reverse(num1.begin(), num1.end());
	reverse(num2.begin(), num2.end());
	
	string result;
	int carry = 0;
	for (int i = 0; i < num1.length(); ++i) {
		int digit1 = num1[i] - '0';
		int digit2 = (i < num2.length()) ? (num2[i] - '0') : 0;
		int diff = digit1 - digit2 - carry;
		if (diff < 0) {
			diff += 10;
			carry = 1;
		} else {
			carry = 0;
		}
		result.push_back(diff + '0');
	}
	
	// 去掉前导零
	while (result.length() > 1 && result.back() == '0') {
		result.pop_back();
	}
	
	// 反转回正常顺序
	reverse(result.begin(), result.end());
	
	// 如果结果为负数，添加负号
	if (negative) {
		result = "-" + result;
	}
	
	return result;
}

 高精度减法（浮点数）


// 补齐小数部分长度
void padDecimal(string &num1, string &num2) {
	size_t dot1 = num1.find('.');
	size_t dot2 = num2.find('.');
	if (dot1 == string::npos) num1 += ".0";
	if (dot2 == string::npos) num2 += ".0";
	
	size_t decimal1 = num1.length() - num1.find('.') - 1;
	size_t decimal2 = num2.length() - num2.find('.') - 1;
	
	if (decimal1 < decimal2) {
		num1.append(decimal2 - decimal1, '0');
	} else if (decimal1 > decimal2) {
		num2.append(decimal1 - decimal2, '0');
	}
}

// 高精度减法（浮点数）
string subtractBigFloats(string num1, string num2) {
	// 补齐小数部分
	padDecimal(num1, num2);
	
	// 移除小数点，将浮点数视为整数
	size_t dot1 = num1.find('.');
	size_t dot2 = num2.find('.');
	num1.erase(dot1, 1);
	num2.erase(dot2, 1);
	
	// 调用整数减法
	string result = subtractBigIntegers(num1, num2);
	
	// 重新插入小数点
	int decimalPlaces = max(num1.length() - dot1, num2.length() - dot2);
	result.insert(result.length() - decimalPlaces, ".");
	
	// 去掉末尾多余的零
	result.erase(result.find_last_not_of('0') + 1, string::npos);
	if (result.back() == '.') result.pop_back();
	
	return result;
}

高精度乘法

代码说明：

  1. 高精度整数乘法：

    • 使用字符串表示大整数。

    • 通过逐位相乘并处理进位来实现乘法。

    • 最后去除前导零并返回结果。

  2. 高精度浮点数乘法：

    • 首先找到小数点的位置，将浮点数转换为整数。

    • 计算小数点的总位数。

    • 使用整数乘法进行计算。

    • 最后根据小数点的位数插入小数点。

高精度乘法（整数）

// 高精度整数乘法
string multiply(string num1, string num2) {
    int n1 = num1.size();
    int n2 = num2.size();
    vector<int> result(n1 + n2, 0);

    // 从低位到高位逐位相乘
    for (int i = n1 - 1; i >= 0; i--) {
        for (int j = n2 - 1; j >= 0; j--) {
            int mul = (num1[i] - '0') * (num2[j] - '0');
            int sum = mul + result[i + j + 1];
            result[i + j + 1] = sum % 10;
            result[i + j] += sum / 10;
        }
    }

    // 去除前导零
    int i = 0;
    while (i < result.size() && result[i] == 0) {
        i++;
    }

    // 将结果转换为字符串
    string res;
    for (; i < result.size(); i++) {
        res.push_back(result[i] + '0');
    }

    return res.empty() ? "0" : res;
}

 高精度乘法（浮点数）

// 高精度浮点数乘法
string multiplyFloat(string num1, string num2) {
	// 找到小数点的位置
	size_t dot1 = num1.find('.');
	size_t dot2 = num2.find('.');
	
	// 如果没有小数点，则当作整数处理
	if (dot1 == string::npos) dot1 = num1.size();
	if (dot2 == string::npos) dot2 = num2.size();
	
	// 移除小数点，将浮点数转换为整数
	string int1 = num1.substr(0, dot1) + num1.substr(dot1 + 1);
	string int2 = num2.substr(0, dot2) + num2.substr(dot2 + 1);
	
	// 计算小数点的总位数
	int decimalPlaces = (num1.size() - dot1 - 1) + (num2.size() - dot2 - 1);
	
	// 进行整数乘法
	string result = multiply(int1, int2);
	
	// 插入小数点
	if (decimalPlaces > 0) {
		result.insert(result.size() - decimalPlaces, ".");
	}
	
	return result;
}

 高精度除法

高精度除法（整数）

// 高精度整数除法
string highPrecisionDivide(string dividend, int divisor) {
	string result;
	int index = 0;
	int temp = dividend[index] - '0';
	
	while (temp < divisor) {
		temp = temp * 10 + (dividend[++index] - '0');
	}
	
	while (dividend.size() > index) {
		result += (temp / divisor) + '0';
		temp = (temp % divisor) * 10 + (dividend[++index] - '0');
	}
	
	if (result.length() == 0) {
		return "0";
	}
	
	return result;
}

 高精度除法（浮点数）

// 高精度浮点数除法
string highPrecisionFloatDivide(string dividend, int divisor, int precision) {
	size_t decimalPoint = dividend.find('.');
	if (decimalPoint == string::npos) {
		decimalPoint = dividend.length();
	}
	
	string integerPart = dividend.substr(0, decimalPoint);
	string fractionalPart = dividend.substr(decimalPoint + 1);
	
	string integerResult = highPrecisionDivide(integerPart, divisor);
	
	string fractionalResult;
	int temp = 0;
	for (int i = 0; i < fractionalPart.length(); ++i) {
		temp = temp * 10 + (fractionalPart[i] - '0');
	}
	
	for (int i = 0; i < precision; ++i) {
		temp *= 10;
		fractionalResult += (temp / divisor) + '0';
		temp %= divisor;
	}
	
	return integerResult + "." + fractionalResult;
}

代码说明：

  1. 高精度整数除法：

    • highPrecisionDivide 函数实现了高精度整数除法。它通过逐位处理被除数，模拟手工除法的过程。

    • 该函数返回一个字符串形式的结果。

  2. 高精度浮点数除法：

    • highPrecisionFloatDivide 函数首先将浮点数分为整数部分和小数部分。

    • 对整数部分调用 highPrecisionDivide  进行除法运算。

    • 对小数部分进行逐位处理，模拟手工除法的过程，直到达到指定的精度。

相关文章：

  • 用大模型学大模型03-数学基础 概率论 最大似然估计（MLE）最大后验估计（MAP）
  • 几款C#开发的入门书籍与视频教程
  • LLaMA-Factory 安装linux部署conda笔记
  • MT6835 21位 磁编码器 SPI 平台无关通用驱动框架 STM32
  • DeepSeek教unity------MessagePack-06
  • 【前端如何实现图片懒加载？】
  • Day65_20250213图论part9_dijkstra(堆优化版)|Bellman_ford算法精讲
  • HTTP 参数污染（HPP）详解
  • 开源大模型性能追平闭源模型技术路径分析
  • 1.初识SpringSecurity
  • VsCode美化 Json
  • 基于SSM+uniapp的租房小程序
  • React 中级教程
  • Linux线程概念与线程操作
  • soular基础教程-使用指南
  • nodejs版本管理，使用 nvm 删除node版本，要删除 Node.js 的某个版本详细操作
  • Java 大数据与区块链的融合：数据可信共享与溯源（45）
  • Spring Boot 整合 SSE（Server-Sent Events）
  • uniapp当页面高度设置100vh的时候。怎么让他禁止上下滚动
  • 尚硅谷爬虫note007
  • 龙翔被撤销南京市人大常委会主任职务，此前已被查
  • 美国务院宣布新一轮与伊朗相关的制裁
  • 五一去哪儿｜ 追着花期去旅行，“赏花经济”绽放文旅新活力
  • 解密62个“千亿县”：强者恒强，新兴产业助新晋县崛起
  • 当老年人加入“行为艺术基础班”
  • 中国人保聘任田耕为副总裁，此前为工行浙江省分行行长