fexpr_init expr

Initializes expr for use. Its value is set to the atomic integer 0.

fexpr_clear expr

Clears expr, freeing its allocated memory.

_fexpr_vec_init len

Returns a heap-allocated vector of len initialized expressions.

_fexpr_vec_clear vec len

Clears the len expressions in vec and frees vec itself.

fexpr_fit_size expr size

Ensures that expr has room for size words.

fexpr_set res expr

Sets res to the a copy of expr.

fexpr_swap a b

Swaps a and b efficiently.

fexpr_depth expr

Returns the depth of expr as a symbolic expression tree.

fexpr_num_leaves expr

Returns the number of leaves (atoms, counted with repetition) in the expression expr.

fexpr_size expr

Returns the number of words in the internal representation of expr.

fexpr_size_bytes expr

Returns the number of bytes in the internal representation of expr. The count excludes the size of the structure itself. Add sizeof(fexpr_struct) to get the size of the object as a whole.

fexpr_allocated_bytes expr

Returns the number of allocated bytes in the internal representation of expr. The count excludes the size of the structure itself. Add sizeof(fexpr_struct) to get the size of the object as a whole.

fexpr_equal a b

Checks if a and b are exactly equal as expressions.

fexpr_equal_si expr c

fexpr_equal_ui expr c

Checks if expr is an atomic integer exactly equal to c.

fexpr_hash expr

Returns a hash of the expression expr.

fexpr_cmp_fast a b

Compares a and b using an ordering based on the internal representation, returning -1, 0 or 1. This can be used, for instance, to maintain sorted arrays of expressions for binary search; the sort order has no mathematical significance.

fexpr_is_integer expr

Returns whether expr is an atomic integer

fexpr_is_symbol expr

Returns whether expr is an atomic symbol.

fexpr_is_string expr

Returns whether expr is an atomic string.

fexpr_is_atom expr

Returns whether expr is any atom.

fexpr_zero res

Sets res to the atomic integer 0.

fexpr_is_zero expr

Returns whether expr is the atomic integer 0.

fexpr_is_neg_integer expr

Returns whether expr is any negative atomic integer.

fexpr_set_si res c

fexpr_set_ui res c

fexpr_set_fmpz res c

Sets res to the atomic integer c.

fexpr_get_fmpz res expr

Sets res to the atomic integer in expr. This aborts if expr is not an atomic integer.

fexpr_set_symbol_builtin res id

Sets res to the builtin symbol with internal index id (see fexpr-builtin).

fexpr_is_builtin_symbol expr id

Returns whether expr is the builtin symbol with index id (see fexpr-builtin).

fexpr_is_any_builtin_symbol expr

Returns whether expr is any builtin symbol (see fexpr-builtin).

fexpr_set_symbol_str res s

Sets res to the symbol given by s.

fexpr_get_symbol_str expr

Returns the symbol in expr as a string. The string must be freed with flint_free. This aborts if expr is not an atomic symbol.

fexpr_set_string res s

Sets res to the atomic string s.

fexpr_get_string expr

Assuming that expr is an atomic string, returns a copy of this string. The string must be freed with flint_free.

fexpr_write stream expr

Writes expr to stream.

fexpr_print expr

Prints expr to standard output.

fexpr_get_str expr

Returns a string representation of expr. The string must be freed with flint_free.

Warning: string literals appearing in expressions are currently not escaped.

fexpr_write_latex stream expr flags

Writes the LaTeX representation of expr to stream.

fexpr_print_latex expr flags

Prints the LaTeX representation of expr to standard output.

fexpr_get_str_latex expr flags

Returns a string of the LaTeX representation of expr. The string must be freed with flint_free.

Warning: string literals appearing in expressions are currently not escaped.

fexpr_latex_small

Generate more compact formulas, most importantly by printing fractions inline as \(p/q\) instead of as \(\frac{p}{q}\). This flag is automatically activated within subscripts and superscripts and in certain other parts of formulas.

fexpr_latex_logic

Use symbols for logical operators such as Not, And, Or, which by default are rendered as words for legibility.

fexpr_nargs expr

Returns the number of arguments n in the function call \(f(e_1,\ldots,e_n)\) represented by expr. If expr is an atom, returns -1.

fexpr_func res expr

Assuming that expr represents a function call \(f(e_1,\ldots,e_n)\), sets res to the function expression f.

fexpr_view_func view expr

As fexpr_func, but sets view to a shallow view instead of copying the expression. The variable view must not be initialized before use or cleared after use, and expr must not be modified or cleared as long as view is in use.

fexpr_arg res expr i

Assuming that expr represents a function call \(f(e_1,\ldots,e_n)\), sets res to the argument \(e_{i+1}\). Note that indexing starts from 0. The index must be in bounds, with \(0 \le i < n\).

fexpr_view_arg view expr i

As fexpr_arg, but sets view to a shallow view instead of copying the expression. The variable view must not be initialized before use or cleared after use, and expr must not be modified or cleared as long as view is in use.

fexpr_view_next view

Assuming that view is a shallow view of a function argument \(e_i\) in a function call \(f(e_1,\ldots,e_n)\), sets view to a view of the next argument \(e_{i+1}\). This function can be called when view refers to the last argument \(e_n\), provided that view is not used afterwards. This function can also be called when view refers to the function f, in which case it will make view point to \(e_1\).

fexpr_is_builtin_call expr id

Returns whether expr has the form \(f(\ldots)\) where f is a builtin function defined by id (see fexpr-builtin).

fexpr_is_any_builtin_call expr

Returns whether expr has the form \(f(\ldots)\) where f is any builtin function (see fexpr-builtin).

fexpr_call0 res f

fexpr_call1 res f x1

fexpr_call2 res f x1 x2

fexpr_call3 res f x1 x2 x3

fexpr_call4 res f x1 x2 x3 x4

fexpr_call_vec res f args len

Creates the function call \(f(x_1,\ldots,x_n)\). The vec version takes the arguments as an array args and n is given by len. Warning: aliasing between inputs and outputs is not implemented.

fexpr_call_builtin1 res f x1

fexpr_call_builtin2 res f x1 x2

Creates the function call \(f(x_1,\ldots,x_n)\), where f defines a builtin symbol.

fexpr_contains expr x

Returns whether expr contains the expression x as a subexpression (this includes the case where expr and x are equal).

fexpr_replace res expr x y

Sets res to the expression expr with all occurrences of the subexpression x replaced by the expression y. Returns a boolean value indicating whether any replacements have been performed. Aliasing is allowed between res and expr but not between res and x or y.

fexpr_replace2 res expr x1 y1 x2 y2

Like fexpr_replace, but simultaneously replaces x1 by y1 and x2 by y2.

fexpr_replace_vec res expr xs ys

Sets res to the expression expr with all occurrences of the subexpressions given by entries in xs replaced by the corresponding expressions in ys. It is required that xs and ys have the same length. Returns a boolean value indicating whether any replacements have been performed. Aliasing is allowed between res and expr but not between res and the entries of xs or ys.

fexpr_set_fmpq res x

Sets res to the rational number x. This creates an atomic integer if the denominator of x is one, and otherwise creates a division expression.

fexpr_set_arf res x

fexpr_set_d res x

Sets res to an expression for the value of the floating-point number x. NaN is represented as Undefined. For a regular value, this creates an atomic integer or a rational fraction if the exponent is small, and otherwise creates an expression of the form Mul(m, Pow(2, e)).

fexpr_set_re_im_d res x y

Sets res to an expression for the complex number with real part x and imaginary part y.

fexpr_neg res a

fexpr_add res a b

fexpr_sub res a b

fexpr_mul res a b

fexpr_div res a b

fexpr_pow res a b

Constructs an arithmetic expression with given arguments. No simplifications whatsoever are performed.

fexpr_is_arithmetic_operation expr

Returns whether expr is of the form \(f(e_1,\ldots,e_n)\) where f is one of the arithmetic operators Pos, Neg, Add, Sub, Mul, Div.

fexpr_arithmetic_nodes nodes expr

Sets nodes to a vector of subexpressions of expr such that expr is an arithmetic expression with nodes as leaves. More precisely, expr will be constructed out of nested application the arithmetic operators Pos, Neg, Add, Sub, Mul, Div with integers and expressions in nodes as leaves. Powers Pow with an atomic integer exponent are also allowed. The nodes are output without repetition but are not automatically sorted in a canonical order.

fexpr_get_fmpz_mpoly_q res expr vars ctx

Sets res to the expression expr as a formal rational function of the subexpressions in vars. The vector vars must have the same length as the number of variables specified in ctx. To build vars automatically for a given expression, fexpr_arithmetic_nodes may be used.

Returns 1 on success and 0 on failure. Failure can occur for the following reasons:

• A subexpression is encountered that cannot be interpreted as an arithmetic operation and does not appear (exactly) in vars.
• Overflow (too many terms or too large exponent).
• Division by zero (a zero denominator is encountered).

It is important to note that this function views expr as a formal rational function with vars as formal indeterminates. It does thus not check for algebraic relations between vars and can implicitly divide by zero if vars are not algebraically independent.

fexpr_set_fmpz_mpoly res poly vars ctx

fexpr_set_fmpz_mpoly_q res frac vars ctx

Sets res to an expression for the multivariate polynomial poly (or rational function frac), using the expressions in vars as the variables. The length of vars must agree with the number of variables in ctx. If NULL is passed for vars, a default choice of symbols is used.

fexpr_expanded_normal_form res expr flags

Sets res to expr converted to expanded normal form viewed as a formal rational function with its non-arithmetic subexpressions as terminal nodes. This function first computes nodes with fexpr_arithmetic_nodes, sorts the nodes, evaluates to a rational function with fexpr_get_fmpz_mpoly_q, and then converts back to an expression with fexpr_set_fmpz_mpoly_q. Optional flags are reserved for future use.

fexpr_vec_init vec len

Initializes vec to a vector of length len. All entries are set to the atomic integer 0.

fexpr_vec_clear vec

Clears the vector vec.

fexpr_vec_print vec

Prints vec to standard output.

fexpr_vec_swap x y

Swaps x and y efficiently.

fexpr_vec_fit_length vec len

Ensures that vec has space for len entries.

fexpr_vec_set dest src

Sets dest to a copy of src.

fexpr_vec_append vec expr

Appends expr to the end of the vector vec.

fexpr_vec_insert_unique vec expr

Inserts expr without duplication into vec, returning its position. If this expression already exists, vec is unchanged. If this expression does not exist in vec, it is appended.

fexpr_vec_set_length vec len

Sets the length of vec to len, truncating or zero-extending as needed.

_fexpr_vec_sort_fast vec len

Sorts the len entries in vec using the comparison function fexpr_cmp_fast.