microPython的源码解析之 mpz.c

最新推荐文章于 2024-08-09 15:52:48 发布
最新推荐文章于 2024-08-09 15:52:48 发布
阅读量901 收藏 30
点赞数 20
分类专栏： micropython 文章标签： c语言 开发语言 micropython python 嵌入式硬件
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zhangzhechun/article/details/137366141
版权
本文深入解析MicroPython的mpz.c源码，介绍其在微控制器环境中实现的任意精度整数运算，包括初始化、比较、加减乘除、位运算等功能。通过理解这一核心组件，有助于掌握Python解析器的实现逻辑。
摘要由CSDN通过智能技术生成

MicroPython 是一种适用于微控制器和其他受限环境的 Python 编程语言的实现。它旨在提供与 Python 3 语言的紧密兼容，同时考虑到内存和计算资源的限制。MicroPython 库是这门语言的核心组成部分，提供了一系列的模块和函数，使得开发者能够在硬件上执行各种任务。
下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.

microPython Python最小内核源码解析

以上代码实现了多种数学运算，包括位运算、乘法、除法、取模、幂运算等，以及将大整数转换为字节序列和字符串的功能。

#include <string.h>
#include <assert.h>

// 引入大整数库的头文件
#include "py/mpz.h"

#if MICROPY_LONGINT_IMPL == MICROPY_LONGINT_IMPL_MPZ

// 定义数字的大小和掩码等常量
#define DIG_SIZE (MPZ_DIG_SIZE) // 每个数字的大小
#define DIG_MASK ((MPZ_LONG_1 << DIG_SIZE) - 1) // 单个数字的掩码
#define DIG_MSB  (MPZ_LONG_1 << (DIG_SIZE - 1)) // 最高位掩码
#define DIG_BASE (MPZ_LONG_1 << DIG_SIZE) // 进制基数

/*
mpz 是一个任意精度整数类型，具有公共 API。

mpn 函数对非负整数进行操作，这些整数由一系列广义数字表示（例如，每个数字一个字）。
您还需要单独指定数组的长度。
没有公开的 mpn API。相反，这些函数被 mpz 用来实现其功能。

整数值以小端格式存储（第一个数字在内存中最先）。

规范化的定义是什么？
*/

// 移除数字数组尾部的零
static size_t mpn_remove_trailing_zeros(mpz_dig_t *oidig, mpz_dig_t *idig) {
   
    for (--idig; idig >= oidig && *idig == 0; --idig) {
   
    }
    return idig + 1 - oidig;
}

// 比较 i 和 j
// 返回 i - j 的符号
// 假设 i 和 j 已经规范化
static int mpn_cmp(const mpz_dig_t *idig, size_t ilen, const mpz_dig_t *jdig, size_t jlen) {
   
    if (ilen < jlen) {
   
        return -1;
    }
    if (ilen > jlen) {
   
        return 1;
    }

    for (idig += ilen, jdig += ilen; ilen > 0; --ilen) {
   
        mpz_dbl_dig_signed_t cmp = (mpz_dbl_dig_t)*(--idig) - (mpz_dbl_dig_t)*(--jdig);
        if (cmp < 0) {
   
            return -1;
        }
        if (cmp > 0) {
   
            return 1;
        }
    }

    return 0;
}

// 计算 i = j << n
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 已经规范化；假设 n > 0
// 可以有 i 和 j 指向相同的内存
static size_t mpn_shl(mpz_dig_t *idig, mpz_dig_t *jdig, size_t jlen, mp_uint_t n) {
   
    // 计算 n 需要移动的位数和部分位数
    mp_uint_t n_whole = (n + DIG_SIZE - 1) / DIG_SIZE;
    mp_uint_t n_part = n % DIG_SIZE;
    if (n_part == 0) {
   
        n_part = DIG_SIZE;
    }

    // 从高位开始移动数字
    idig += jlen + n_whole - 1;
    jdig += jlen - 1;

    // 进行位移
    mpz_dbl_dig_t d = 0;
    for (size_t i = jlen; i > 0; i--, idig--, jdig--) {
   
        d |= *jdig;
        *idig = (d >> (DIG_SIZE - n_part)) & DIG_MASK;
        d <<= DIG_SIZE;
    }

    // 存储剩余的位
    *idig = (d >> (DIG_SIZE - n_part)) & DIG_MASK;
    idig -= n_whole - 1;
    memset(idig, 0, (n_whole - 1) * sizeof(mpz_dig_t));

    // 计算结果的长度
    jlen += n_whole;
    while (jlen != 0 && idig[jlen - 1] == 0) {
   
        jlen--;
    }

    // 返回结果的长度
    return jlen;
}

// 计算 i = j >> n
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 已经规范化；假设 n > 0
// 可以有 i 和 j 指向相同的内存
static size_t mpn_shr(mpz_dig_t *idig, mpz_dig_t *jdig, size_t jlen, mp_uint_t n) {
   
    mp_uint_t n_whole = n / DIG_SIZE;
    mp_uint_t n_part = n % DIG_SIZE;

    if (n_whole >= jlen) {
   
        return 0;
    }

    jdig += n_whole;
    jlen -= n_whole;

    for (size_t i = jlen; i > 0; i--, idig++, jdig++) {
   
        mpz_dbl_dig_t d = *jdig;
        if (i > 1) {
   
            d |= (mpz_dbl_dig_t)jdig[1] << DIG_SIZE;
        }
        d >>= n_part;
        *idig = d & DIG_MASK;
    }

    if (idig[-1] == 0) {
   
        jlen--;
    }

    return jlen;
}

// 计算 i = j + k
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 和 k 已经规范化；假设 jlen >= klen
// 可以有 i, j, k 指向相同的内存
static size_t mpn_add(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen) {
   
    mpz_dig_t *oidig = idig;
    mpz_dbl_dig_t carry = 0;

    jlen -= klen;

    for (; klen > 0; --klen, ++idig, ++jdig, ++kdig) {
   
        carry += (mpz_dbl_dig_t)*jdig + (mpz_dbl_dig_t)*kdig;
        *idig = carry & DIG_MASK;
        carry >>= DIG_SIZE;
    }

    for (; jlen > 0; --jlen, ++idig, ++jdig) {
   
        carry += *jdig;
        *idig = carry & DIG_MASK;
        carry >>= DIG_SIZE;
    }

    if (carry != 0) {
   
        *idig++ = carry;
    }

    return idig - oidig;
}

// 计算 i = j - k
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 和 k 已经规范化；假设 j >= k
// 可以有 i, j, k 指向相同的内存
static size_t mpn_sub(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen) {
   
    mpz_dig_t *oidig = idig;
    mpz_dbl_dig_signed_t borrow = 0;

    jlen -= klen;

    for (; klen > 0; --klen, ++idig, ++jdig, ++kdig) {
   
        borrow += (mpz_dbl_dig_t)*jdig - (mpz_dbl_dig_t)*kdig;
        *idig = borrow & DIG_MASK;
        borrow >>= DIG_SIZE;
    }

    for (; jlen > 0; --jlen, ++idig, ++jdig) {
   
        borrow += *jdig;
        *idig = borrow & DIG_MASK;
        borrow >>= DIG_SIZE;
    }

    return mpn_remove_trailing_zeros(oidig, idig);
}

// 以下代码块在 MICROPY_OPT_MPZ_BITWISE 被定义时才会编译
#if MICROPY_OPT_MPZ_BITWISE

// 计算 i = j & k
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 和 k 已经规范化；假设 jlen >= klen (jlen 参数实际上不需要)
// 可以有 i, j, k 指向相同的内存
static size_t mpn_and(mpz_dig_t *idig, const mpz_dig_t *jdig, const mpz_dig_t *kdig, size_t klen) {
   
    mpz_dig_t *oidig = idig;

    for (; klen > 0; --klen, ++idig, ++jdig, ++kdig) {
   
        *idig = *jdig & *kdig;
    }

    return mpn_remove_trailing_zeros(oidig, idig);
}

#endif

// 计算 i = -((-j) & (-k)) = ~((~j + 1) & (~k + 1)) + 1
// i = (j & (-k)) = (j & (~k + 1)) =  (j & (~k + 1))
// i = (-j) & k) = ((~j + 1) & k) =  ((~j + 1)&   k)
// 计算通用形式：
// i = (im ^ (((j ^ jm) + jc) & ((k ^ km) + kc))) + ic  where Xm = Xc == 0 ? 0 : DIG_MASK
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 和 k 已经规范化；假设 jlen >= klen
// 可以有 i, j, k 指向相同的内存
static size_t mpn_and_neg(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen,
    mpz_dbl_dig_t carryi, mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
   
    mpz_dig_t *oidig = idig;
    mpz_dig_t imask = (0 == carryi) ? 0 : DIG_MASK;
    mpz_dig_t jmask = (0 == carryj) ? 0 : DIG_MASK;
    mpz_dig_t kmask = (0 == carryk) ? 0 : DIG_MASK;

    for (; jlen > 0; ++idig, ++jdig) {
   
        carryj += *jdig ^ jmask;
        carryk += (--klen <= --jlen) ? (*kdig++ ^ kmask) : kmask;
        carryi += ((carryj & carryk) ^ imask) & DIG_MASK;
        *idig = carryi & DIG_MASK;
        carryk >>= DIG_SIZE;
        carryj >>= DIG_SIZE;
        carryi >>= DIG_SIZE;
    }

    if (0 != carryi) {
   
        *idig++ = carryi;
    }

    return mpn_remove_trailing_zeros(oidig, idig);
}

#if MICROPY_OPT_MPZ_BITWISE

// 计算 i = -((-j) | (-k)) = ~((~j + 1) | (~k + 1)) + 1
// i = -(j | (-k)) = -(j | (~k + 1)) = ~(j | (~k + 1)) + 1
// i = -((-j) | k) = -((~j + 1) | k) = ~((~j + 1) | k) + 1
// 计算通用形式：
// i = ~(((j ^ jm) + jc) | ((k ^ km) + kc)) + 1  where Xm = Xc == 0 ? 0 : DIG_MASK
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 和 k 已经规范化；假设 jlen >= klen
// 可以有 i, j, k 指向相同的内存

static size_t mpn_or_neg(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen,
    mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
   
    mpz_dig_t *oidig = idig;
    mpz_dbl_dig_t carryi = 1;
    mpz_dig_t jmask = (0 == carryj) ? 0 : DIG_MASK;
    mpz_dig_t kmask = (0 == carryk) ? 0 : DIG_MASK;

    for (; jlen > 0; ++idig, ++jdig) {
   
        carryj += *jdig ^ jmask;
        carryk += (--klen <= --jlen) ? (*kdig++ ^ kmask) : kmask;
        carryi += ((carryj | carryk) ^ DIG_MASK) & DIG_MASK;
        *idig = carryi & DIG_MASK;
        carryk >>= DIG_SIZE;
        carryj >>= DIG_SIZE;
        carryi >>= DIG_SIZE;
    }

    // 至少 j 或 k 之一必须是非零的，所以上面的循环至少运行一次。
    // 如果 carryi 在这里不为零，它必须在每次循环迭代结束时都为零。
    // 因此，carryi 必须每次都溢出，即 carryi += 0xff..ff。
    // 所以 carryj|carryk 必须在每次迭代中在 DIG_MASK 位上为零。
    // 但考虑到 j,k 所有可能的符号情况，这是不可能的。
    assert(carryi == 0);

    return mpn_remove_trailing_zeros(oidig, idig);
}

#else

// 计算 i = -((-j) | (-k)) = ~((~j + 1) | (~k + 1)) + 1
// i = -(j | (-k)) = -(j | (~k + 1)) = ~(j | (~k + 1)) + 1
// i = -((-j) | k) = -((~j + 1) | k) = ~((~j + 1) | k) + 1
// 计算通用形式：
// i = ~(((j ^ jm) + jc) | ((k ^ km) + kc)) + 1  where Xm = Xc == 0 ? 0 : DIG_MASK
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 和 k 已经规范化；假设 jlen >= klen
// 可以有 i, j, k 指向相同的内存

static size_t mpn_or_neg(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen,
    mpz_dbl_dig_t carryi, mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk) {
   
    mpz_dig_t *oidig = idig;
    mpz_dig_t imask = (0 == carryi) ? 0 : DIG_MASK;
    mpz_dig_t jmask = (0 == carryj) ? 0 : DIG_MASK;
    mpz_dig_t kmask = (0 == carryk) ? 0 : DIG_MASK;

    for (; jlen > 0; ++idig, ++jdig) {
   
        carryj += *jdig ^ jmask;
        carryk += (--klen <= --jlen) ? (*kdig++ ^ kmask) : kmask;
        carryi += ((carryj | carryk) ^ imask) & DIG_MASK;
        *idig = carryi & DIG_MASK;
        carryk >>= DIG_SIZE;
        carryj >>= DIG_SIZE;
        carryi >>= DIG_SIZE;
    }

    // 参见上面 mpn_or_neg 的注释，为什么 carryi 必须为零。
    assert(carryi == 0);

    return mpn_remove_trailing_zeros(oidig, idig);
}

#endif

#if MICROPY_OPT_MPZ_BITWISE

// 计算 i = j ^ k
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 和 k 已经规范化；假设 jlen >= klen
// 可以有 i, j, k 指向相同的内存
static size_t mpn_xor(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen) {
   
    mpz_dig_t *oidig = idig;

    jlen -= klen;

    for (; klen > 0; --klen, ++idig, ++jdig, ++kdig) {
   
        *idig = *jdig ^ *kdig;
    }

    for (; jlen > 0; --jlen, ++idig, ++jdig) {
   
        *idig = *jdig;
    }

    return mpn_remove_trailing_zeros(oidig, idig);
}

#endif

// 计算 i = (-j) ^ (-k) = ~(j - 1) ^ ~(k - 1) = (j - 1) ^ (k - 1)
// i = -(j ^ (-k)) = -(j ^ ~(k - 1)) = ~(j ^ ~(k - 1)) + 1 = (j ^ (k - 1)) + 1
// i = -((-j) ^ k) = -(~(j - 1) ^ k) = ~(~(j - 1) ^ k) + 1 = ((j - 1) ^ k) + 1
// 计算通用形式：
// i = ((j - 1 + jc) ^ (k - 1 + kc)) + ic
// 返回 i 中的数字个数
// 假设 i 的内存足够；假设 j 和 k 已经规范化；假设 jlen >= klen
// 可以有 i, j, k 指向相同的内存
static size_t mpn_xor_neg(mpz_dig_t *idig, const mpz_dig_t *jdig, size_t jlen, const mpz_dig_t *kdig, size_t klen,
    mpz_dbl_dig_t carryi, mpz_dbl_dig_t carryj, mpz_dbl_dig_t carryk){
   
    mpz_dig_t *oidig = idig;

    for (; jlen > 0; ++idig, ++jdig) {
   
        carryj += *jdig + DIG_MASK;
        carryk += (--klen <= --jlen) ? (*kdig++ + DIG_MASK) : DIG_MASK;
        carryi += (carryj ^ carryk) & DIG_MASK;
        *idig = carryi & DIG_MASK;
        carryk >>= DIG_SIZE;
        carryj >>= DIG_SIZE;
        carryi >>= DIG_SIZE;
    }

    if (0 != carryi) {
   
        *idig++ = carryi;
    }

    return
最低0.47元/天 解锁文章
openwin_top
关注
  • 20
    点赞
  • 踩
  • 30
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
RSA加/解密算法--python实现
dzn的博客
06-01 1975
首先，使用了gmp大数库python的封装接口，但支
python大整数开方——gmpy安装
渔父歌的博客
06-21 7089
https://github.com/aleaxit/gmpy/releases/tag/gmpy2-2.1.0a1 打开上面的网址选择对应的版本下载，下载好之后使用pip安装wheel文件。 注意版本号一定要严格对照，否则可能会安装失败。 以gmpy2-2.1.0a1-cp36-cp36m-win32.whl为例，cp36表示python36版本，win32表示windows32为版本的解释器，...
mpz 类型 [python]
amber_o0k的博客
09-07 2128
在用到这两个库的函数时可能会返回mpz类型的结果，但mpz与int类型不同，主要用int（）转换即可。
Python gmpy2 mpz Methods
Q_U_A_R_T_E_R的博客
03-07 2318
写在前面： 此博客仅用于记录个人学习进度，学识浅薄，若有错误观点欢迎评论区指出。欢迎各位前来交流。（部分材料来源网络，若有侵权，立即删除） Python gmpy2 mpz Methodsmpz方法 mpz方法 bit_clear(…) x.bit_clear(n) 返回x的一个副本，其位数n设置为0。 bit_flip(…) x.bit_flip(n)返回x的一个副本，其中位n被倒置。 bit_length(…) x.bit_length() 返回x的radix-2表示法中的有效位数。为了与P
python实现RSA算法
abtgu的博客
05-08 1358
import gmpy2 from gmpy2 import mpz import binascii rs = gmpy2.random_state() #生成大素数（0-2^1024位） def create_prime(): p = gmpy2.mpz_urandomb(rs,1024) #随机生成一个0~2^1024位的数 while not gmpy2....
microPython的源码解析之 mpprint.c
zhangzhechun的专栏
04-04 589
MicroPython 库是这门语言的核心组成部分，提供了一系列的模块和函数，使得开发者能够在硬件上执行各种任务。这段代码是MicroPython的打印函数实现，它提供了丰富的格式化选项，可以打印各种类型的数据。下面将通过系列文章,逐一解读microPython,以便让读者了解掌握microPython的整个核心逻辑.,以便读者可以透过这个Python的最小内核,掌握Python解析器的核心实现逻辑,学习世界上最优秀的源码设计之一.- 打印字符串并进行格式化的函数。- 打印格式化字符串的函数。
mpz.im:我的个人网站和由盖茨比提供支持的东西。
04-29
gatsby-starter-default 默认的盖茨比启动器。 有关项目结构的概述，请参阅。 安装 确保已安装Gatsby CLI程序： npm install --global gatsby-cli 并从您的CLI运行： gatsby new gatsby-example-site ...
rsa.rar_mpz_millerrabin_rsa_脉动阵列
09-24
在给定的“rsa”文件中，可能包含了使用GMP库实现的RSA算法代码，这部分代码可能包含了用C语言编写的函数，用于执行RSA的加解密操作，以及利用`mpz_millerrabin`进行素数检测。而“gmp”文件可能包含了GMP库的头文件...
font_2439706_2qun4mpz1lt.woff
09-16
font_2439706_2qun4mpz1lt.woff
gmp.tar.gz
03-30
GMP，全称为GNU Multiple Precision Arithmetic Library，是一个用于C和C++编程语言的开源库，专门处理高精度算术运算。这个压缩包“gmp.tar.gz”包含了GMP的源代码以及在Deepin 5.11操作系统上编译好的安装包。...
RSAc.rar_rsac++
09-19
- **扩展欧几里得算法**：计算e的模逆元d，GMP库提供了`mpz_invert`函数。 - **加密解密函数**：编写相应的函数，接收明文/密文和公钥/私钥，执行加密和解密操作。 3. **注意事项** - 安全性：RSA的安全性依赖于...
在python中用gmpy实现高精度计算
stereohomology
02-27 1万+
https://code.google.com/p/gmpy/wiki/UsingGmpy2AndMpfr  点击打开链接 Using gmpy2 and mpfr.  Documentation Updated Jul 5, 2012 by casevh Using gmpy2 and mpfr Overview MPFR is
Python3中gmpy2常用的函数及功能
热门推荐
Cony_14的博客
11-15 1万+
import gmpy2 ''' 问题描述，求d n=pq phi =(p-1)(q-1) ed=1 mod phi ''' ''' 常用的库 import libnum libnum.n2s(n)数字转字符串 libnum.s2n(s) gmpy2.mpz(n)初始化一个大整数 n=invert(m,phi)求mod phi的逆元 pow(m,e,n)求c^d mod n gmpy2.is...
RSA算法之实现篇（Python版）
那些零零散散的算法
06-21 9974
RSA中的密钥长度指的是公钥的长度，目前主流的公钥长度为1024、2048以及4096位。由于已经有768位公钥被成功分解的先例，所以低于1024位的公钥都被认为是不安全的。而C++自带的基本类型远远无法满足RSA的运算需求，所以RSA算法的实现必须依赖于高精度整型运算。本文旨在介绍RSA算法的实现流程，不会对于涉及到的每一个算法进行深入介绍，如果需要进一步了解的可以参考本博客的其它相关文章。
CTF 常用python库
rang的博客
12-14 1828
gmpy2库 import gmpy2 gmpy2.mpz(x)#初始化一个大整数x gmpy2.mpfr(x)#初始化一个高精度浮点数x C = gmpy2.powmod(M,e,n)#幂取模，结果是 C = (M^e) mod n d = gmpy2.invert(e,n) # 求逆元，de = 1 mod n gmpy2.is_prime(n) # 判断n是不是素数 gmpy2.gcd(a,b) # 欧几里得算法 gmpy2.gcdext(a,b) # 扩展欧几里得算法 gmpy2.i
python计算圆周率精确_Python快速计算高精度圆周率
weixin_39675728的博客
12-05 1094
################################################################# Computing pi by Binary Splitting Algorithm with GMP library. ################################################################## 经测试 计算...
GMP学习：初始化mpz数组
suki570的博客
02-14 2298
GMP库中有函数 mpz_array_init ，但是注释了 This is an obsolete function. Do not use it. mpz_array_init 的问题在于它永远不会释放分配的内存。 看到网上没有什么有关的资料，因此记录一下使用 GMP 初始化数组的方法： #include <stdio.h> #include <gmp.h> int...
【启明智显分享】工业级Model3C芯片方案4.3寸触摸串口彩屏打造超高性价比智能破壁机
最新发布
ami82的博客
08-09 633
本文采用国产HMI芯片Model3C为主控芯片，驱动4.3寸触摸彩屏，实现直观显示和操作功能，板载蜂鸣器给予用户智能提醒，拓展WIFI/蓝牙模块连接手机APP/小程序，云菜谱帮助用户制作美食，并分析健康数据。Model3C芯片是一款基于RISC-V的高性能、国产自主、工业级高清显示与智能控制MCU，PNG/JPEG解码引擎提升信息处理能力，2D加速提升破壁机整体的响应速度。工业级品质，个位数价格，高性能低功耗，且具备超高性价比，让破壁机的质量与成本之间实现平衡。
需要本地设备上有mpz.h的头文件吗
07-16
是的，使用 GMP 库进行大数运算时，需要在本地设备上安装 GMP 库，并且确保有正确的头文件引用。 首先，需要从 GMP 官方网站（https://gmplib.org/）下载适用于您的操作系统的 GMP 库，并按照其提供的安装说明进行安装。 安装完成后，在您的 C 代码中，需要包含 `gmp.h` 头文件来使用 GMP 库提供的函数和数据类型。确保在编译时正确指定 GMP 库的路径和链接选项。 例如，在 Linux 系统上使用 GCC 编译器进行编译时，可以使用以下命令： ```bash gcc -o program program.c -lgmp ``` 这将编译名为 `program.c` 的源文件，并链接 GMP 库（使用 `-lgmp` 选项）。确保 `gmp.h` 文件所在的目录在编译器的搜索路径中。 如果您使用的是其他编译器或操作系统，请参考相应的文档和指南，确保正确地安装和链接 GMP 库，并包含正确的头文件路径。 通过这样的设置，您就可以在本地设备上使用 GMP 库进行大数运算，并且可以包含 `mpz.h` 头文件来使用 GMP 提供的数据类型和函数。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

openwin_top

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值