.. _ca-vec: **ca_vec.h** -- vectors of real and complex numbers =============================================================================== A :type:`ca_vec_t` represents a vector of real or complex numbers, implemented as an array of coefficients of type :type:`ca_struct`. Most functions are provided in two versions: an underscore method which operates directly on pre-allocated arrays of coefficients (taking :type:`ca_ptr` and :type:`ca_srcptr` arguments), and a non-underscore method which takes :type:`ca_vec_t` input and performs automatic memory management. Unlike :type:`ca_poly_t`, a :type:`ca_vec_t` is not normalised by removing zero coefficients; it retains the exact length assigned by the user. Types, macros and constants ------------------------------------------------------------------------------- .. type:: ca_vec_struct .. type:: ca_vec_t Contains a pointer to an array of entries (*coeffs*), the used length (*length*), and the allocated size of the array (*alloc*). A *ca_vec_t* is defined as an array of length one of type *ca_vec_struct*, permitting an *ca_vec_t* to be passed by reference. .. macro:: ca_vec_entry(vec, i) Macro returning a pointer to entry *i* in the vector *vec*. The index must be in bounds. Memory management ------------------------------------------------------------------------------- .. function:: ca_ptr _ca_vec_init(slong len, ca_ctx_t ctx) Returns a pointer to an array of *len* coefficients initialized to zero. .. function:: void ca_vec_init(ca_vec_t vec, slong len, ca_ctx_t ctx) Initializes *vec* to a length *len* vector. All entries are set to zero. .. function:: void _ca_vec_clear(ca_ptr vec, slong len, ca_ctx_t ctx) Clears all *len* entries in *vec* and frees the pointer *vec* itself. .. function:: void ca_vec_clear(ca_vec_t vec, ca_ctx_t ctx) Clears the vector *vec*. .. function:: void _ca_vec_swap(ca_ptr vec1, ca_ptr vec2, slong len, ca_ctx_t ctx) Swaps the entries in *vec1* and *vec2* efficiently. .. function:: void ca_vec_swap(ca_vec_t vec1, ca_vec_t vec2, ca_ctx_t ctx) Swaps the vectors *vec1* and *vec2* efficiently. Length ------------------------------------------------------------------------------- .. function:: slong ca_vec_length(const ca_vec_t vec, ca_ctx_t ctx) Returns the length of *vec*. .. function:: void _ca_vec_fit_length(ca_vec_t vec, slong len, ca_ctx_t ctx) Allocates space in *vec* for *len* elements. .. function:: void ca_vec_set_length(ca_vec_t vec, slong len, ca_ctx_t ctx) Sets the length of *vec* to *len*. If *vec* is shorter on input, it will be zero-extended. If *vec* is longer on input, it will be truncated. Assignment ------------------------------------------------------------------------------- .. function:: void _ca_vec_set(ca_ptr res, ca_srcptr src, slong len, ca_ctx_t ctx) Sets *res* to a copy of *src* of length *len*. .. function:: void ca_vec_set(ca_vec_t res, const ca_vec_t src, ca_ctx_t ctx) Sets *res* to a copy of *src*. Special vectors ------------------------------------------------------------------------------- .. function:: void _ca_vec_zero(ca_ptr res, slong len, ca_ctx_t ctx) Sets the *len* entries in *res* to zeros. .. function:: void ca_vec_zero(ca_vec_t res, slong len, ca_ctx_t ctx) Sets *res* to the length *len* zero vector. Input and output ------------------------------------------------------------------------------- .. function:: void ca_vec_print(const ca_vec_t vec, ca_ctx_t ctx) Prints *vec* to standard output. The coefficients are printed on separate lines. .. function:: void ca_vec_printn(const ca_vec_t poly, slong digits, ca_ctx_t ctx) Prints a decimal representation of *vec* with precision specified by *digits*. The coefficients are comma-separated and the whole list is enclosed in square brackets. List operations ------------------------------------------------------------------------------- .. function:: void ca_vec_append(ca_vec_t vec, const ca_t f, ca_ctx_t ctx) Appends *f* to the end of *vec*. Arithmetic ------------------------------------------------------------------------------- .. function:: void _ca_vec_neg(ca_ptr res, ca_srcptr src, slong len, ca_ctx_t ctx) .. function:: void ca_vec_neg(ca_vec_t res, const ca_vec_t src, ca_ctx_t ctx) Sets *res* to the negation of *src*. .. function:: void _ca_vec_add(ca_ptr res, ca_srcptr vec1, ca_srcptr vec2, slong len, ca_ctx_t ctx) .. function:: void _ca_vec_sub(ca_ptr res, ca_srcptr vec1, ca_srcptr vec2, slong len, ca_ctx_t ctx) Sets *res* to the sum or difference of *vec1* and *vec2*, all vectors having length *len*. .. function:: void _ca_vec_scalar_mul_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx) Sets *res* to *src* multiplied by *c*, all vectors having length *len*. .. function:: void _ca_vec_scalar_div_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx) Sets *res* to *src* divided by *c*, all vectors having length *len*. .. function:: void _ca_vec_scalar_addmul_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx) Adds *src* multiplied by *c* to the vector *res*, all vectors having length *len*. .. function:: void _ca_vec_scalar_submul_ca(ca_ptr res, ca_srcptr src, slong len, const ca_t c, ca_ctx_t ctx) Subtracts *src* multiplied by *c* from the vector *res*, all vectors having length *len*. Comparisons and properties --------------------------------------------------------------------------------- .. function:: truth_t _ca_vec_check_is_zero(ca_srcptr vec, slong len, ca_ctx_t ctx) Returns whether *vec* is the zero vector. Internal representation --------------------------------------------------------------------------------- .. function:: int _ca_vec_is_fmpq_vec(ca_srcptr vec, slong len, ca_ctx_t ctx) Checks if all elements of *vec* are structurally rational numbers. .. function:: int _ca_vec_fmpq_vec_is_fmpz_vec(ca_srcptr vec, slong len, ca_ctx_t ctx) Assuming that all elements of *vec* are structurally rational numbers, checks if all elements are integers. .. function:: void _ca_vec_fmpq_vec_get_fmpz_vec_den(fmpz * c, fmpz_t den, ca_srcptr vec, slong len, ca_ctx_t ctx) Assuming that all elements of *vec* are structurally rational numbers, converts them to a vector of integers *c* on a common denominator *den*. .. function:: void _ca_vec_set_fmpz_vec_div_fmpz(ca_ptr res, const fmpz * v, const fmpz_t den, slong len, ca_ctx_t ctx) Sets *res* to the rational vector given by numerators *v* and the common denominator *den*. .. raw:: latex \newpage