fexpr.h

Initialises expr and sets it to the integer 0.

Clears expr, freeing its memory.

Allocates an array of len expressions initialised to 0, or clears the len expressions of vec and frees the array.

Ensures that expr has room for size words, growing the allocation to at least twice its size if it must grow.

Sets res to a copy of expr.

Swaps a and b in constant time.

Returns the depth of expr as a tree: 1 for an atom, and one more than the largest depth of the function and the arguments for a call.

Returns the number of atoms in expr, counted with repetition.

Returns the size of expr in words or in bytes, or the number of bytes allocated for it. The counts exclude the structure itself; add sizeof(fexpr_struct) for the size of the whole object.

Returns whether a and b are the same expression (structural equality, a comparison of the word arrays).

Returns whether expr is the integer atom c.

Returns a hash of expr; equal expressions have equal hashes.

Compares a and b in a total order based on the internal representation, returning -1, 0 or 1. The order is fast and suitable for sorting and binary search, but has no mathematical meaning.

Returns whether expr is an integer, a symbol, a string, or any atom.

Sets res to the integer 0, or returns whether expr is the integer 0.

Returns whether expr is a negative integer atom.

Sets res to the integer atom c.

If expr is an integer atom, sets res to its value and returns 1; otherwise returns 0 and leaves res unchanged.

Sets res to the builtin symbol with index id, for example FEXPR_Pi (see fexpr_builtin.h).

Returns whether expr is the builtin symbol with index id, or any builtin symbol.

Sets res to the symbol with name s. If s is the name of a builtin symbol, the builtin symbol is created, so that fexpr_set_symbol_str(e, "Pi") and fexpr_set_symbol_builtin(e, FEXPR_Pi) give the same expression.

Returns a newly allocated string with the name of the symbol expr, which the caller must free with flint_free. Throws an exception if expr is not a symbol.

Sets res to the string atom with content s, or returns a newly allocated copy of the string atom expr, which the caller must free with flint_free.

Writes expr in plain text to stream, prints it to standard output, or returns it as a newly allocated string to be freed with flint_free.

Returns a newly allocated string with a decimal approximation of the value of expr with digits significant digits, or "?" if the expression cannot be evaluated numerically. The expression is evaluated in ball arithmetic with increasing precision (up to a few thousand bits); integers, the constants Pi, NumberI, NumberE, Euler, CatalanConstant and GoldenRatio, arithmetic, roots, elementary functions, and some special functions such as Gamma, Erf, RiemannZeta, the Bessel and Airy functions are supported. flags is reserved and should be 0.

Writes a LaTeX rendering of expr to out, prints it to standard output, or returns it as a newly allocated string to be freed with flint_free. Builtin symbols are rendered with standard mathematical notation (see fexpr_builtin.h); other calls are rendered as function applications. String atoms are not escaped.

Returns the number of arguments n of the call f(e_1, \ldots, e_n), or -1 if expr is an atom.

For a call f(e_1, \ldots, e_n), sets res to a copy of f, or to a view of it. A view shares the data of expr (it has alloc = 0): it must not be initialised before nor cleared after use, must not be modified, and is valid only as long as expr is not modified or cleared.

For a call f(e_1, \ldots, e_n), sets res to a copy of, or a view of, the argument e_{i+1} (indices start at 0 and must satisfy 0 \le i < n). Throws an exception if expr is an atom. Access takes O(1) steps for calls with more than four arguments, thanks to the index.

Advances a view of e_i (or of f) in a call to a view of the next argument e_{i+1} (or of e_1). It may be called on a view of the last argument provided that the result is not used.

Returns whether expr is a call f(\ldots) where f is the builtin symbol with index id, or any builtin symbol.

Sets res to the call f(x_1, \ldots, x_n), with the arguments given explicitly or as the array args of length n = len. The output must not be the same object as any input.

Sets res to the call f(x) or f(x, y), where f is the builtin symbol with index f. Here res may be the same object as an argument.

Returns whether x occurs as a subexpression of expr (including expr itself).

Sets res to expr with every occurrence of the subexpression x replaced by y (or of the entries of xs by the corresponding entries of ys, which must have the same length), simultaneously and without rescanning the replacements. Returns whether any replacement was made. res may be the same object as expr but not as the other inputs.

Sets res to the rational number x: an integer atom if the denominator is 1, and otherwise Div(p, q).

Sets res to an expression for the exact value of the floating-point number x = m \cdot 2^e (m odd): an integer if 0 \le e \le 20, a fraction Div(m, 2^-e) if -8 \le e < 0, and otherwise Pow(2, e), Neg(Pow(2, e)) or Mul(m, Pow(2, e)). Infinities are written as Infinity and Neg(Infinity), NaN as Undefined.

Sets res to an expression for the complex number x + yi, built with fexpr_set_d, NumberI, Mul and Add (omitting zero parts).

Sets res to the expression Neg(a), Add(a, b), Sub(a, b), Mul(a, b), Div(a, b) or Pow(a, b), without any simplification.

Returns whether expr is a call of one of the arithmetic operators Pos, Neg, Add, Sub, Mul or Div.

Sets nodes to the subexpressions of expr that are the leaves when expr is viewed as an arithmetic expression: expr is built from integers and the elements of nodes by nested applications of Pos, Neg, Add, Sub, Mul, Div and Pow with an integer exponent. Each node appears once; the nodes are not sorted.

Sets res to expr viewed as a rational function of the subexpressions in vars, which are treated as independent indeterminates, and returns 1. The length of vars must equal the number of variables of ctx; fexpr_arithmetic_nodes gives a suitable vector. Returns 0 if a subexpression is neither an arithmetic operation nor an entry of vars, on overflow (too many terms or too large exponents), or on division by zero.

Sets res to an expression for the polynomial poly (or the rational function frac), with the entries of vars substituted for the variables. The length of vars must equal the number of variables of ctx; if vars is NULL, default symbols are used.

Sets res to the expanded normal form of expr as a formal rational function of its non-arithmetic subexpressions, and returns 1 (0 on failure, see fexpr_get_fmpz_mpoly_q). The nodes are found with fexpr_arithmetic_nodes and sorted with fexpr_cmp_fast, expr is converted with fexpr_get_fmpz_mpoly_q and converted back with fexpr_set_fmpz_mpoly_q. flags is reserved and should be 0.

Initialises vec as a vector of len expressions equal to 0, or clears it.

Prints the entries of F to standard output, comma-separated in square brackets, without a newline.

Swaps x and y in constant time.

Ensures that vec has room for len entries, without changing its length.

Sets dest to a copy of src.

Appends a copy of f to vec.

Returns the index of an entry of vec equal to f, appending f first if there is none. The search is linear.

Sets the length of vec to len, appending zeros or truncating as needed.

Sorts the len entries of vec with the order of fexpr_cmp_fast.

Versions of fexpr_size and the atom predicates that take a pointer to the header word of an expression.

Generic forms: a function application f(x_1, \ldots, x_n), a symbol with subscripts f_{x_1, \ldots, x_n} (used for the indexed Greek and Latin variable symbols), and a subscripted function application f_{x_1}(x_2, \ldots).

Operators: infix relations and operators (such as Equal, Less or Element), products, quotients (as fractions, or inline with FEXPR_LATEX_SMALL), unary minus and plus, sums, differences, powers, e^x, and factorials, with parentheses inserted as needed.

Operators binding variables through For: sums and products, divisor sums, integrals, limits, residues and derivatives.

Special functions with an optional derivative order as last argument: f(x) or f^{(n)}(x), f(x, y) or f^{(n)}(x, y), and the same with the first argument as a subscript, f_x(y) or f_x(y, z).

Notation for functions with a fixed LaTeX form, such as |x|, \lfloor x \rfloor, \binom{n}{k} or \overline{z} (the simple2 variants for two-argument functions such as binomial coefficients, small writing the arguments in small style), and a few special functions with unusual notation.

Logical connectives and quantifiers (Not, And, Or, Implies, All, Exists, ...), extrema and similar operators over sets (Maximum, Minimum, Infimum, ArgMax, Poles, ...), collections (List, Tuple, Set, also in set-builder form), integer ranges, matrices, and piecewise definitions (Cases).

Algebraic structures such as polynomial and power series rings R[x], R[[x]]; Where expressions with local definitions; ShowExpandedNormalForm; and Decimal literals.