fmpz_vec.h

Returns an array of len integers, all zero, allocated with flint_calloc (an fmpz with value zero is a zero word).

Clears the len entries of vec and frees the array.

Initialise vec to a vector of length len with all entries zero, respectively release its memory.

Returns the length of vec.

Return a pointer to entry i, which can be used as an fmpz_t. The index is not checked.

Ensures that vec has room for at least len entries, at least doubling the allocation when it grows. The length is not changed.

Sets the length to len \ge 0. Entries beyond a smaller new length are set to zero (releasing their memory); entries added by a larger new length are zero.

Sets res to a copy of src.

Append f to vec, increasing its length by one.

Set the entries to random integers of at most bits bits, generated by fmpz_randtest (respectively fmpz_randtest_unsigned). With probability 1/2 the vector is made sparse, with a random proportion of zero entries, to exercise special cases in tests.

Return b or -b, where b is the maximum of the bit sizes of the absolute values of the entries; the sign is negative if some entry is negative. The _ref version is a simple reference implementation used in tests.

Returns the sum of the bit sizes fmpz_bits of the entries.

Sets *sumabs to the bit size of the sum of the absolute values of the entries, and *maxabs to the bit size of the largest absolute value.

Returns the maximum number of limbs of the absolute values of the entries, and 0 if all entries are zero.

_fmpz_vec_height sets height to the largest absolute value of an entry (the \ell^\infty norm), which is 0 for len = 0. _fmpz_vec_height_index returns the index of an entry of largest absolute value and requires len \ge 1.

Print the vector to file or stdout as the length, two spaces and the entries separated by single spaces; a vector of length zero is printed as 0. Return a positive value on success and a nonpositive value on failure.

Read a vector in the format of _fmpz_vec_fprint from file or stdin. Return a positive value on success and a nonpositive value on failure.

Sets res[i] to the residue in [0, n) of poly[i] modulo the modulus n of mod.

Sets res[i] to the symmetric representative in (-n/2, n/2] of the reduced residue poly[i] modulo n.

Returns an exponent e and sets appv[i] to doubles with appv[i]\cdot 2^e \approx vec[i], where e is the largest exponent of fmpz_get_d_2exp over the entries, so that all appv[i] have absolute value less than 1. Entries much smaller than the largest lose precision or become 0.

Convert between a vector of integers and the coefficient arrays of the Schönhage–Strassen FFT of the fft module, used by fmpz_poly_mul_SS. _fmpz_vec_get_fft writes each of the length entries to coeffs_f[i] as l limbs plus one limb for overflow, negative values in two's complement over the l + 1 limbs (the entries must fit in l limbs). The conversion is done in parallel when threads are available. _fmpz_vec_set_fft converts fully reduced residues of limbs limbs back, to the range [-N, N] with N = 2^{\mathtt{FLINT\_BITS} \cdot \mathit{limbs} - 1} if sign is nonzero and to [0, 2N] otherwise.

Copy vec2 to vec1, swap the entries of the two vectors (exchanging words, without copying limbs), and set all entries to zero.

Return whether the two vectors are equal, respectively whether all entries are zero.

Set vec1 to the entrywise maximum (minimum) of vec2 and vec3, respectively of vec1 and vec2.

Sorts the entries in increasing order (with qsort and fmpz_cmp).

Set res to the entrywise sum, respectively difference, of the vectors of length len2.

Set vec1 to the negation, respectively the entrywise absolute value, of vec2.

Set vec1 to vec2 multiplied by the scalar (x, c or 2^{\mathit{exp}}).

Add (respectively subtract) the second vector multiplied by the scalar to (from) the first.

Add (respectively subtract) vec2 multiplied by c 2^{\mathit{exp}} to (from) vec1.

Set vec1 to vec2 divided by the nonzero scalar, assuming that every division is exact (not checked).

Sets the r \times c array B to A divided exactly by x, where row i of B (respectively A) is the c entries starting at B + i * Bstride (A + i * Astride). Exactness is not checked. In-place operation is allowed with B = A and Bstride = Astride.

Set vec1 to the quotients of the entries of vec2 by c \ne 0, rounded towards -\infty (fdiv) or towards zero (tdiv); see Division and rounding conventions.

Set vec1 to the quotients of the entries by 2^{\mathit{exp}}, rounded towards -\infty or towards zero, respectively to the remainders of floor division, which lie in [0, 2^{\mathit{exp}}).

Reduce the entries modulo p > 0, to [0, p), respectively to the symmetric range (-p/2, p/2].

Sets res[j] for 0 \le j < len to the integer congruent to residues[i][j] modulo primes[i] for all 0 \le i < num_primes, in [0, M) if sign is 0 and in (-M/2, M/2] otherwise, where M is the product of the pairwise coprime word-size moduli. The precomputation is shared by all entries; each entry is reconstructed as by fmpz_multi_CRT_ui (Chinese remaindering).

Sets res to the sum of the entries.

Set res to the product of the entries of an array of integers, respectively of words; the empty product is 1. Both use a balanced product tree (Binary splitting and product trees), with leaves of at most 3 integers, respectively 15 words, multiplied in sequence.

Set res to the nonnegative GCD of the entries (0 for a zero or empty vector), respectively of the entries and inp, which allows the common content of several vectors to be accumulated. The computation stops as soon as the GCD becomes 1.

Sets res to the nonnegative least common multiple of the entries: 0 if an entry is zero and 1 for an empty vector.

Set res to s + (-1)^{\mathit{subtract}} \sum_{i=0}^{\mathit{len}-1} a_i b_i, where s is initial (or 0 if initial is NULL), subtract is 0 or 1, and b is read in reverse order (b_{len-1-i} in place of b_i) if reverse is 1. res may alias initial but not an entry of a or b. The _naive version is a loop of fmpz_addmul used in tests.

Sets res to \sum_i vec1[i] vec2[i]; equivalent to _fmpz_vec_dot_general(res, NULL, 0, vec1, vec2, 0, len2).