PARI/GP教程：自由软件计算工具

需积分: 12 6 浏览量更新于2024-07-15 收藏 377KB PDF 举报

PARI Tutorial.pdf是一份关于PARI/GP的教程，PARI/GP是一款专门用于数论计算的强大工具，由C.Batut、K.Belabas、D.Bernardi、H.Cohen和M.Olivier等人在法国波尔多第一大学的数学实验室A2X（U.M.R.9936 C.N.R.S.）开发。该教程提供了对PARI/GP语言的详细介绍，包括其设计目的、语法特性以及如何利用它进行高级数值计算和符号计算。 PARI/GP是基于GNU公共许可证的自由软件，这意味着用户可以根据GNU通用公共许可证的规定自由地复制、分发和修改此软件。这份教程包含了以下主要内容： 1. **概述与介绍**：教程首先介绍了PARI/GP的背景和目标，它是专为数论和代数几何等领域设计的，特别适合处理大整数和多项式运算，以及模形式、椭圆曲线等高级数学对象。 2. **安装与环境设置**：教程详细指导了如何下载并安装PARI/GP，包括访问官方primary ftp站点ftp://pari.math.u-bordeaux.fr/pub/pari/获取最新版本。 3. **基本语法与命令**：教程涵盖了PARI/GP的基本数据类型（如整数、有理数、浮点数、矩阵等）、变量声明、表达式和函数的使用，以及输入输出操作。 4. **数值计算**：这部分讲解了如何在PARI/GP中执行高效的数值计算，包括求解方程、计算行列式、矩阵运算等实用技巧。 5. **符号计算与高级功能**：教程深入探讨了PARI/GP的符号计算能力，如多项式操作、根式简化、代数对象的构造以及高级数论函数的调用。 6. **编程与调试**：对于那些希望扩展PARI/GP功能的用户，教程还涉及如何编写和调试自定义函数，以及PARI/GP的错误处理机制。 7. **版权与许可**：最后，教程强调了版权和许可条款，确保用户在使用PARI/GP时尊重软件的开源性质，遵守GNU通用公共许可证的要求。通过阅读这份教程，读者不仅可以学习到PARI/GP的基础知识，还能掌握如何有效地利用它进行复杂的数学研究和问题解决。由于PARI/GP在现代密码学、数论分析以及计算机代数等领域广泛应用，掌握这门工具对于专业数学家和研究人员来说具有很高的价值。

A c omplex number has a real part and an imaginary part (who would have guessed?). However,

beware that when the imaginary part is the exact integer zero, it is not printed, but the complex

number is not converted to a real number. Hence it may look like a real number without being

one, and this may cause some confusion in programs which expect real numbers. For example,

type n = 3 + I - I. The answer reads 3, as exp ec ted. But it is still a complex number. Check

it with type(n). Hence if you then type (1+x)^n, instead of getting the polynomial 1 + 3*x +

3*x^2 + x^3 as expected, you obtain a power series. Worse, when you try to apply an arithmetic

function, say the Euler totient function (known as eulerphi to GP), you get a sententious error

message recalling you that “arithmetic functions want integer arguments”. You would have guessed

yourself, but the message is diﬃcult to understand since 3 looks like a genuine integer!!! (Please

read again if this is not clear. It is a common source of incomprehension).

Similarly, 3 + x - x is not the integer 3 but a constant polynomial (in the variable x), equal

to 3 = 3x

If you want the ﬁnal expression to be in the simplest form possible (for example before applying

an arithmetic function, or simply because things will go faster afterwards), apply the function

simplify to the result. In fact, by default GP does this automatically at the end of a GP command.

Note that it does not simplify in intermediate expressions. This default can be switched oﬀ and on

by the command \y. This is why I asked you to type this before starting.

2) As already stated, power series expansions are always implicitly around x = 0. When we

wanted them around x = a, we replaced x by z + a in the function we wanted to expand. For

complicated functions, it may be simpler to use the substitution function subst. For example, if

p = 1 / (x^4 + 3*x^3 + 5*x^2 - 6*x + 7), you may not want to retype this, replacing x by

z + a, so you can write subst(p, x, z+a) (look up the exact description of the subst function).

Now try typing p = 1 + x + x^2 + O(x^10), then subst(p, x, z+1). Do you understand

why you get an error message?

3. The Remaining PARI Types.

Let’s talk some more about the basic PARI types.

Type p = x * exp(-x). As expected, you get the power series expansion to 16 terms (if

you have not changed the default). Now type pr = serreverse(p). You are asking here for the

reversion of the p ower series p, in other words the inverse function. This is possible only for power

series whose ﬁrst non-zero coeﬃcient is that of x

. To check the correctness of the result, you can

type subst(p, x, pr) or subst(pr, x, p) and you should get back x + O(x^17).

Now the coeﬃcients of pr obey a very simple formula. First, we would like to multiply the

coeﬃcient of x^n by n! (in the case of the exponential function, this would simplify things con-

siderably!). The PARI function serlaplace does just that. So type ps = serlaplace(pr). The

coeﬃcients now become integers, which can be immediately recognized by inspection. The coeﬃ-

cient of x

is now equal to n

n−1

. In other words, we have

pr =

n≥1

n−1

Do you know how to prove this? (If you have never seen this, the proof is diﬃcult.)

Of course PARI knows about vectors (rows and columns are distinguished, even though math-

ematically there is no diﬀerence) and matrices. Type for example [1,2,3,4]. This gives the row

vector whose coordinates are 1, 2, 3 and 4. If you want a column vector, type [1,2,3,4]

, the

tilde me aning of course transpose. You don’t see much diﬀerence in the output, except for the

tilde at the end. However, now type \b: lo and behold, the vector does become a column. The \b

command is used mainly for this purpose.

Type m = [a,b,c; d,e,f]. You have just entered a matrix with 2 rows and 3 columns. Note

that the matrix is entered by rows and the rows are separated by semicolons “;”. The matrix is

printed naturally in a rectangle shape. If you want it printed horizontally just as you typed it, type

\a, or if you want this type of printing to be the permanent default typ e default(output, 1).

Type default(output, 0) if you want to come back to the original default.

Now type m[1,2], m[1,], m[,2]. Are explanations necessary? (In an expression such as

m[j,k], the j always refers to the row number, and the k to the column number, and the ﬁrst

index is always 1, never 0. This default cannot be changed.)

Even b etter, type m[1,2] = 5; m (the semicolon also allows us to put several instructions on

the same line. The ﬁnal result will be the output of the last statement on the line). Now typ e

m[1,] = [15,-17,8]. No problem. Finally type m[,2] = [j,k]. You have an error message since

you have typed a row vector, while m[,2] is a column vector. If you type instead m[,2] = [j,k]

it works.

Type now h = mathilbert(20). You get the so-called “Hilbert matrix” whose coeﬃcient of

row i and column j is equal to (i +j −1)

−1

. Incidentally, the matrix h takes too much room. If you

don’t want to see it, simply type a semi-colon “;” at the end of the li ne (h = mathilbert(20);).

This is an example of a “precomputed” matrix, built into PARI. There are only a few. We will see

later an example of a much more general construction.

What is interesting about Hilbert matrices is that ﬁrst their inverses and determinants can

be computed explicitly (and the inverse has integer coeﬃcients), and second they are numerically

very unstable, which make them a severe test for linear algebra packages in numerical analysis.

Of course with PARI, no such problem can occur: since the coeﬃcients are given as rational

numbers, the computation will be done exactly, so there cannot be any numerical error. Try it.

Type d = matdet(h) (you have to b e a little patient, this is quite a complicated computation).

The result is a rational number (of course) of numerator equal to 1 and denominator having 226

decimal digits. How do I know, by the way? I did not count! Instead, simply type 1.* d. The

result is now in exponential format, and the exponent gives us the answer. Another, more natural,

way would be to simply type sizedigit(1/d).

Now type hr = 1.* h; (do not forget the semicolon, we don’t want to see all the junk!), then

dr = matdet(hr). You notice two things. First the computation, although not instantaneous, is

much faster than in the rational case. The reason for this is that PARI is handling real numbers

with 28 digits of accuracy, while in the rational case it is handling integers having up to 226 decimal

digits.

The second more important fact is that the result is terribly wrong. If you compare with

1.∗d computed earlier, which is correct, you will see that only 2 decimals agree! This catastrophic

instability is as already mentioned one of the characteristics of Hilber t matrices. In fact, the

situation is much worse than that. Type norml2(1/h - 1/hr) (the function norml2 gives the

square of the L

norm, i.e. the sum of the squares of the coeﬃcients). Again be patient since

computing 1/h will take even more time (not much) than computing matdet(h). The result is

larger than 10

, showing that some coeﬃcients of 1/hr are wrong by as much as 10

(the largest

error is in fact equal to 7.644 ·10

for the coeﬃcient of row 15 and column 14, which is a 28 digit

integer).

To obtain the correct result after rounding for the inverse, we have to use a default precision

of 56 digits (try it).

Although vectors and matrices can be entered manually, by typing explicitly their elements,

very often the elements satisfy a simple law and one uses a diﬀerent syntax. For ex ample, as-

sume that you want a vector whose i-th coordinate is equal to i

. No problem, type for example

vector(10,i, i^2) if you want a vector of length 10. Similarly, if you type

matrix(5,5,i,j, 1/(i+j-1))

you will get the Hilbert matrix of order 5 (hence the mathilbert function is redundant). The i and

j represent dummy variables which are used to number the rows and columns respectively (in the

case of a vector only one is present of course). You must not forget, in addition to the dimensions

of the vector or matrix, to indicate explicitly the names of these variables.

Warning. The letter I is reserved for the complex number e qual to the square root of −1. Hence

it is absolutely forbidden to use it as a variable. Try typing vector(10,I, I^2), the error message

that you get clearly indicates that GP does not consider I as a variable. There are two other

reserved variable names: Pi and Euler. All function names are forbidden as well. On the other

hand there is nothing special about i, pi or euler.

When creating vectors or matrices, it is often useful to use boolean operators and the if()

statement (see the section on programming for details on using this statement). Indeed, an if

expression has a value, which is of course equal to the evaluated part of the if. So for example you

can type

matrix(8,8, i,j, if ((i-j)%2, x, 0))

to get a checkerboard matrix of x and 0. Note however that a vector or matrix must be created

ﬁrst before being used. For example, it is forbidden to write

for (i = 1, 5, v[i] = 1/i)

if the vector v has not been created beforehand (for example by a v = vector(5,j,0) command).

The last PARI types which we have not yet played with are types which are closely linked to

number theory (hence people not interested in number theory can skip ahead).

The ﬁrst is the type “integer–mo dulo”. Let us see an example. Type n = 10^15 + 3. We

want to know whether this number is prime or not. Of course we could make use of the built-in

facilities of PARI, but let us do otherwise. We ﬁrst trial divide by the built-in table of primes.

We slightly cheat here and use a variant of the function factor which does exactly this. So type

factor(n, 200000) (the last argument tells factor to trial divide up to the given bound and stop

at this point. You can set it to 0 to trial divide by the full set of built-in primes, which goes up to

500000 by default).

The result is a 2 column matrix (as for all factoring functions), the ﬁrst column giving the

primes and the second their exponents. Here we get a single row, telling us that n is not divisible

by any prime up to 200000. We could now trial divide further, or even cheat completely and call

the PARI function factor without the optional second argument, but before we do this let us see

how to get an answer ourselves.

剩余45页未读，继续阅读

灰条纹酸奶

粉丝: 0
资源: 2

PARI/GP教程：自由软件计算工具

Math-Pari-2.030518.zip

网式雾化器，全球前5强生产商排名及市场份额调查数据.pdf

stl_pari

android cypari2

Avatar_Utils-1.0.6-py3-none-any.whl.zip

“人力资源+大数据+薪酬报告+涨薪调薪”

2024-2030全球及中国聚硅氮烷行业研究及十五五规划分析报告 Sample-yb.pdf

用于目标检测的一个GUI程序界面.zip

使用笔记本电脑上的无线网卡，生成wifi热点，让设备连接_ShareVirtualWiFi.zip

基于springboot的名城小区物业管理系统设计与实现.docx

最新资源