PARI/GP

### realbitprecision

%1 = 128

### realprecision

%1 = 38

gp > default(realprecision, 100)

gp > default(realprecision)

%3 = 115

To do: Why does `default(realprecision, 100)`

set `realprecision`

to 115?

### timer

%1 = 0

gp > default(timer, 1)

gp > default(timer)

%3 = 1

### digits(\(x\), {\(b\) = \(10\)})

3.6.34 digits(\(x\), {\(b\) = \(10\)}). Outputs the vector of the digits of |\(x\)| in base \(b\), where \(x\) and \(b\) are integers (\(b\) = 10 by default). See `fromdigits`

for the reverse operation.

%1 = [1, 2, 3]

\(\space\)

gp > digits(10)

%2 = [1, 0]

\(\space\)

gp > digits(10, 2) \\ base 2

%3 = [1, 0, 1, 0]

By convention, 0 has no digits.

%1 = []

### divisors(\(x\), {flag = 0})

3.8.26 divisors(x, {flag = 0}). Creates a row vector whose components are the divisors of x. The factorization of x (as output by factor) can be used instead. If flag = 1, return pairs [d; factor(d)].

%1 = [1, 2, 3, 4, 6, 12]

\(\space\)

gp > divisors(12, 1) \\ include their factorization

%2 = [[1, matrix(0,2)], [2, Mat([2, 1])], [3, Mat([3, 1])], [4, Mat([2, 2])], [6, [2, 1; 3, 1]], [12, [2, 2; 3, 1]]]

\(\space\)

gp > divisors(x^4 + 2*x^3 + x^2) \\ also works for polynomials

%3 = [1, x, x^2, x + 1, x^2 + x, x^3 + x^2, x^2 + 2*x + 1, x^3 + 2*x^2 + x, x^4 + 2*x^3 + x^2]

### floor(\(x\))

3.6.36 floor(\(x\)). Floor of \(x\). When \(x\) is in \(\mathbb{R}\), the result is the largest integer smaller than or equal to \(x\). Applied to a rational function, floor(\(x\)) returns the Euclidean quotient of the numerator by the denominator.

### frac(\(x\))

3.6.37 frac(\(x\)). Fractional part of \(x\). Identical to \(x\) floor(\(x\)). If \(x\) is real, the result is in \([0, 1[\).

### fromdigits(\(x\), {\(b\) = \(10\)})

3.6.38 fromdigits(\(x\), {\(b\) = 10}). Gives the integer formed by the elements of \(x\) seen as the digits of a number in base \(b\) (\(b\) = 10 by default). This is the reverse of `digits`

.

### length(\(x\))

3.6.40 length(\(x\)). Length of \(x\); #\(x\) is a shortcut for length(\(x\)). This is mostly useful for

- vectors: dimension (0 for empty vectors),
- lists: number of entries (0 for empty lists),
- matrices: number of columns,
- character strings: number of actual characters (without trailing \0, should you expect it from C
`char*`

).

%1 = 8

gp > gp > #”a string”

%2 = 8

gp > length([3, 2, 1])

%3 = 3

gp > #[3, 2, 1]

%4 = 3

gp > length([])

%5 = 0

gp > #[]

%6 = 0

gp > length(matrix(2, 5))

%7 = 5

gp > #matrix(2, 5)

%8 = 5

gp > L = List([1, 2, 3, 4]); length(L)

%9 = 4

gp > L = List([1, 2, 3, 4]); #L

%10 = 4

### precision(\(x\), {\(n\)})

3.6.49 precision(\(x\), {\(n\)}).

### random({\(n\) = \(2^{31}\)})

3.6.50 random({\(n\) = \(2^{31}\)}).

### round(\(x\), {&\(e\)})

3.6.52 round(\(x\), {&\(e\)}).

### simplify(\(x\))

3.6.55 simplify(\(x\)).

### truncate(\(x\), {&\(e\)})

3.6.58 truncate(\(x\), {&\(e\)}).

### variables({\(x\)})

3.6.62 variables({\(x\)}).