c++高精度计算20除法High-precision20calculate240101

要在C++中实现高精度和高性能的计算，
比如要计算 sin⁡(π6)sin(6π​) 至少100位的精度，你可以考虑使用如GNU Multiple Precision Arithmetic Library (GMP) 或者MPFR库来处理高精度数学运算。MPFR库是专门为了提供一个可靠的多精度浮点数计算平台，能够保证结果的准确性，包括四舍五入的控制。

下面是一个使用MPFR库在C++中计算 sin⁡(π/6)即sin(π/6​) 的示例代码，假设你已经正确安装了MPFR库：

……

如果你给嵌入式设备编程,当然就不能使用大规模的数学计算库，这时候……需要：
为实现一个基本的 高精度计算 c++库,应该从最基本的

大数的 加减乘除 撸起……

//大整数计算器:加减乘除
#include <iostream> // 用于输入输出
#include <string>   // 用于处理字符串
using namespace std;
// 定义一个表示大整的类，使用字符串来存储数字
class BigInteger {
private:
    std::string number; // 数字以字符串形式逆序存储

public:
    // 构造函数，初始化大整数
    BigInteger(const std::string& num) : number(num) {
        // 构造函数中不对字符串进行逆序，以保持原始顺序
    }

    // 将大整数转换成字符串形式
    std::string toString() const {
        std::string result = number;
        // toString函数中也不进行逆序，直接返回结果
        return result.empty() ? "0" : result; // 如果字符串为空，则返回"0"
    }

    // 实现大整数的加法
    BigInteger add(const BigInteger& other) const {
        std::string result = "";
        int carry = 0; // 进位
        int maxLength = std::max(number.length(), other.number.length()); // 获取最长的数字长度

        for (int i = 0; i < maxLength || carry; ++i) {
            // 从字符串最后一位开始逐位取出数字进行加法
            int digit1 = i < number.length() ? number[number.length() - 1 - i] - '0' : 0;
            int digit2 = i < other.number.length() ? other.number[other.number.length() - 1 - i] - '0' : 0;
            int sum = digit1 + digit2 + carry; // 计算总和
            result = char((sum % 10) + '0') + result; // 计算当前位的值，并添加到结果字符串前
            carry = sum / 10; // 计算进位
        }

        return BigInteger(result);
    } 实现大整数的加法

    // 实现大整数的减法
    BigInteger subtract(const BigInteger& other) const {
        std::string result = "";
        int borrow = 0; // 借位
        for (int i = 0; i < number.length(); ++i) 
        {//for1100
            // 从字符串最后一位开始逐位取出数字进行减法
            int digit1 = number[number.length() - 1 - i] - '0';
            int digit2 = i < other.number.length() ? other.number[other.number.length() - 1 - i] - '0' : 0;
            int diff = digit1 - digit2 - borrow; // 计算差值
            if (diff < 0) {
                diff += 10;
                borrow = 1; // 需要借位
            }
            else {
                borrow = 0;
            }
            result = char(diff + '0') + result; // 将当前位的结果添加到结果字符串前
        }//for1100

        // 移除结果前的所有零
        size_t firstNonZero = result.find_first_not_of('0');
        if (firstNonZero != std::string::npos) {
            result = result.substr(firstNonZero);
        }
        else {
            result = "0";
        }

        return BigInteger(result);
    }// 实现大整数的减法


    // 实现大整数的乘法
    BigInteger multiply(const BigInteger& other) const {
        int n = number.length();
        int m = other.number.length();
        std::string result(n + m, '0'); // 初始化结果为0，长度为两个数长度之和

        // 从个位开始逐位相乘
        for (int i = n - 1; i >= 0; i--) {
            for (int j = m - 1; j >= 0; j--) {
                int mul = (number[i] - '0') * (other.number[j] - '0'); // 计算乘积
                int sum = (result[i + j + 1] - '0') + mul; // 加上之前的进位

                result[i + j + 1] = sum % 10 + '0'; // 更新当前位
                result[i + j] += sum / 10; // 更新进位
            }
        }

        // 移除前导零
        size_t startpos = result.find_first_not_of('0');
        if (string::npos != startpos) {
            return BigInteger(result.substr(startpos));
        }
        return BigInteger("0");
    }

    // 比较两个大整数的大小
    bool isLessThan(const BigInteger& other) const {
        // 首先比较长度，长度短的数字小
        if (number.length() != other.number.length()) {
            return number.length() < other.number.length();
        }
        // 长度相同，逐位比较
        for (int i = 0; i < number.length(); ++i) {
            if (number[i] != other.number[i]) {
                return number[i] < other.number[i];
            }
        }
        return false; // 如果完全相同，则返回假
    }

    // 实现大整数的除法
    std::pair<BigInteger, BigInteger> divide(const BigInteger& divisor) const {
        if (divisor.number == "0") {
            throw std::invalid_argument("Divisor cannot be zero."); // 除数不能为0
        }

        BigInteger dividend = *this; // 被除数
        BigInteger quotient("0"); // 商
        BigInteger remainder("0"); // 余数
        for (int i = 0; i < dividend.number.length(); ++i) 
        {//for1100
            remainder.number += dividend.number[i]; // 将被除数的每一位加到余数上
            int count = 0;
            // 当余数不小于除数时，执行减法，并计数
            while (!remainder.isLessThan(divisor)) {
                remainder = remainder.subtract(divisor);
                ++count;
            }
            quotient.number += std::to_string(count); // 将计数添加到商的结果中
        }//for1100

        // 移除商结果前的所有零
        size_t firstNonZero = quotient.number.find_first_not_of('0');
        if (firstNonZero != std::string::npos) 
        {//for1200
            quotient.number = quotient.number.substr(firstNonZero);
        }
        else {
            quotient.number = "0";
        }//for1200else1200

        // 如果余数为空，设置为"0"
        if (remainder.number.empty()) { remainder.number = "0";}

        return { quotient, remainder };
    }// 实现大整数的除法
};  //class BigInteger

int main() {
    BigInteger num1("1235"); // 初始化被除数
    BigInteger num2("12");   // 初始化除数
    cout << "Num1:" << num1.toString() << endl;
    cout << "Num2;" << num2.toString() << endl;

    BigInteger r2 = num1.add(num2);
    cout << "Add:" << r2.toString() << endl;
    r2 = num1.subtract(num2);
    cout << "Subtract:" << r2.toString() << endl;

    // 试验乘法
    BigInteger product = num1.multiply(num2);
    cout << "Multiply: " << product.toString() << endl;

    std::pair<BigInteger, BigInteger> result = num1.divide(num2); // 执行除法运算
    // 输出商和余数
    std::cout << "Quotient: " << result.first.toString() << std::endl;
    std::cout << "Remainder: " << result.second.toString() << std::endl;
    return 0;
}//main()