gr_vec.h – vectors over generic rings

Types and basic operations

type gr_vec_struct

type gr_vec_t

void gr_vec_init(gr_vec_t vec, slong len, gr_ctx_t ctx)

Initializes vec to a vector of length len with elements in the ring ctx. The length must be nonnegative. All entries are set to zero.

void gr_vec_clear(gr_vec_t vec, gr_ctx_t ctx)

Clears the vector vec.

GR_VEC_ENTRY(vec, i, sz)

Macro to access the i-th element in the vector vec, indexed from zero, assuming that entries have size sz. The index must be in bounds.

gr_ptr gr_vec_entry_ptr(gr_vec_t vec, slong i, gr_ctx_t ctx)

gr_srcptr gr_vec_entry_srcptr(gr_vec_t vec, slong i, gr_ctx_t ctx)

Returns a pointer to the i-th element in the vector vec, indexed from zero. The index must be in bounds.

slong gr_vec_length(const gr_vec_t vec, gr_ctx_t ctx)

Returns the length of the vector vec.

void gr_vec_fit_length(gr_vec_t vec, slong len, gr_ctx_t ctx)

Allocates space for at least len elements in the vector vec. This does not change the size of the vector.

void gr_vec_set_length(gr_vec_t vec, slong len, gr_ctx_t ctx)

Resizes the vector to length len, which must be nonnegative. The vector will be extended with zeros.

int gr_vec_set(gr_vec_t res, const gr_vec_t src, gr_ctx_t ctx)

Sets res to a copy of the vector src.

int gr_vec_append(gr_vec_t vec, gr_srcptr x, gr_ctx_t ctx)

Appends the element x to the end of vector vec.

int _gr_vec_write(gr_stream_t out, gr_srcptr vec, slong len, gr_ctx_t ctx)

int gr_vec_write(gr_stream_t out, const gr_vec_t vec, gr_ctx_t ctx)

int gr_vec_print(const gr_vec_t vec, gr_ctx_t ctx)

int gr_vec_set_str(gr_vec_t vec, const char *s, int resize, gr_ctx_t ctx)

Sets vec to the vector described by the string s, which must have the form [expr1, expr2, ..., exprn] (or [] for the empty vector). Each entry expression is parsed with gr_set_str() over ctx. Whitespace around the brackets and separators is ignored, and commas appearing inside parentheses, brackets or braces of an entry are treated as part of that entry rather than as separators. If resize is 1, vec is resized to the number of entries found. If resize is 0, returns GR_DOMAIN when that number differs from the current length of vec. Returns GR_UNABLE if s is not a well-formed list, and propagates any failure from parsing an individual entry.

int gr_vec_str_count_entries(slong *count, const char *s, gr_ctx_t ctx)

Sets count to the number of top-level entries of the bracketed list at the start of s, without evaluating them. Nesting depth of parentheses, brackets and braces is tracked so that only separators at the outermost level are counted. Any characters following the matching closing bracket are ignored. Returns GR_UNABLE if the list is not well-formed.

int _gr_vec_set_str(gr_ptr res, const char *s, slong len, gr_ctx_t ctx)

Evaluates the bracketed list at the start of s into the preallocated array res, which must hold len initialized elements, parsing each entry with gr_set_str(). Returns GR_DOMAIN if the number of entries found differs from len. Any characters following the matching closing bracket are ignored, which allows this function to be applied to a row lying within a larger matrix string.

GR_ENTRY(vec, i, size)

Macro to access the i-th entry of a gr_ptr or gr_srcptr vector vec, where each element is size bytes.

void _gr_vec_init(gr_ptr vec, slong len, gr_ctx_t ctx)

Initialize len elements of vec to the value 0. The pointer vec must already refer to allocated memory.

void _gr_vec_clear(gr_ptr vec, slong len, gr_ctx_t ctx)

Clears len elements of vec. This frees memory allocated by individual elements, but does not free the memory allocated by vec itself.

void _gr_vec_swap(gr_ptr vec1, gr_ptr vec2, slong len, gr_ctx_t ctx)

Swap the entries of vec1 and vec2.

int _gr_vec_randtest(gr_ptr res, flint_rand_t state, slong len, gr_ctx_t ctx)

int _gr_vec_set(gr_ptr res, gr_srcptr src, slong len, gr_ctx_t ctx)

truth_t _gr_vec_equal(gr_srcptr vec1, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_vec_zero(gr_ptr vec, slong len, gr_ctx_t ctx)

truth_t _gr_vec_is_zero(gr_srcptr vec, slong len, gr_ctx_t ctx)

int _gr_vec_normalise(slong *res, gr_srcptr vec, slong len, gr_ctx_t ctx)

slong _gr_vec_normalise_weak(gr_srcptr vec, slong len, gr_ctx_t ctx)

Arithmetic

int _gr_vec_neg(gr_ptr res, gr_srcptr src, slong len, gr_ctx_t ctx)

int _gr_vec_add(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx)

int _gr_vec_sub(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx)

int _gr_vec_mul(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx)

int _gr_vec_div(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx)

int _gr_vec_divexact(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx)

int _gr_vec_pow(gr_ptr res, gr_srcptr src1, gr_srcptr src2, slong len, gr_ctx_t ctx)

Binary operations applied elementwise.

int _gr_vec_add_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx)

int _gr_vec_sub_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx)

int _gr_vec_mul_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx)

int _gr_vec_div_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx)

int _gr_vec_divexact_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx)

int _gr_vec_pow_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx)

int _gr_scalar_add_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_sub_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_mul_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_div_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_divexact_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_pow_vec(gr_ptr vec1, gr_srcptr c, gr_srcptr vec2, slong len, gr_ctx_t ctx)

Binary operations applied elementwise with a fixed scalar operand.

int _gr_vec_add_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx)

int _gr_vec_sub_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx)

int _gr_vec_mul_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx)

int _gr_vec_div_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx)

int _gr_vec_divexact_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx)

int _gr_vec_pow_other(gr_ptr vec1, gr_srcptr vec2, gr_srcptr vec3, gr_ctx_t ctx3, slong len, gr_ctx_t ctx)

int _gr_other_add_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx)

int _gr_other_sub_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx)

int _gr_other_mul_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx)

int _gr_other_div_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx)

int _gr_other_divexact_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx)

int _gr_other_pow_vec(gr_ptr vec1, gr_srcptr vec2, gr_ctx_t ctx2, gr_srcptr vec3, slong len, gr_ctx_t ctx)

Binary operations applied elementwise, allowing a different type for one of the vectors.

int _gr_vec_add_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx)

int _gr_vec_sub_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx)

int _gr_vec_mul_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx)

int _gr_vec_div_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx)

int _gr_vec_divexact_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx)

int _gr_vec_pow_scalar_other(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t cctx, gr_ctx_t ctx)

int _gr_scalar_other_add_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_other_sub_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_other_mul_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_other_div_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_other_divexact_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_scalar_other_pow_vec(gr_ptr vec1, gr_srcptr c, gr_ctx_t cctx, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_vec_add_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx)

int _gr_vec_sub_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx)

int _gr_vec_mul_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx)

int _gr_vec_div_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx)

int _gr_vec_divexact_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx)

int _gr_vec_pow_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx)

int _gr_vec_add_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx)

int _gr_vec_sub_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx)

int _gr_vec_mul_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx)

int _gr_vec_div_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx)

int _gr_vec_divexact_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx)

int _gr_vec_pow_scalar_ui(gr_ptr vec1, gr_srcptr vec2, slong len, ulong c, gr_ctx_t ctx)

int _gr_vec_add_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx)

int _gr_vec_sub_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx)

int _gr_vec_mul_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx)

int _gr_vec_div_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx)

int _gr_vec_divexact_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx)

int _gr_vec_pow_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx)

int _gr_vec_add_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx)

int _gr_vec_sub_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx)

int _gr_vec_mul_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx)

int _gr_vec_div_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx)

int _gr_vec_divexact_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx)

int _gr_vec_pow_scalar_fmpq(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpq_t c, gr_ctx_t ctx)

Binary operations applied elementwise with a fixed scalar operand, allowing a different type for the scalar.

int _gr_vec_addmul_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx)

int _gr_vec_submul_scalar(gr_ptr vec1, gr_srcptr vec2, slong len, gr_srcptr c, gr_ctx_t ctx)

int _gr_vec_addmul_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx)

int _gr_vec_submul_scalar_si(gr_ptr vec1, gr_srcptr vec2, slong len, slong c, gr_ctx_t ctx)

int _gr_vec_addmul_scalar_fmpz(gr_ptr vec1, gr_srcptr vec2, slong len, const fmpz_t c, gr_ctx_t ctx)

int _gr_vec_mul_scalar_2exp_si(gr_ptr res, gr_srcptr vec, slong len, slong c, gr_ctx_t ctx)

Sums and products

int _gr_vec_sum(gr_ptr res, gr_srcptr vec, slong len, gr_ctx_t ctx)

int _gr_vec_product(gr_ptr res, gr_srcptr vec, slong len, gr_ctx_t ctx)

Dot products

int _gr_vec_dot(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, gr_srcptr vec2, slong len, gr_ctx_t ctx)

int _gr_vec_dot_si(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, const slong *vec2, slong len, gr_ctx_t ctx)

int _gr_vec_dot_ui(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, const ulong *vec2, slong len, gr_ctx_t ctx)

int _gr_vec_dot_fmpz(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, const fmpz *vec2, slong len, gr_ctx_t ctx)

Sets res to \(c \pm \sum_{i=0}^{n-1} a_i b_i\).

int _gr_vec_dot_strided(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, slong stride1, gr_srcptr vec2, slong stride2, slong len, gr_ctx_t ctx)

Sets res to \(c \pm \sum_{i=0}^{n-1} a_{i \cdot stride1} b_{i \cdot stride2}\). The strides may be negative.

int _gr_vec_dot_rev(gr_ptr res, gr_srcptr initial, int subtract, gr_srcptr vec1, gr_srcptr vec2, slong len, gr_ctx_t ctx)

Sets res to \(c \pm \sum_{i=0}^{n-1} a_i b_{n-1-i}\).

Sorting and searching

truth_t _gr_vec_contains(gr_srcptr vec, slong len, gr_srcptr x, gr_ctx_t ctx)

truth_t gr_vec_contains(const gr_vec_t vec, gr_srcptr x, gr_ctx_t ctx)

int _gr_vec_sort(gr_ptr vec, slong len, gr_ctx_t ctx)

int gr_vec_sort(gr_vec_t dest, const gr_vec_t src, gr_ctx_t ctx)

Sorts the entries in increasing order. The underscore version works in-place; when it returns a status code other than \(GR_SUCCESS\), the vector may not be sorted but still contains some permutation of the original entries.

void _gr_vec_permute(gr_ptr vec, slong *perm, slong len, gr_ctx_t ctx)

int gr_vec_permute(gr_vec_t dest, gr_vec_t src, slong *perm, gr_ctx_t ctx)

Applies a permutation to a vector, i.e. dest[perm[i]] = src[i]. The underscore version works in-place and overwrites \(perm\).

void _gr_vec_permute_inv(gr_ptr vec, slong *perm, slong len, gr_ctx_t ctx)

int gr_vec_permute_inv(gr_vec_t dest, gr_vec_t src, slong *perm, gr_ctx_t ctx)

Applies the inverse of a permutation to a vector, i.e. dest[i] = src[perm[i]]. The underscore version works in-place and overwrites \(perm\).

void _gr_vec_shuffle(gr_ptr vec, flint_rand_t state, slong len, gr_ctx_t ctx)

Applies a uniform random permutation.

Other functions

int _gr_vec_step(gr_ptr vec, gr_srcptr start, gr_srcptr step, slong len, gr_ctx_t ctx)

int _gr_vec_reciprocals(gr_ptr res, slong len, gr_ctx_t ctx)

Sets res to the vector of reciprocals of the positive integers 1, 2, … up to len inclusive.

int _gr_vec_set_powers(gr_ptr res, gr_srcptr x, slong len, gr_ctx_t ctx)