Routines for symbolic manipulation and expression handling
See also: args.h
void add_to_top (CESI ptr); 
Adds a value to the expression on the top of the estack.
add_to_top adds the expression pointed to by ptr to the expression currently at the top of the estack and stores the result to the top of the estack, in place of the expression that was added to.
See also: subtract_from_top, and_onto_top, negate_top, add1_to_top
void add1_to_top (void); 
Adds 1 to the top of the estack.
add1_to_top adds 1 (or 1.0) to the value on the top of the estack. This routine basically calls add_to_top with "1" as the pointedto value.
short all_tail (CESI_Callback_t f, ESI start_ptr); 
Checks whether all elements in the list have some property.
all_tail is similar to map_tail, but callback function f is
not void. It needs to return a Boolean value (TRUE or FALSE).
If f returns FALSE, any further processing of the list tail will
be stopped, even if END_TAG is not reached yet. The result of all_tail is
the last value returned from f. In other words, it returns TRUE if
and only if the callback function f returns TRUE for each expression
in the tail of expressions indexed by element_ptr.
all_tail is very useful to check whether all elements of a list possess some property. Suppose
that you defined the following function which checks whether an entry on the expression stack is a positive
integer:
short is_positive_integer (ESI ptr) { return (*ptr == POSINT_TAG); }
and suppose that start_ptr points to the first element of the list (one byte below LIST_TAG). Then, you can use the following call to check whether all elements of the lists are positive integers:
are_all_positive_integers = all_tail (is_positive_integer, start_ptr);
void and_onto_top (CESI ptr); 
Logical ANDs the expression onto the estack.
and_onto_top replaces the top expression on the estack with the logical AND of itself and ptr.
See also: add_to_top, subtract_from_top, negate_top
short any_tail (CESI_Callback_t f, ESI start_ptr); 
Checks whether any element in the list has some property.
any_tail is similar like all_tail, except further processing of the list will be stopped if f returns TRUE instead of FALSE. In other words, it returns TRUE if and only if the callback function f returns TRUE for at least one expression in the tail of expressions indexed by element_ptr. any_tail is very useful to check whether any element of a list possesses some property. Assuming the same assumptions as in the example given with all_tail, the following call will check whether any element of the list is a positive integer:
is_any_positive_integer = any_tail (is_positive_integer, start_ptr);
short are_expressions_identical (CESI ptr1, CESI ptr2); 
Checks whether two expressions are identical.
are_expressions_identical returns TRUE if expressions pointed to by ptr1 and ptr2 are syntactically identical, else returns FALSE. At the moment, I am not exactly sure what is the criteria for equivalence. I only know that a+b and b+a are not identical for example. And, floats are never identical to rational numbers. So far, I only know that this function surely returns TRUE when two expressions are absolutely identical. But, if this is the only case of equivalence, this routine should be very simple. But it is not. It is very complicated and recursive, so I am really not sure which pairs of expressions may be treated as "identical". Any additional info is welcomed.
short can_be_approxed (CESI ptr, short Complex); 
Checks whether an expression can be approximated to a number.
can_be_approxed returns TRUE if the expression pointed to by
ptr can be approximated to a number (including transfinite ones) or a list of
numbers (such expression are for example
'ln(2+sin(1))/5'
, '1/0'
or
'x^2+1x*x'
), else returns FALSE.
Complex is a Boolean parameter:
if it is TRUE, complex results will be allowed, but if it
is FALSE, complex results will be treated as "can not be approxed".
Note: can_be_approxed performs much detailed investigation than functions
likely_approx_to_number and
likely_approx_to_complex_number.
void check_estack_size (unsigned short Size); 
Checks if there is enough room on the expression stack.
check_estack_size checks if there is enough room to push Size bytes to the expression stack. If there is not enough space, it tries to enlarge the stack (using HeapRealloc) to make additional space. It throws an error if the requirement cannot be satisfied. Note that all "push_..." functions call this routine, so all of them may throw an error if there is not enough memory.
short compare_complex_magnitudes (CESI ptr1, CESI ptr2); 
Compares magnitudes of two complex number entries on the expression stack.
compare_complex_magnitudes compares two complex number entries (which may be real also) on the expression stack pointed to by ptr1 and ptr2, and returns a value which is
< 0 if the magnitude of the number pointed to by ptr1 is less than the magnitude of the number pointed to by ptr2
== 0 if the magnitude of the number pointed to by ptr1 is the same as the magnitude of the number pointed to by ptr2
> 0 if the magnitude of the number pointed to by ptr1 is greater than the magnitude of the number pointed to by ptr2
short compare_expressions (CESI ptr1, CESI ptr2); 
Compares two expressions.
compare_expressions returns 0 if two expressions pointed to by ptr1 and ptr2
are equal in the sense that they have the same structure, variables, function names, and
numbers that compare equal. A float and a rational number compare equal
if converting the rational number to a float produces an identical number.
If the expressions are not, it returns a nonzero value which may be positive or negative
(more precise, 1 or 1). Positive result means that the
expression pointed to by ptr1 is "more main" that the expression pointed to by ptr2,
and negative result means "less main". Principally, variables are more main than symbolic constants
such as pi, which are more main than numbers. In expressions such
as 'expand(...,var)'
or 'Integral(...,var)'
, a variable var
is "most main". Otherwise, the 26 Roman oneletter variables order
r>>s>>...>>z>>a>>b>>...>>q ('>>' means "more main"),
which order more main than all other variables, which order alphabetically. Functions and operators
are typically ordered by recursively comparing their first arguments, with ties broken by
comparing their second arguments, etc. then finally comparing the operators or functions, if
necessary. For example:
2.0 and 2 are equal;
2.0 is less main than 1;
pi is more main than 4;
x
is more main than 4;
x
is less main than r
;
x
is more main than ln(y)
;
x
is less main than ln(x)
.
Note: Both expressions should be in internal canonic form (see push_internal_simplify), else this function may not work as expected.
long compare_Floats (CESI ptr1, CESI ptr2); 
Compares two floating point entries on the expression stack.
compare_Floats compares two floating point entries on the expression stack pointed to by ptr1 and ptr2, and returns a value which is
< 0 if the number pointed to by ptr1 is less than the number pointed to by ptr2
== 0 if the number pointed to by ptr1 is the same as the number pointed to by ptr2
> 0 if the number pointed to by ptr1 is greater than the number pointed to by ptr2
So, this function is similar like fcmp, except the arguments are different (fcmp uses floating point arguments, and compare_Floats uses pointers to floating point entries on the expression stack).
void delete_between (ESI ptr1, ESI ptr2); 
Deletes a sequence of bytes from the expression stack.
delete_between deletes a sequence of bytes between ptr1 and ptr2 (more precise, starting at ptr1+1 and ending at ptr2) from the expression stack. It does this by moving the memory from ptr2+1 to top_estack downwards (using memmove) and adjusting top_estack. This routine assumes that ptr1 and ptr2 really point to parts of the expression stack and that ptr2 is above ptr1, otherwise the result is unpredictable.
void delete_expression (ESI ptr); 
Deletes an expression from the expression stack.
delete_expression deletes an entry on the expression stack pointed to by ptr (it needs to point to the entry tag) from the stack. The entry need not be a simple entity; it may be a complex symbolic expression too. This is achieved by calling next_expression_index and delete_between.
unsigned short deleted_between (ESI ptr1, ESI ptr2); 
Deletes a sequence of bytes from the expression stack.
deleted_between acts like delete_between, but it also returns a number of deleted bytes. Note that delete_between calls memmove for moving memory after ptr2, but deleted_between uses an embedded loop sequence for the same task. I don't know why these two routines use different methods: as I can see, the final effect is the same. Maybe I am wrong?
unsigned short deleted_expression (ESI ptr); 
Deletes an expression from the expression stack.
deleted_expression acts like delete_expression, but it also returns a number of deleted bytes. It calls deleted_between instead of delete_between.
short did_push_cnvrt_Float_to_integer (CESI ptr); 
Pushes a floating point entry converted to an integer, but only if it is an exact whole number.
did_push_cnvrt_Float_to_integer is a subroutine used in push_cnvrt_integer_if_whole_nmb. It assumes that ptr points to a floating point entry. If it is a whole number (including big numbers too), did_push_cnvrt_Float_to_integer pushes the number converted to a tagged integer to the expression stack, and returns TRUE, otherwise it does nothing and returns FALSE.
HANDLE display_statements (CESI ptr, unsigned short Newlines, unsigned short FullPrec); 
Converts tokenized expressions or TIBasic statements to the printable form.
display_statements converts the expression (or a group of tokenized TIBasic statements) pointed to by ptr from RPN form to the standard printable ("algebraic") form, and returns a handle to the memory block where the converted string is stored (you don't need to allocate anything by yourself, this function will do it instead; note that this routine may cause heap compression). It will return H_NULL if memory is full. Newline is a Boolean flag: when it is nonzero, all newline characters will be replaced with ':', otherwise they will remain intact. FullPrec is also a Boolean flag: when it is nonzero, all floating point values will be converted using the maximal precision (14 digits), else current precision settings (from TIBasic MODE dialog) will be used. Here is an illustrative example for usage of this command (take a look at the "Integrate" example as well):
push_parse_text ("expand((x+1)(x+2)(x+3))"); NG_rationalESI (top_estack); handle = display_statements (top_estack, 1, 1); printf_xy (0, 40, "%s", HeapDeref (handle)); HeapFree (handle);
See push_parse_text, NG_rationalESI,
HeapDeref and HeapFree
to understand how this example works.
Note: Handles returned by display_statements aren't locked so any heap
compression will move the block associated with the handle. Therefore it is safer
to lock them using HLock and
HeapUnlock than to just dereference them
using HeapDeref.
display_statements will always convert expressions into the "canonic printing (external) form".
For example, both x*3 and 3*x will be displayed as 3*x, x*y^(1) will be displayed as x/y etc.
Note: Although display_statements is very similar to Parse1DExpr
and both of them may usually be used for the same purposes, display_statements is used in TIOS for
printing TIBasic statements (from programs) and for the detokenization (in NG_RPNToText),
and Parse1DExpr is used for printing expressions.
float estack_number_to_Float (CESI ptr); 
Converts entry on the expression stack to floating point number.
estack_number_to_Float converts an entry on the expression stack pointed to by
ptr (it needs to point to the entry tag) to a floating point value
and returns the result. Note that the entry need not be represented by
FLOAT_TAG: it also may be represented by an integer, or
by a fraction. This function does not remove the entry from the stack.
Note: estack_number_to_Float will throw an error if the entry on the stack is not
a floating point number, a fraction or an integer, so you will need to use
ER_catch to catch eventual errors.
short estack_to_short (CESI ptr, short *value_ptr); 
Converts entry on the expression stack to signed short integer.
estack_to_short converts an entry on the expression stack pointed to by
ptr (it needs to point to the entry tag) to a signed short integer
and stores the result in the location pointed to by value_ptr.
Note that the entry need not be represented by POSINT_TAG
or NEGINT_TAG: it also may be represented by
FLOAT_TAG for example, but the value itself needs to be a whole
number. This function does not remove the entry from the stack.
estack_to_short returns 1 if the conversion was successful, 0 in the case of overflow
(in this case the stored result will be 32768 or 32767 depending of the direction
of the overflow), and 1 if the entry can not be represented as a whole number (in
this case the result is undefined).
short estack_to_ushort (CESI ptr, unsigned short *value_ptr); 
Converts entry on the expression stack to unsigned short integer.
estack_to_ushort converts an entry on the expression stack pointed to by
ptr (it needs to point to the entry tag) to a unsigned short integer
and stores the result in the location pointed to by value_ptr.
Note that the entry need not be represented by POSINT_TAG
or NEGINT_TAG: it also may be represented by
FLOAT_TAG for example, but the value itself needs to be a whole
number. This function does not remove the entry from the stack.
estack_to_short returns 1 if the conversion was successful, 0 in the case of overflow
(in this case the stored result will be 0 or 65535 depending of the direction of the
overflow), and 1 if the entry can not be represented as a whole number (in this case
the result is undefined).
#define ESTACK(idx) (*(idx)) 
Reads the expression stack at a specific index.
The ESTACK macro can be used to read the expression stack at the index idx. It simply dereferences idx, since the ESI and CESI types are in fact pointers to quantums of type ESQ.
ESI factor_base_index (CESI ptr); 
Gets the index of the base of an expression.
If ptr points to the POW_TAG, which is a case when it points to an expression of form base ^ exponent factor_base_index returns the pointer to base. If ptr does not point to the POW_TAG, factor_base_index returns ptr (i.e. the pointer to the expression itself).
ESI factor_exponent_index (CESI ptr); 
Gets the index of the exponent of an expression.
If ptr points to the POW_TAG, which is a case when it points to an expression of form base ^ exponent factor_exponent_index returns the pointer to exponent. If ptr does not point to the POW_TAG, factor_exponent_index returns a pointer to a simple expression which consists only of the number 1 (floating point or integer, depending on whether the approximation mode is active or not).
float gcd_exact_whole_Floats (CESI ptr1, CESI ptr2); 
Finds the greatest common divisor of two floating point entries.
gcd_exact_whole_Floats finds the greatest common divisor of two floating point entries
pointed to by ptr1 and ptr2 and returns the result (the result is a garbage
if ptr1 or ptr2 doesn't point to floating point entries).
Note: Although the name of the function suggests that both entries need to be whole
numbers, this is not true. This function, in fact, returns "generalized" GCD of two
numbers x and y which is defined as the greatest number z
which has a property that both x/z and
y/z are whole numbers.
char *get_key_ptr (ESQ Tag1, ESQ Tag2); 
Converts a tag code to a tag name.
get_key_ptr returns a static pointer to the string which represents the name of the
tag Tag1. Tag2 is used only if Tag1 is an extended tag
(i.e. EXT_TAG, EXT_INSTR_TAG or EXT_SYSTEM_TAG)
which can't be fully represented using only one byte.
If the tag corresponds to a function, AMS 1.xx does not append
'(' at the end of the string, but AMS 2.xx does. Thus, anyone who
intends to use this function for function tokens should use extra
code to handle both cases.
long GetValue (CESI ptr, long low, long high); 
Converts entry on the expression stack to short integer and checks whether it is in a given range.
GetValue converts an entry on the expression stack pointed to by ptr (it needs to point on the entry tag) to a short integer value using estack_to_short or estack_to_ushort, depending on the sign of low. Then, a "Domain Error" is thrown if the value is smaller than low or greater than high, otherwise the value will be returned as the result of the function. It will also throw a "Data type" error if the entry can not be represented as an integer.
ESI HToESI (HANDLE Handle); 
Converts a handle to an expression stack index.
HToESI is a simple but very useful routine. It returns a pointer to the last
byte of the MULTI_EXPR structure referenced
by Handle. Therefore it allows for the use of TIOS variables as input
data in expression stack routines. Assuming that Handle
is a handle of a TIOS variable which contains an expression, HToESI will return a pointer
to the tag of the expression contained in the variable. Such a pointer may be used in
any routine which needs an argument of type CESI, like
NG_approxESI, etc. (except in functions which manipulate
the actual memory space on the expression stack, like
delete_between).
In fact, HToESI simply dereferences Handle and adds the size plus 1 to the address.
It also may be used to determine the type of a TIOS variable, because after execution the
result points to the data type tag of the variable data.
Note: If the handle is not locked, HToESI must be called again after a heap compression
since the block of memory associated with the handle may have moved.
ESI im_index (CESI ptr); 
Gets the index of the imaginary part of an expression.
If ptr points to the COMPLEX_TAG
(i.e. if the expression is complex), im_index returns the pointer
to the imaginary part of the expression. If ptr does not point to the
COMPLEX_TAG (i.e. if the expression is real),
im_index returns a pointer to a simple zero expression, i.e. expression which
consists only of the number 0 (floating point or integer,
depending on whether the approximation mode is active or not).
Note: The expression should be in internal canonic form
(see push_internal_simplify), else this function
is not reliable.
ESI index_below_display_expression_aux (CESI ptr); 
Main routine for detokenizing.
index_below_display_expression_aux is main (recursive) routine for detokenizing. As it is just an auxiliary routine used in display_statements and Parse1DExpr, it shouldn't need to be used directly.
ESI index_main_var (CESI ptr); 
Searches an expression for a first encountered variable.
index_main_var returns the index of the first encountered variable in the expression pointed to by ptr. More precise, it repeatedly decreases value of ptr by one until the tag of a variable, a number or a symbolic constant (like pi) is reached. As expressions are usually organized in "internal canonic" form (see notes given with description of numeric_factor_index) in which all constants are always "below" variables on the stack, a variable will always be reached before any constant, except if there are not any variables in the expression (in this case, a pointer to a constant is returned). Obviously, this function is not reliable if the expression is not in the internal canonic form (see push_internal_simplify).
ESI index_numeric_term (CESI ptr); 
Searches terms in the expression for a numeric term.
If ptr points to the ADD_TAG, which is a case when it
points to an expression of form term1 + term2 + ...
(i.e. if the expression is a sum of simpler terms), index_numeric_term returns the pointer
to the eventual numeric term in the expression. If the expression is a number, index_numeric_term
returns ptr (i.e. the pointer to the expression itself). If ptr does not point to
the ADD_TAG (i.e. if the expression is not a sum of simpler terms),
or if there are not any numeric terms in the expression, index_numeric_factor returns
a pointer to a simple expression which consists only of the number 0 (floating point or integer,
depending on whether the approximation mode is active or not).
Note: This function is not implemented to be very universal. TIOS always "reorganizes" expressions
on such way that numeric terms are at the beginning of the expression (for example, x+3 will be reorganized
into 3+x, although it will be displayed just reversed, i.e. as x+3), and this function assumes that the
expression is organized on such way. In other words, it must be in internal canonic form (such
expressions always have at most one term with a numeric tag, in which case it is the deepest
term). Fortunately,
all expressions in argument are always in internal canonic form. However, this is not true after
push_parse_text function, nor after an evaluation using
NG_rationalESI or NG_approxESI. In
other words, results of these commands are not always "correctly" organized. To force converting
an expression to the internal canonic form, always call
push_internal_simplify after usage of any of the functions
mentioned above.
ESI index_of_lead_base_of_lead_term (CESI ptr); 
Gets the index of the base of the lead term of an expression.
index_of_lead_base_of_lead_term first calls lead_term_index, then apply lead_base_index on the result. So, it returns the pointer to the base of the lead factor of the first term of the expression pointed to by ptr.
short integer_non_unknown (CESI ptr); 
Tests if an expression is an integer.
Returns 1 if the expression pointed to by ptr is an integer
or floatingpoint value; returns 1 for constants like p or e.
Returns 0 for everything else  this includes expressions like ln(2)
,
2p
, or Ö(2)
.
short is0 (CESI ptr); 
Tests if an expression is equal to 0.
Returns TRUE if the expression pointed to by ptr is equal to zero (integer or floating point).
See also: is1, is_minus1, is_never0
short is1 (CESI ptr); 
Tests if an expression is equal to 1.
Returns TRUE if the expression pointed to by ptr is equal to one (integer or floating point).
short is_advanced_tag (ESQ Tag); 
Checks whether a tag is an advanced tag.
is_advanced_tag returns TRUE if a byte Tag is an advanced tag, otherwise it returns FALSE. Advanced tags are all tags which do not represent a variable, a number (integer, fraction or float) or an expression which consists only of simple operations "+", "", "*", "/" and "^" (including elementbyelement versions "+.", ".", "*.", "/." and "^.").
short is_antisymmetric (CESI expr_ptr, CESI var_ptr); 
Checks for a antisymmetry.
is_antisymmetric returns TRUE if the expression pointed to by expr_ptr is such that it changes the sign but keeps the same magnitude when the variable pointed to by var_ptr changes it sign, otherwise it returns FALSE.
short is_complex0 (CESI ptr); 
Checks whether an expression is reducible to zero.
is_complex0 returns TRUE if the expression pointed to by
ptr is a zero (signed, unsigned, or even complex), otherwise it returns FALSE.
Note: The information about this routine in releases of TIGCCLIB before 2.3 was wrong.
short is_complex_number (CESI ptr); 
Checks whether an expression is a number.
is_complex_number returns TRUE if the expression (in RPN form,
of course) pointed to by ptr is a "number" (integer, rational, floating point, or
complex, but not irrational), otherwise it returns FALSE.
Note that 'sqrt(2)'
is not a "number" in this convention.
A complex number is a "number" if both real and imaginary parts are "numbers" in a sense
of the convention given above.
Note: The information about this routine in releases of TIGCCLIB before 2.3 was wrong.
See also: likely_approx_to_number
short is_constant (CESI ptr); 
Checks whether an expression is constant.
is_constant returns TRUE if the expression pointed to by ptr does not rely on any variables (initialized, builtin, but not constants like p), otherwise it returns FALSE.
short is_Float_exact_whole_number (CESI ptr); 
Checks whether a floating point entry is an exact whole number.
is_Float_exact_whole_number returns TRUE if the floating point entry pointed to by ptr is an exact whole number whose magnitude is less than the smallest whole number that is not represented exactly (1e15), otherwise it returns FALSE.
short is_free_of_tag (CESI ptr, ESQ Tag); 
Checks whether an expression is free of a particular tag.
is_free_of_tag is a recursive function which returns TRUE if the expression structure pointed to by ptr is free of tag Tag, otherwise it returns FALSE.
short is_independent_of_de_seq_vars (CESI ptr); 
Checks whether an expression is independent of differential equation and sequence variables.
is_independent_of_de_seq_vars returns TRUE if the expression pointed to by expr_ptr is independent of system variables which are used for differential equation and sequence graphing (i.e. variables u1u99 and y1'y99'), otherwise it returns FALSE.
short is_independent_of_elements (CESI expr_ptr, CESI varlist_ptr); 
Checks whether an expression is independent of the elements of a list.
is_independent_of_elements is very similar to is_independent_of_tail. Assuming that varlist_ptr points to the list of variables or expressions (more precise, to the LIST_TAG of such list), is_independent_of_elements returns TRUE if the expression pointed to by expr_ptr is independent of all variables from the list pointed to by varlist_ptr, otherwise it returns FALSE. More precisely,
is_independent_of_elements (expr_ptr, varlist_ptr)
is the same as
is_independent_of_tail (expr_ptr, varlist_ptr  1)
short is_independent_of_tail (CESI expr_ptr, CESI start_ptr); 
Checks whether an expression is independent of a sequence of variables (or expressions).
is_independent_of_tail returns TRUE if the expression pointed to by expr_ptr is independent of all entries on the expression stack stored below start_ptr up to END_TAG tag, otherwise it returns FALSE.
See also: is_independent_of, is_independent_of_elements, map_tail, all_tail
short is_independent_of (CESI expr_ptr, CESI var_ptr); 
Checks whether an expression is independent of a variable (or expression).
is_independent_of returns TRUE if the expression pointed to by
expr_ptr is independent of the variable pointed to by
var_ptr, else returns FALSE. Although var_ptr
may point to something which is not a variable, the independence of the "expression"
is not well defined, so avoid such situations until more information about what
such "independence" means (TI says that this means "syntactical independence", but
this is not well defined either).
Note: This routine (and all other "independence" routines also)
is not reliable if expressions are not in internal canonic form
(see push_internal_simplify).
short is_matrix (CESI ptr); 
Checks whether an expression is a matrix.
is_matrix returns TRUE if the expression pointed to by ptr is a matrix (i.e. a list which consists of equally sized lists), otherwise it returns FALSE.
short is_minus1 (CESI ptr); 
Tests if an expression is equal to 1.
Returns TRUE if the expression pointed to by ptr is equal to negative one (integer or floating point).
short is_monomial_in_kernel (CESI ptr); 
Checks whether an expression is a monomial in kernel.
is_monomial_in_kernel returns TRUE if the expression pointed to by
ptr is a monomial in kernel, i.e. if it is a monomial function of kernels,
where "kernel" means any irrational subexpression, else returns FALSE.
For example, 'sin(x)*ln(y)'
is not monomial (in respect to 'x'
and 'y'
), but it is monomial in kernel (in respect to 'sin(x)'
and 'ln(y)'
).
short is_monomial (CESI ptr); 
Checks whether an expression is a monomial.
is_monomial returns TRUE if the expression pointed to by
ptr is a monomial expression, otherwise it returns FALSE.
For example, the expression 'x*y^3'
is a monomial, and
x+y*z'
or 'ln(x)'
are not.
short is_narrowly_independent_of (CESI expr_ptr, CESI var_ptr); 
Checks whether an expression is narrowly independent of a variable (???).
is_narrowly_independent_of returns TRUE if the expression pointed to by expr_ptr is narrowly independent of the variable pointed to by var_ptr, otherwise it returns FALSE. I am not sure what "narrowly independent" really means, and what the difference between this function and is_independent_of is.
short is_negative (CESI ptr); 
Tests if an expression is less than 0.
Returns TRUE if the expression pointed to by ptr is known to be negative, FALSE otherwise.
See also: is_nonnegative, is_positive, is_nonpositive
short is_never0 (CESI ptr); 
Tests if an expression is never 0.
Returns TRUE if the expression pointed to by ptr cannot be equal to zero.
See also: is0
short is_nonnegative (CESI ptr); 
Tests if an expression is >= 0.
Returns TRUE if the expression pointed to by ptr is known to be positive or zero, FALSE otherwise.
See also: is_negative, is_positive, is_nonpositive
short is_nonpositive (CESI ptr); 
Tests if an expression is <= 0.
Returns TRUE if the expression pointed to by ptr is known to be negative or zero, FALSE otherwise.
See also: is_positive, is_negative, is_nonnegative
short is_polynomial_in_var_or_kern (CESI test, CESI var_or_kern); 
Checks if an expression is a polynomial with respect to another expression.
is_polynomial_in_var_or_kern returns TRUE if the expression pointed to by test is a polynomial with respect to the expression var_or_kern, otherwise it returns FALSE. The definition of "polynomial with respect to" is more complicated when dealing with expressions in var_or_kern. For example, "x+sin(x)" is polynomial with respect to "sin(x)" but not to "x". Interestingly, when testing with respect to "sin(x)", "x" seems to be treated like a constant.
short is_positive (CESI ptr); 
Tests if an expression is greater than 0.
Returns TRUE if the expression pointed to by ptr is known to be positive (not zero), FALSE otherwise.
See also: is_nonpositive, is_negative, is_nonnegative
short is_square_matrix (CESI ptr); 
Checks whether an expression is a square matrix.
is_square_matrix returns TRUE if the expression pointed to by ptr is a square matrix, otherwise it returns FALSE.
short is_symmetric (CESI expr_ptr, CESI var_ptr); 
Checks for symmetry.
is_symmetric returns TRUE if the expression pointed to by expr_ptr is such that it remains the same when the variable pointed to by var_ptr changes its sign, otherwise it returns FALSE.
short is_tail_independent_of (CESI start_ptr, CESI var_ptr); 
Checks whether a sequence of expressions is independent of a variable (or expression).
is_tail_independent_of returns TRUE if all expressions on the expression stack which are stored below start_ptr up to END_TAG are independent of the variable pointed to by var_ptr, otherwise it returns FALSE.
See also: is_independent_of, map_tail, all_tail
short is_totally_polynomial (CESI ptr); 
Checks if an expression is polynomial in all variables.
is_totally_polynomial returns TRUE if the expression pointed to by ptr is polynomial with respect to all variables  that is, consists only of variables raised to positive constant powers (with coefficients) and multiplied or added together. Otherwise it returns FALSE.
short is_valid_smap_aggregate (CESI ptr); 
Checks whether an expression is a valid aggregate type.
is_valid_smap_aggregate returns TRUE if the expression pointed to by ptr is a valid aggregate type (i.e. list or valid matrix), otherwise it returns FALSE. This is not a simple check whether a tag pointed to by ptr is LIST_TAG. For example, list which consists of lists which are not equally sized (like {{1,2,3},{4,5}}) are not valid. Also, matrices whose elements are list or matrices are also not valid aggregate types.
short is_variable (CESI ptr); 
Checks if the expression is a variable.
is_variable returns TRUE if the expression is a variable and FALSE if it is not.
short is_whole_number (CESI ptr); 
Tests if an expression is a whole number.
Returns TRUE if the expression pointed to by ptr is a whole number (it can be a floatingpoint value).
ESI last_element_index (CESI ptr); 
Searches for the last expression in the list.
last_element_index calls next_expression_index in a loop starting from ptr until END_TAG is reached, then returns the pointer to the last encountered expression before END_TAG. So, assuming that ptr points to a member of the list (including argument lists too), last_element_index will return the pointer to the last element of the list.
ESI lead_base_index (CESI ptr); 
Gets the index of the base of the lead factor of an expression.
lead_base_index first calls lead_factor_index, then applies factor_base_index to the result. So, it returns the pointer to the base of the lead factor (i.e. the lead base) of the expression pointed to by ptr.
ESI lead_exponent_index (CESI ptr); 
Gets the index of the exponent of the lead factor of an expression.
lead_exponent_index first calls lead_factor_index, then applies factor_exponent_index to the result. So, it returns the pointer to the exponent of the lead factor (i.e. the lead exponent) of the expression pointed to by ptr.
ESI lead_factor_index (CESI ptr); 
Gets the index of the lead factor of an expression.
If ptr points to the MUL_TAG, which is the case when it
points to an expression of form factor1 * factor2 * ...
(i.e. if the expression is a product of simpler factors), lead_factor_index returns the pointer
to factor1 (i.e. to the lead factor). If ptr does not point to the
MUL_TAG (i.e. if the expression is not a product of simpler factors),
lead_factor_index returns ptr (i.e. the pointer to the expression itself).
Note: Expressions in internal canonic form have the most main factor shallowest, with less main factors deeper
(see compare_expressions for more info about "main"
ordering). Also, the lead factor of an internallysimplified product is never a product.
For example, lead factor of '(3*x^2)*y'
converted into canonic form is
'x^2'
. Internallysimplified numeric denominator factors are combined with
numeric numerator factors into a fractional numeric factor. Nonnumeric denominator
factors are internally simplified to be merged with numerator factors as negative powers.
For example, the lead factor of '2/x'
converted into canonic form is
'x^1'
. A factor having a sum as its base orders shallower than a factor
having the sum’s main variable as its base. For example, the lead factor
of '(x+1)^2*x^3'
converted into canonic form is '(x+1)^2'
.
See push_internal_simplify
for more info about how to convert an expression into the internal canonic form.
ESI lead_term_index (CESI ptr); 
Gets the index of the lead term of an expression.
If ptr points to the ADD_TAG, which is a case when it
points to an expression of form term1 + term2 + ...
(i.e. if the expression is a sum of simpler terms), lead_term_index returns the pointer
to term1 (i.e. to the lead term). If ptr does not point to the
ADD_TAG (i.e. if the expression is not a sum of simpler terms),
lead_term_index returns ptr (i.e. the pointer to the expression itself).
Note: Expressions in internal canonic form have the most main term shallowest, with less main
terms deeper (see compare_expressions about more info about
"main" ordering). Also, the lead term of an internallysimplified sum is never a sum.
For example, the lead term of '(2+x)+y'
converted to canonic form is 'x'
.
By default, similar powers of the main variable are collected in internal canonic forms.
For example, the lead term of 'x^2*y+x^2+5'
converted to canonic form is
'x^2*(y+1)'
. See push_internal_simplify
for more info about how to convert an expression into the internal canonic form.
short likely_approx_to_complex_number (CESI ptr); 
Checks if it is likely that an expression can be approxed to a complex number.
likely_approx_to_complex_number is very similar to likely_approx_to_number, except that it checks for the possibility of approximation to numbers which need not be real numbers.
short likely_approx_to_number (CESI ptr); 
Checks is it likely that an expression can be approxed to a real number.
If likely_approx_to_number returned TRUE, it is sure that the expression pointed to by
ptr can be approxed to a real number, but returning FALSE
does not mean that the approximation is not possible: it only means that the approximation
to a number is not obvious. For example, it is obvious that expression
'ln(2+sin(1))/5'
can be approxed to a number, but this is not so obvious for
expression 'x^2+1x*x'
, because it
contains a symbolic variable name. See can_be_approxed for a more
detailed investigation of possibility of approximation.
ESI main_gen_var_index (CESI ptr); 
Searches an expression for a generalized variable.
main_gen_var_index is a variant of index_main_var, but it
searches for a "generalized variable", which may also be a subexpression. For example,
if the expression is 'sin(x)+y'
, index_main_var
will return a pointer to 'x'
, but main_gen_var_index will return a pointer to
'sin(x)'
. Generalized variable can be an ordinary variable, the base of a
noninteger power, or a kernel (like 'sin(x)'
), meaning any other irrational
subexpression.
More precise, main_gen_var_index skips all ADD_TAG,
MUL_TAG and POW_TAG tags, then stops at the
first tag which is not equal to some of them. In addition to this, if the tag is
POW_TAG, function next_expression_index
will be called, to get access to the base of the power (note that "powers" cannot be
"reorganized" on such way that constants are always in front of variables, because '2^x'
and 'x^2'
are not the same expression). This implies that "main generalized variable"
of a sum, a product or an integer power is equal to the main generalized variable of a lead term,
a lead factor or a base respectively. Otherwise, main generalized variable is the expression
itself. For example, main "generalized variables" of expressions 'sin(x)^2*y+ln(z)'
,
'3^(1/5)+2'
and '(x+y)^(1/2)+x'
are 'sin(x)'
,
'3'
and 'x+y'
respectively.
short map_tail_Int (ESI_Callback_Int_t f, ESI start_ptr, short n); 
Applies an extended function to all elements in the list.
map_tail_Int is very similar to map_tail, except callback function f has one additional parameter n. Each time f is called, the parameter n passed to map_tail_Int is passed to f. Also, the callback function is not void but returns a Boolean value (TRUE or FALSE). The result of map_tail_Int is the logical OR of all the values returned by f.
void map_tail (ESI_Callback_t f, ESI start_ptr); 
Applies a function to all elements in the list.
map_tail first pushes END_TAG on the expression stack, then
calls callback function f for every expression on the expression stack
(in reversed order), starting from the expression pointed to by start_ptr until
END_TAG is reached. Each time f is called, a pointer to the
actual expression is passed to it. This function is very useful if you want to apply some
operation on all elements of the list (then start_ptr need to point to the first
element of the list). If the callback function does not push anything on the stack, the
END_TAG pushed by map_tail should probably be deleted.
Note: map_tail calls next_expression_index
to step from one expression to another.
void map_unary_over_comparison (ESI_Callback_t f, ESI cmptag_ptr); 
Calls callback function for both comparison terms and pushes the comparison tag.
map_unary_over_comparison assumes that cmptag_ptr
points to a comparison tag. It calls the callback function f twice, passing to it pointers
to both comparison terms, i.e. the two expressions below the comparison tag (the callback function
should push something to the expression stack). The callback function is applied first to the
deeper argument on the stack, then to the shallower argument. Finally, map_unary_over_comparison
will push the tag pointed to by cmptag_ptr (one byte) to the expression stack.
This function is useful to perform some transformations on both sides of a comparison
(e.g. to transform 'n<5'
into 'n!<120'
). Beware that squaring of
both sides of an inequality can cause loss of solutions, and squaring both sides of an
equation may introduce spurious solutions!
ESQ min_quantum (ESQ Tag1, ESQ Tag2); 
Finds smaller of two tags.
min_quantum returns Tag1 if it is smaller than Tag2, else returns Tag2.
void move_between_to_top (ESI ptr1, ESI ptr2); 
Moves a sequence of bytes to the top of the expression stack.
move_between_to_top moves a sequence of bytes between ptr1 and ptr2 (more precise, starting at ptr1+1 and ending at ptr2) to the top of the expression stack. It acts like a combination of push_between and delete_between (in fact, it is). This routine assumes that ptr1 and ptr2 really point to parts of the expression stack and that ptr2 is above ptr1, otherwise the result is unpredictable.
unsigned short moved_between_to_top (ESI ptr1, ESI ptr2); 
Moves a sequence of bytes to the top of the expression stack.
moved_between_to_top acts like move_between_to_top, but it also returns a number of moved bytes. It calls deleted_between instead of delete_between.
void negate_top (void); 
Negates the top of the estack.
negate_top changes the sign of the expression on the top of the estack.
See also: add_to_top, subtract_from_top, and_onto_top
ESI next_expression_index (CESI ptr); 
Finds the next entry on the expression stack.
Assuming that ptr points to an expression entry on the expression stack,
next_expression_index returns the pointer which points to an expression which is
located just below the expression pointed to by ptr. So, by successive calls
to next_expression_index starting from top_estack, you
can locate all expressions on the stack. This command will throw an error if
ptr points to the END_TAG, so be careful.
Note: next_expression_index calls index_after_match_endtag
for TIBasic functions and program tags, so that inline functions are counted as entire
expressions rather than of their components.
void NG_approxESI (CESI ptr); 
Evaluates an expression in "APPROX" mode.
NG_approxESI executes the entry on the expression stack pointed to by ptr (it needs to point to the entry tag) in "APPROX" mode, then pushes the result (i.e. a new expression) on the top of the expression stack. The pushed result is NOT in internal canonic form (if necessary, do push_internal_simplify to force conversion to the internal canonic form). The following example illustrates this very powerful command:
push_parse_text ("sin(1.3)+log(2)/7"); NG_approxESI (top_estack); printf_xy (0, 50, "%f", estack_number_to_Float (top_estack));
See push_parse_text and estack_number_to_Float
to understand how this example works.
Note: The expression must not contain TIBasic statements.
For executing TIBasic statements, use NG_execute. Also, this
command may cause expansion of the expression stack or heap compression, and may throw
various errors is something is wrong.
void NG_execute (HANDLE Handle, short approx_flag); 
Executes TIBasic statements.
NG_execute executes a sequence of TIBasic statements in tokenized form, which are located in a memory block pointed to by handle Handle. It is a handle to a MULTI_EXPR structure. To create such a block, the functions push_parse_text and HS_popEStack may be very useful, like in the following example:
push_parse_text ("ClrGraph:Graph sin(x)"); handle = HS_popEStack (); NG_execute (handle, FALSE); HeapFree (handle);
If approx_flag is nonzero, the sequence will be executed in "approx" mode
(like running with [DIAMOND]+[ENTER]). Otherwise, the current mode settings will be used.
This routine is called after NG_RPNToText from the home screen.
NG_execute can also evaluate expressions. In this case, the result of the evaluation
is pushed on the top of the expression stack.
Note: This routine always clears the error context, resets control flags, may cause estack
expansion or heap compression. It may throw various errors if something is wrong.
void NG_graphESI (CESI ptr, HANDLE Handle); 
Evaluates an expressions for graphing purposes.
NG_graphESI is the function used in TIOS during drawing function graphs. It evaluates the entry on the expression stack pointed to by ptr in "APPROX" mode then pushes the result on the top of the expression stack, similar to what NG_approxESI does, but NG_graphESI requires that all variables in the expression must be defined, i.e. the expression must evaluate to a number (else "Undefined variable" error will be thrown). Handle is the handle of the function in which the expression is defined. I don't know exactly when and why this function needs this handle (probably to check which variables are parameters of the function, which variables are local etc.). When I tried to pass H_NULL to this function, nothing bad happened. However, in the absence of more info, avoid this function.
void NG_rationalESI (CESI ptr); 
Evaluates an expression in "EXACT" mode.
NG_rationalESI executes the entry on the expression stack pointed to by ptr
(it needs to point to the entry tag) in "EXACT" mode, then pushes the result (i.e. a new
expression) on the top of the expression stack. See the example of usage given with
display_statements. The same notes given with
NG_approxESI are true with this command too.
Note: The expression must not contain TIBasic statements.
For executing TIBasic statements, use NG_execute. Also, this
command may cause expansion of the expression stack or heap compression, and may throw
various errors is something is wrong.
HANDLE NG_RPNToText (HANDLE hRPN, unsigned short NewLines, unsigned short FullPrec); 
Detokenizes a tokenized structure associated with a handle.
NG_RPNToText detokenizes a tokenized structure (an expression, TIBasic statement or a group of statements) associated with handle hRPN and returns a handle to the memory block where detokenized string is stored (you don't need to allocate anything by yourself, this function will do it instead). The first word of the data associated with hRPN should be the length of the data which is used to find the first tag of the tokenized data. It throws an error if the detokenization fails. This function is mainly identical to display_statements except NG_RPNToText requires a handle instead of the pointer to the structure which needs to be detokenized. See display_statements for more info.
short NG_tokenize (HANDLE hTEXT, unsigned short *ErrCode, unsigned short *ErrOffset); 
Tokenizes text associated with a handle and pushes them to the expression stack.
NG_tokenize is more powerful variant of push_parse_text. It tokenizes the text associated with the handle hTEXT, and pushes the converted text to the expression stack. Returns TRUE if the operation was successful, otherwise it returns FALSE. If there was an error, then the variable pointed to by ErrCode contains the error code, and the variable pointed to by ErrOffset contains the offset in the text where the error occurred. If there were not any errors, then the variable pointed to by ErrCode contains multi state (this is the result returned from push_parse_text) and ErrOffset is undefined. This routine may expand the expression stack, may cause the heap compression, or even may throw an error if something goes really wrong (not enough memory, for example).
float norm1_complex_Float (CESI ptr); 
Finds the 1norm of a complex number entry.
norm1_complex_Float finds the 1norm (i.e. the sum of absolute values of real and imaginary part) of the complex number entry pointed to by ptr and returns the result. If the entry is not a complex or real floating point number, the result is garbage (in the case of a real number, norm1_complex_Float reduces to a simple absolute value).
ESI numeric_factor_index (CESI ptr); 
Searches factors in the expression for a numeric factor.
If ptr points to the MUL_TAG, which is a case when it
points to an expression of form factor1 * factor2 * ...
(i.e. if the expression is a product of simpler factors), numeric_factor_index returns the pointer
to the eventual numeric factor in the expression. If the expression is a number, numeric_factor_index
returns ptr (i.e. the pointer to the expression itself). If ptr does not point to
the MUL_TAG (i.e. if the expression is not a product of simpler factors),
or if there is not any numeric factors in the expression, lead_factor_index returns
a pointer to a simple expression which consists only of the number 1 (floating point or integer,
depending of whether the approximation mode is active or not).
Note: This function is not implemented to be very universal. TIOS always "reorganizes" expressions
on such way that numeric factors are at the beginning of the expression (i.e. x*3 will be reorganized
into 3*x), and this function assumes that the expression is organized on such way. This is the socalled
"internal canonic" form, and such expressions always have at most one factor with a numeric tag, in
which case it is the deepest factor. So, '3*x^2*y'
contains a numeric factor (3),
but '2*x+3'
does not. Also, numeric factors in numerators and denominators are
always simplified into a single numeric factor in internal canonic forms (so, the numeric
factor of '6*x/(4*y)'
after conversion to canonic form is 3/2. Fortunately,
all expressions in arguments are always in internal canonic form. However, this is not true after
push_parse_text function, nor after an evaluation using
NG_rationalESI or NG_approxESI. In
other words, results of these commands are not always "correctly" organized. To force converting
an expression to the internal canonic form, always call
push_internal_simplify after usage any of functions
mentioned above.
void Parms2D (CESI ptr, short *Width, short *Bottom, short *Top); 
Gets information about dimensions of block which will be "pretty printed".
Parms2D gets information about the screen space which will be occupied by displayed expression. It should be called after calling Parse2DExpr (or Parse2DMultiExpr), and ptr should be a result returned from it. Params2D stores the information in three variables pointed to by Width, Bottom and Top. Width is the width of the displayed block, and Top and Bottom are distances of top and bottom edge of the block measured from the wanted y position. More precise, if the expression is printed at (x, y) using Print2DExpr, the left corner of the occupied space will be at (x, y*Top), and the right corner of the occupied space will be at (x+*Width, y+*Bottom). So, the 2D expression has an imaginary center line above which is the "Top", and below (counting this line too) is the "Bottom".
HANDLE Parse1DExpr (CESI ptr, unsigned short FullPrec, unsigned short width); 
Parses a tokenized expression to be printed.
Parse1DExpr does a similar job as display_statements (i.e. converts a RPN expression to the TEXT and returns the handle to the text), but the parameters are somewhat different. Here, width is the maximum width of text result (0 indicates no width restriction). So, when necessary, symbolic expressions are truncated to width1 characters and terminated with an ellipsis character ('...'). When ptr points to a tagged floating point number, the number is rounded to fit in width characters. When the number cannot be rounded to fit in width characters, an ellipsis character ('...') is returned. See display_statements for more info.
ESI Parse2DExpr (CESI ptr, unsigned short FullPrec); 
Parses a tokenized expression to be pretty printed using Print2DExpr.
Parse2DExpr parses the expression pointed to by ptr, so it can be displayed with
Print2DExpr. This function splits up expression into blocks with
information about their relative position and size. This splitting is performed for
efficiency reasons, so the expression may be displayed again without having to calculate
the positions again. Parse2DExpr returns the pointer to a created structure (it needs to be
passed to Print2DExpr). This pointer is in fact the new
value of top_estack, because the created structure (known as "boxed RPN")
is also pushed on the expression stack. FullPrec is a Boolean flag:
when it is nonzero, all floating point values will be converted using the maximal precision
(14 digits), else current precision settings (from TIBasic MODE dialog) will be used.
If there is not enough memory, a special symbol is pushed onto the expression stack to signify
this. This routine may cause heap compression.
See Print2DExpr for an example of usage.
Parse2DExpr will always convert expressions into the "canonic printing (external) form".
For example, both x*3 and 3*x will be displayed as 3*x, x*y^(1) will be displayed as x/y etc.
Note: Break key (ON) is checked during execution of this function, and pressing it will throw
an error!
ESI Parse2DMultiExpr (HANDLE Handle, unsigned short FullPrec); 
Parses a multistatement expression associated with a handle to be pretty printed using Print2DExpr.
Parse2DMultiExpr parses a multiexpression (see MULTI_EXPR) associated with Handle so that it can be displayed with Print2DExpr. Parameter FullPrec has the same meaning as in Parse2DExpr. The expression associated with Handle may contain multiple expressions separated with NEXTEXPR_TAG (in opposite to Parse2DExpr). I must admit that I don't understand this function very well, so avoid it except if you know about it more than I know...
void Print2DExpr (CESI ptr, WINDOW *w, short x, short y); 
Performs "pretty printing" (or "2D printing") of an expression.
Print2DExpr prints the expression in "pretty" or "2D" style. Before printing, the expression
needs first to be "parsed" using Parse2DExpr, and argument ptr
should be a result returned from Parse2DExpr
(an error may be thrown if ptr points to something else). w is a pointer
to the WINDOW structure which describes the window in which
the expression will be displayed (see wingraph.h header file for
more info about windows). If you didn't create your own windows in the program, you can pass
DeskTop as the parameter (as in the example given below).
x and y are coordinates (windowrelative) where the expression will be printed.
x determines the left edge of the expression, and the expression goes (in y direction)
both above and below the value of y. See Parms2D for exact
information about dimensions of displayed expression. If the displayed expression can not fit
into the given window, it will be simply clipped at edges of the window.
Here is an example (called "Pretty Print") which first calculates the integral of 1/((x3)(x^2+4)), then "pretty prints"
the result on the screen:
// Calculate an integral and pretty print it #define USE_TI89 // Compile for TI89 #define USE_TI92PLUS // Compile for TI92 Plus #define USE_V200 // Compile for V200 #define MIN_AMS 101 // Compile for AMS 1.01 or higher #define SAVE_SCREEN // Save/Restore LCD Contents #include <tigcclib.h> // Include All Header Files // Main Function void _main(void) { TRY push_END_TAG (); push_quantum (VAR_X_TAG); push_parse_text ("1/((x3)(x^2+4))"); push_quantum (INTEGRATE_TAG); NG_rationalESI (top_estack); WinClr (DeskTop); Print2DExpr (Parse2DExpr (top_estack, FALSE), DeskTop, 0, 50); ONERR DrawStr (20, 20, "Error!", A_NORMAL); ENDTRY ngetchx (); }
It is also possible to use
Parse2DExpr (top_estack, FALSE); Print2DExpr (top_estack, DeskTop, 0, 50);
instead of
Print2DExpr (Parse2DExpr (top_estack, FALSE), DeskTop, 0, 50);
You can use Parms2D to get information about the height and the width of the printed expression without displaying it on the screen. This may be used to determine coordinates where the expression needs to be displayed.
void push_ANSI_string (const char *str); 
Pushes a standard C string to the expression stack.
push_ANSI_string is an alias (known from earlier versions of the TIGCC Library) for the TIOS function push_zstr.
void push_between (void *ptr1, void *ptr2); 
Pushes a sequence of bytes to the expression stack.
push_between pushes a sequence of bytes starting at ptr1+1 and ending at ptr2
to the expression stack.
Note: The break key (ON) is checked during execution of this routine, and an error is thrown if
it is pressed!
void push_cnvrt_integer_if_whole_nmb (CESI ptr); 
Pushes a floating point entry eventually converted to an integer.
push_cnvrt_integer_if_whole_nmb checks the entry on the expression stack pointed to by ptr. If it is not a floating point value (represented by FLOAT_TAG), or if it is a floating point value which is not a whole number, yet another copy of the entry is pushed on the expression stack. If the entry is a floating point value which is a whole number, this number is pushed on the expression stack, but this time as an integer (i.e. with POSINT_TAG or NEGINT_TAG).
void push_END_TAG (void); 
Pushes endoflist marker to the expression stack.
push_END_TAG pushes END_TAG to the expression stack. This
is the same as push_quantum (END_TAG).
push_END_TAG may be useful when you want to push a list on the expressions
stack: first push END_TAG, then all elements of the list in reverse order, and finally
push LIST_TAG (using push_LIST_TAG).
See also: push_quantum
void push_expr_quantum (CESI ptr, ESQ Tag); 
Pushes an expression followed by a tag to the expression stack.
push_expr_quantum pushes an entry (expression) pointed to by ptr (it needs to point to the entry tag) to the top of the expression stack, then pushes a byte Tag. The entry does not need to be a simple entity; it may be a complex symbolic expression, too. This is achieved by calling next_expression_index and push_between. This function is useful when you need to perform a unary operation on the expression.
See also: push_expression, push_expr2_quantum
void push_expr2_quantum (CESI ptr1, CESI ptr2, ESQ Tag); 
Pushes two expressions followed by a tag to the expression stack.
push_expr2_quantum pushes two entries (expressions) on the expression stack pointed to by ptr1 and ptr2 to the top of the stack, then pushes a byte Tag. This function is useful when you need to perform a binary operation on two expressions.
See also: push_expression, push_expr_quantum
void push_expression (CESI ptr); 
Pushes an expression to the expression stack.
push_expression pushes an entry (expression) pointed to by ptr (it needs to point to the entry tag) to the top of the expression stack. The entry does not need to be a simple entity; it may be a complex symbolic expression, too. This is achieved by calling next_expression_index and push_between.
See also: push_quantum, push_expr_quantum, push_expr2_quantum
void push_Float_to_nonneg_int (float value); 
Rounds a floating point value to an integer, then pushes it to the expression stack.
push_Float_to_nonneg_int rounds value to the nearest integer, then pushes it to the expression stack, as a tagged integer value. The sign of value is ignored. This routine may throw an error if the truncated integer part of value is not representable as a big integer.
void push_Float_to_rat (CESI ptr); 
Pushes a rational approximation of a floating point entry.
push_Float_to_rat finds a rational approximation of the floating point entry pointed to by ptr (of course, ptr points to the tag), and pushes it on the top of the expression stack. The relative error can be specified using the AMS global variable RAtionalize_tol. This routine works well even with transfinite floats (e.g. POSITIVE_INF will be pushed as INFINITY_TAG).
void push_Float (float value); 
Pushes a floating point value to the expression stack.
push_Float rounds value to the 14 significant digits (using round14), then pushes it to the expression stack. If value is not representable as a finite float, the most appropriate transfinite tag is pushed.
void push_internal_simplify (CESI ptr); 
Converts an expression into internal canonic form and pushes the result to the expression stack.
This extremely important lowlevel subroutine converts an expression pointed to by ptr to the internal canonic form (see top_estack for more info about the internal canonic form), and pushes the converted expression at the top of the expression stack. This routine accepts all valid (algebraic, calculus, relational, logical or Boolean) tokenized expressions. During the conversion, various simplifications may be performed as well. This routine may cause heap compression, stack expansion, and may throw an error if something goes wrong.
void push_LIST_TAG (void); 
Pushes list tag to the expression stack.
push_LIST_TAG pushes LIST_TAG to the expression stack. This
is the same as push_quantum (LIST_TAG).
push_LIST_TAG may be useful when you want to push a list on the expressions
stack: first push END_TAG (using push_END_TAG),
then all elements of the list in reverse order, and finally push LIST_TAG.
See also: push_quantum
void push_long_to_integer (long value); 
Pushes a signed long integer to the expression stack.
push_long_to_integer pushes the long integer value value to the expression stack. It is the same as push_longint, except that it is implemented in the operating system instead of by TIGCC.
See also: push_ulong_to_integer, push_ushort_to_integer, push_longint
void push_longint (long value); 
Pushes a long integer to the expression stack.
push_longint pushes the long integer value value to the expression stack.
Note: push_longint is not a TIOS entry; it is implemented "by hand" using
push_quantum. This means that either
push_shortint or push_longint should be used in a
program, but using both is usually not desirable.
See also: push_shortint, push_longlongint
void push_longlongint (long long value); 
Pushes a doublelong integer to the expression stack.
push_longlongint pushes the doublelong integer value value to the expression stack.
Note: push_longlongint is not a TIOS entry; it is implemented "by hand" using
push_quantum.
See also: push_shortint, push_longint
void push_next_arb_int (void); 
Pushes a next "arbitrary integer" symbol to the expression stack.
push_next_arb_int pushes a next "arbitrary integer" symbol (i.e. symbol @nxxx) to the top of the expression stack. More precise, it increments an internal counter for arbitrary integers, pushes the counter on the stack, then pushes ARB_INT_TAG. The counter wraps to zero after 255 is reached.
void push_next_arb_real (void); 
Pushes a next "arbitrary real" symbol to the expression stack.
push_next_arb_int pushes a next "arbitrary real" symbol (i.e. symbol @xxx) to the top of the expression stack. More precise, it increments an internal counter for arbitrary reals, pushes the counter on the stack, then pushes ARB_REAL_TAG. The counter wraps to zero after 255 is reached.
void push_next_internal_var (ESQ Tag); 
Pushes an internal variable to the expression stack.
push_next_internal_var is an auxiliary function used in calculus operations. It pushes the sequence 0, Tag+1, count, 0 to the expression stack, where count is the internal counter of internal variables. Then, the counter is increased by one. TIOS usually passes 0 or 1 for Tag, so it manages a two independent sets of internal variables. You can see that internal variable names consist of two bytes (see VAR_NAME_TAG): one byte is "set number", and another byte is "number of a variable in the set".
unsigned short push_offset_array (CESI elements_ptr, unsigned short **dest); 
Pushes an array of offsets to the list items.
This function is not complicated, but it is a bit hard to explain.
It first increments the pointer to the top of the expression stack to the
nearest even address, then pushes a word array which contains the offsets to all entries
on the expression stack below elements_ptr until END_TAG is
reached. The offset is expressed relative to the elements_ptr.
push_offset_array returns the size of pushed array in words (i.e. the number of elements),
and stores in the pointer variable pointed to by dest the top address of pushed
array. For example, if you execute the following sequence
unsigned int *offsets;
ESI esi;
unsigned int count;
...
esi=top_estack;
count=push_offset_array (esi, &offsets);
then
esioffsets[0],
esioffsets[1],
esioffsets[2],
..., esioffsets[1count]
will point to entries on the expression stack.
esioffsets[0] will point to the further entry from the
top of the expression stack,
esioffsets[1] will point
to the next one, and finally,
esioffsets[1count] will
point to the entry on the top of the expression stack (more precise,
offsets[1count] is always zero). This function is useful
when you need a fast way to access to all entries on the expression stack many times.
void push_overflow_to_infinity (ESQ inf_tag); 
Displays a warning, and pushes a tag to the expression stack.
push_overflow_to_infinity displays the warning message "Warning: Overflow replaced by INF or INF", then pushes byte inf_tag to the expression stack (it is usually INFINITY_TAG or NEGINFINITY_TAG).
short push_parse_text (const char *str); 
Parses an expression given in a string and pushes tokenized expression to the expression stack.
push_parse_text is an extremely powerful function: it parses the expression given in the
string str, and pushes the expressions (in RPN form) to the expression stack.
This function also can parse TIBasic statements (after parsing, the tokenized form of these
statements is pushed on the expression stack too). push_parse_text returns FALSE
if the expression is a multi expression (i.e. if it contains ":" [separator], ">" [store] or
TIBasic statements), otherwise it returns TRUE. This routine may cause expansion
of the expression stack or heap compression.
TIGCCLIB internally uses this function (together with estack_number_to_Float)
in the implementation of atof function.
For more examples of usage of this function, see NG_approxESI,
NG_rationalESI, NG_execute etc.
The "inverse" function of push_parse_text is display_statements.
If you want to perform highly advanced symbolic operations with expressions, you should know that expressions
created by push_parse_text are not always organized on a way which allows the most efficient symbolic
processing (socalled internal canonic form). For example, TIOS always converts 'x*3'
into '3*x'
and converts
'xy'
into 'x+y*(1)'
, although it will be printed as
'xy'
. However, expressions
created by push_parse_text are always asis, i.e.
'3*x'
will be just '3*x'
, not 'x*3'
. Some routines
(like numeric_factor_index for example) may be fooled if
the expression is not "sorted" correctly. Also, some routines
(like lead_term_index, lead_factor_index
etc.) may also be fooled with expressions like 'xy'
and
'x/y'
, because operators ''
and '/'
are usually never seen in
expressions during symbolic processing (the processing is more unique if addition and
subtraction are treated as the same operation; the same is true for '*'
and
'/'
). So, if you
planed to perform some advanced symbolic processing which is based on accessing various
part of the expression, always call push_internal_simplify
after calling push_parse_text. This function pushes on the expression stack the same expression
but converted in internal canonic form.
Note: push_parse_text will throw an error if the string contains expression with wrong
syntax, so you need to use TRY etc. to catch
eventual errors. And, the string must be built using TIBasic conventions (for
example, you must use 0xAD ("small" minus) instead of ''
for
unary minus, etc. See NG_tokenize for a more powerful function which
doesn't throw any errors, and which can determine the exact location and type of the error.
void push_quantum_pair (ESQ Tag1, ESQ Tag2); 
Pushes two bytes (tags) to the expression stack.
push_quantum_pair pushes the bytes Tag1 and Tag2 to the expression stack. Basically, it acts like:
push_quantum (Tag1); push_quantum (Tag2);
but it is a little more optimized.
See also: push_quantum
void push_quantum (ESQ Tag); 
Pushes a byte (tag) to the expression stack.
push_quantum is the basic function for manipulating the expression stack, and many other functions are based on it. It pushes a byte Tag to the expression stack. For example, you can push a complex value to the expression stack using the following construction:
push_Float (real_part); push_Float (imaginary_part); push_quantum (COMPLEX_TAG);
See push_Float, and info about top_estack
and Tags for more info about this example.
Note: This routine (as well as all other "push_..." routines) may cause heap compression, and
may throw an error if there is not enough space on the expression stack.
See also: push_quantum_pair, push_expression, push_expr_quantum
void push_reversed_tail (CESI ptr); 
Pushes elements of the list up to tail onto the stack in reversed order.
push_reversed_tail first pushes END_TAG to the expression stack, then pushes all expressions starting from the expression pointed to by ptr one by one (by calling next_expression_index) until END_TAG is reached. So after calling this function, the expressions up to tail will be pushed onto the stack in reversed order. See other "tail" operations like map_tail.
void push_round_Float (CESI ptr); 
Pushes an approximation of a floating point entry.
push_round_Float first finds a rational approximation of the floating point entry pointed to by ptr using push_Float_to_rat, then converts this fraction back to the floating point number and pushes it on the top of the expressions stack. The summary effect is rounding float to the precision of about 1e5.
void push_shortint (short value); 
Pushes a short integer to the expression stack.
push_shortint pushes the short integer value value to the expression stack.
Note: push_shortint is not a TIOS entry; it is implemented "by hand" using
push_quantum. This means that either
push_shortint or push_longint should be used in a
program, but using both is usually not desirable.
See also: push_longint, push_longlongint
void push_simplify (CESI ptr); 
Simplifies the argument and pushes onto the estack.
push_simplify is like push_internal_simplify, but does not convert into internal canonic form.
void push_transpose_aux (CESI ptr, short ConjFlag); 
Pushes transposed matrix to the expression stack.
Assuming that ptr points to the tag of a matrix (which is, in fact, a list of equally sized lists), push_transpose_aux pushes the transpose of the matrix to the expression stack. If ConjFlag is TRUE, a complex conjugate transpose will be produced, and if ConjFlag is FALSE, an ordinary transpose will be produced. For complex conjugate transposition, the matrix should be in canonic internal form (see push_internal_simplify). If ptr doesn't point to a matrix, the behavior is unpredictable.
void push_ulong_to_integer (unsigned long value); 
Pushes an unsigned long integer to the expression stack.
push_ulong_to_integer pushes the long integer value value to the expression stack. It is the same as push_long_to_integer, except that the value is interpreted as an unsigned value.
See also: push_long_to_integer, push_ushort_to_integer, push_longint
void push_ushort_to_integer (unsigned short value); 
Pushes an unsigned short integer to the expression stack.
push_ushort_to_integer pushes the short integer value value to the expression stack. It is the same as push_shortint, except that the value is interpreted as an unsigned value, and that it is implemented in the operating system instead of by TIGCC.
See also: push_long_to_integer, push_ulong_to_integer, push_shortint
void push_zstr (const char *str); 
Pushes a standard C string to the expression stack.
push_zstr pushes the string str to the expression stack. str is a standard ANSI (zeroterminated) string.
ESI re_index (CESI ptr); 
Gets the index of the real part of an expression.
If ptr points to the COMPLEX_TAG
(i.e. if the expression is complex), re_index returns the pointer
to the real part of the expression. If ptr does not point to the
COMPLEX_TAG (i.e. if the expression is real),
re_index returns ptr (i.e. the pointer to the expression itself).
Note: The expression should be in internal canonic form
(see push_internal_simplify), else this function
is not reliable.
ESI reductum_index (CESI ptr); 
Gets the index of remaining terms of an expression.
If ptr points to the ADD_TAG, which is a case when it
points to an expression of form term1 + term2 + ...
(i.e. if the expression is a sum of simpler terms), reductum_index returns the pointer
to the subexpression term2 + ... (which is a reductum
subexpression of the given expression). If ptr does not point to the
ADD_TAG (i.e. if the expression is not a sum of simpler terms),
reductum_index returns a pointer to a simple zero expression, i.e. expression which
consists only of number 0 (floating point or integer,
depending of whether the approximation mode is active or not).
Note: Expressions in internal canonic form have the most main term
shallowest (see lead_term_index. So, the reductum of
'2+x+y'
converted to canonic form is 'y+2'
.
By default, similar powers of the main variable are collected in internal canonic forms.
For example, the reductum of 'x^2*y+x^2+5'
converted to canonic form is
'5'
. See push_internal_simplify
for more info about how to convert an expression into the internal canonic form.
unsigned short remaining_element_count (CESI start_ptr); 
Returns number of elements remaining.
remaining_element_count counts how many expressions are stored on the expressions
stack below the expression pointed to by ptr (including this one).
END_TAG is treated as the terminator, so eventual expressions
below END_TAG are not counted. So, if ptr points to
an element of the list, remaining_element_count returns the number of elements
in the list starting from this element up to the end of the list.
remaining_element_count works using repeated calling next_expression_index
and increasing a counter until END_TAG is reached.
ESI remaining_factors_index (CESI ptr); 
Gets the index of remaining factors of an expression.
If ptr points to the MUL_TAG, which is a case when it
points to an expression of form factor1 * factor2 * ...
(i.e. if the expression is a sum of simpler terms), remaining_factors_index returns the pointer
to the subexpression term2 * ... (i.e. to the remaining
factors of the expression). If ptr does not point to the
MUL_TAG (i.e. if the expression is not a product of simpler factors),
remaining_factors_index returns a pointer to a simple expression which
consists only of number 1.
Note: Expressions in internal canonic form have the most main factor shallowest, with less main factors
below that (see compare_expressions for more info about "main"
ordering). Also, the lead factor of an internallysimplified product is never a product.
For example, remaining factors of '(3*x^2)*y'
converted into canonic form
are '3*y'
. By default, similar powers of the main variable are collected, so
remaining factor of 'x^2*y+x^2'
after conversion into canonic form is
'y+1'
. Internallysimplified numeric denominator factors are combined with
numeric numerator factors into a fractional numeric factor. Nonnumeric denominator
factors are internally simplified to be merged with numerator factors as negative powers.
See push_internal_simplify
for more info about how to convert an expression into the internal canonic form.
void reset_control_flags (void); 
Resets the control flags for operations with the expression stack.
reset_control_flags resets various control flags which control operations which use the expression stack. It is good idea to call this function before starting any calculation using the expression stack.
void reset_estack_size (unsigned short NewSize); 
Reallocates the expression stack.
reset_estack_size changes the size of the expression stack to NewSize. It throws an error if the requirement cannot be satisfied. If NewSize is smaller than the current amount of used space, then the expression stack is set to the current amount of used space instead of NewSize. Default size of the expression stack is 16384 bytes.
short should_and_did_push_approx_arg2 (CESI arg1_ptr, CESI arg2_ptr); 
Pushes a second floating point argument, if possible.
This function is combination of "push" and "check" operations. If the entry on the expressions stack pointed to by arg1_ptr is not a floating point number (i.e. if arg1_ptr does not point to FLOAT_TAG), this function does nothing and returns FALSE. Otherwise, it checks if it is likely that the entry on the expression stack pointed to by arg2_ptr can be approxed to a real number (using likely_approx_to_number). If it is, should_and_did_push_approx_arg2 pushes the approximated value to the expression stack and returns TRUE, otherwise it does nothing more and returns FALSE.
long signum_Float (CESI ptr); 
Finds the signum of a floating point entry.
signum_Float finds the signum of the floating point entry pointed to by ptr (i.e. returns 1 if the entry is positive, 1 if it is negative, 0 if it is zero). If the entry is not a floating point number, the result is garbage.
void subtract_from_top (CESI ptr); 
Subtracts a value from the top of the estack.
subtract_from_top subtracts the expression pointed to by ptr from the expression currently at the top of the estack.
See also: add_to_top, and_onto_top, negate_top, subtract1_from_top
void subtract1_from_top (void); 
Subtracts 1 from the top of the estack.
add1_to_top subtracts 1 (or 1.0) from the value on the top of the estack. This routine basically calls add_to_top with "1" as the pointedto value.
ESI TokenizeSymName (const char *src, unsigned short Flags); 
Tokenizes a C string into a symbol name.
TokenizeSymName converts a symbol name pointed to by src,
which is an ordinary ANSI C string, into a tokenized form, and pushes the
tokenized form on the expression stack.
After pushing, the new value of top_estack
points to the variable tag on the expression stack. TokenizeSymName returns
the old value of top_estack (which you
can use to restore top_estack), or
NULL_INDEX if the symbol name was invalid.
The parameter Flags is a set of binary flags from
TokenizeSymNameFlags with the
following meaning:
TSF_FULLY_QUALIFIED  Add current default folder to the name if no folder specified in the name (do not use if tokenizing standalone folder names). 
TSF_ALLOW_RESERVED  Allow reserved names to be tokenized (otherwise they cause throwing an error). 
TSF_PASS_ERRORS  Throw errors instead of returning NULL_INDEX. 
See also: StrToTokN
ESQ ARb_int_count; 
Represents the number of times arbitraryinteger variables were already used by some calculus.
Arbitraryinteger variables (of the form "@nx") are generated by TIBasic function calls such as solve(sin(x)=0,x)
.
This variable is set to 0 every time the calculator is reset, or if
cmd_clrhome is called.
ARb_int_count wraps back to 0 after 255.
See also: ARb_real_count, cmd_clrhome, cmd_newprob
ESQ ARb_real_count; 
Represents the number of times arbitrary variables were already used by some calculus.
Arbitrary variables (of the form "@x") are generated by TIBasic function calls such as zeros(0,x)
.
This variable is set to 0 every time the calculator is reset, or if
cmd_clrhome is called.
ARb_real_count wraps back to 0 after 255.
See also: ARb_int_count, cmd_clrhome, cmd_newprob
CESI bottom_estack; 
Points to the bottom of the expression stack.
bottom_estack is a global variable which points to the bottom of the
expression stack, i.e. the first byte used. The quantum at bottom_estack
is always ENDSTACK_TAG. Usually, you should not
change this pointer, although it seems that it is possible to change it
temporarily. If you do this, however, you need to make sure that it is
changed back in any case, even if an error occurs.
This variable can be used together with
top_estack to determine the amount of memory
on the expression stack which is currently used.
The following example (called "Print EStack") prints the values of
bottom_estack and top_estack:
// Print bottom_estack and top_estack #define USE_TI89 // Compile for TI89 #define USE_TI92PLUS // Compile for TI92 Plus #define USE_V200 // Compile for V200 #define MIN_AMS 100 // Compile for AMS 1.00 or higher #define SAVE_SCREEN // Save/Restore LCD Contents #include <tigcclib.h> // Include All Header Files // Main Function void _main(void) { ClrScr (); printf_xy (0, 40, "Bottom = 0x%lp", bottom_estack); printf_xy (0, 50, "Top = 0x%lp", top_estack); ngetchx (); }
See also: top_estack
ESI top_estack; 
Points to the top of the expression stack.
The global variable top_estack points to the top (i.e. the last byte) of the expression stack.
Strictly speaking, in "nostub" mode it is not a real variable but smart macro, although it
works like it is a variable. The expression stack is the place in the memory where TI keeps
expressions during evaluation. All statements are tokenized before being executed
(interpreted). Instructions are reduced to (byte sized) quanta and parsed into Reverse
Polish Notation (RPN). This is a common technique in interpreted languages. Expressions,
functions, etc. are all stored in RPN form, to allow for efficient operation of the expressions
stack. See below for more details about organization of the expression stack.
The actual processing of all expressions is done via the expression stack. The position in the
stack is given by top_estack. Pushing a value appends it to the expression stack and increments
top_estack. When a expression is interpreted, expressions are reduced, and executed as far as
possible. Whatever remains on the stack is the result, this may then be stored or processed
later.
When a file is interpreted the end of the variable is found and it is processed as a separate
expression stack. It is then processed recursively, producing a simplified version on the real
expression stack. Expressions are therefore interpreted from the top (high memory) recursively.
As an artefact of expressions processing mechanism, the arguments of the called program are
kept also on the expression stack. It grows upwards, and the last argument is stored first.
After the assembly program is called, the image of the expression stack is as follows:
The first byte (i.e. the byte with the lowest address) on the stack is END_TAG (0xE5).
Then, a argument list follows, starting from the last argument up to the first argument. So, top_estack points to the last byte of the first argument.
Each string entry on the expression stack is stored as follows (from lower to higher addresses):
One zero byte (starting tag);
Content of the string;
Terminating zero byte;
Byte STR_TAG (0x2D).
Each integer entry is stored as follows:
Bytes of the number in little endian format (i.e. the lowest byte is stored first); the number of bytes varies depending of the size of the number;
A byte which represents the number of the bytes which made the number (note that zero has zerobyte length);
Byte POSINT_TAG (0x1F) or NEGINT_TAG (0x20), depending whether the number is positive or negative (for negative numbers, previous bytes contain the absolute value).
Each fraction entry is stored as follows:
Bytes of the denominator in little endian format (i.e. the lowest byte is stored first); the number of bytes varies depending of the size of the number;
A byte which represents the number of the bytes which made the denominator;
Bytes of the numerator in little endian format;
A byte which represents the number of the bytes which made the numerator;
Byte POSFRAC_TAG (0x21) or NEGFRAC_TAG (0x22), depending whether the fraction is positive or negative (for negative fractions, previous bytes contain absolute values).
Each floating point entry is stored as follows:
Only first 9 bytes of the content of the floating point value are stored (instead of 10), because TIOS always rounds floating point values up to 14 significant digits before pushing them on expression stack (see bcd structure for more information about the internal organization of floating point values);
The last byte is FLOAT_TAG (0x23).
If the entry is complex number, real part is stored first (which can be integer, float,
fraction, etc.), then imaginary part. COMPLEX_TAG (0x9D) is stored after them, so if the
current argument type is complex, decrease the argument pointer by one, then first read
imaginary part, then real part separately.
If the entry is composite (i.e. if it is a list or a matrix), the first byte is end_of_list marker
(byte END_TAG or 0xE5), then follow each element of the list in reverse order (starting
from the last element), and the last byte is LIST_TAG (0xD9).
Now, you surely have an idea how you can pick up elements from the list. Note that a matrix is
a "list of lists".
Signed zeros (POSITIVE_ZERO and
NEGATIVE_ZERO) are represented as
fractions +0/1 and 0/1.
Variable names are stored exactly like strings without terminating STR_TAG (i.e. it is a
sequence of letters bounded with two zero bytes), so "variable" tag is just a zero byte.
There is an exception: oneletter variables have unique onebyte tags (see
Tags for more info. Also, note that variable names are always
stored with lowercase letters. Variables whose names ends with an underscore are assumed
to be complex, and variables whose names starts with an underscore are assumed to
represent physical units.
Expressions are stored in RPN (Reverse Polish Notation) form (also known as postfix form).
So, function calls like func(arg1,arg2,...argn) are stored as sequence
argn ... arg2 arg1 func_tag
and terms like arg1 operator arg2 are stored as
arg1 arg2 operator_tag or
arg2 arg1 operator_tag, depending on the concrete operator.
The situation is analogous for unary operators.
Note that a "pointer to an expression" is a pointer to the last byte of the expression!
When a function (or operator) has variable number of arguments, END_TAG is used to indicate "no more arguments".
See Tags for complete list of various tags. This will be illustrated with
some examples:
Algebraic form:  integrate (e^(x^2), x, 1, 2) 
RPN form:  2 1 x 2 x ^ e ^ integrate 
Sequence of bytes:  [02 01 1F] [01 01 1F] [08] [02 01 1F] [08] [93] [25] [93] [C4] 
Algebraic form:  sum (sqrt (1 + x), x, 0, a) (where sum is actually the capital sigma) 
RPN form:  a 0 x x 1 + sqrt sum 
Sequence of bytes:  [0B] [00 1F] [08] [08] [01 01 1F] [8B] [51] [BA] 
Algebraic form:  a + b + a  b + (a + b) * (a  b) > a 
RPN form:  a b + a + b  a b + a b  * + a > 
Sequence of bytes:  [0B] [0C] [8B] [0B] [8B] [0C] [8D] [0B] [0C] [8B] [0B] [0C] [8D] [8F] [8B] [0B] [80] 
Algebraic form:  {{1, 2}, {3, 4}} 
RPN form:  END_TAG END_TAG 4 3 LIST_TAG END_TAG 2 1 LIST_TAG LIST_TAG 
Sequence of bytes:  [E5] [E5] [04 01 1F] [03 01 1F] [D9] [E5] [02 01 1F] [01 01 1F] [D9] [D9] 
Algebraic form:  my_func (a, b, c) 
RPN form:  END_TAG c b a my_func USERFUNC_TAG 
Sequence of bytes:  [E5] [0D] [0C] [0B] [00 6D 79 5F 66 75 6E 63 00] [DA] 
'x*3'
and
'x+3'
becomes '3*x'
and '3+x'
(although
the second example will be printed as 'x+3'
). Also, expressions like 'x/y'
or
'xy'
in internal canonic form do not contain subtractions and divisions.
As the parameter list (when the program is called from TIBasic) is always in internal
canonic form, such expressions will never be observed asis in parameter lists
etc. because they will be converted before passing them to the program. A lot of functions
for algebraic manipulations automatically convert the expression in the internal canonic form,
but when this is not true, you can always force the conversion using explicit call to
push_internal_simplify function. Note that the reverse conversion
(i.e. back from the canonic form into a regular form) is performed anytime when you try to
print out the expression. Here is the list of the most common transformations which appears
during the transformation into the internal canonic form:
Expression  Standard canonic form 
x  (1)*x 
xy  x+y*(1) 
x/y  x*y^(1) 
e^x  exp(x) 
x^y  exp(ln(x)*y) [ except when "y" is an integer or a fraction ] 
e  exp(1) 
sqrt(x)  x^(1/2) 
log(x)  ln(x)*(ln(10)^(1)) 
sin(x)  trig(x,0) [ assuming "radian" mode; for "trig" function, see SINCOS_TAG ] 
cos(x)  trig(x,1) 
tan(x)  trig(x,0)*trig(x,1)^(1) 
sinh(x)  exp(x)*(1/2)+exp(x)^(1)*(1/2) 
cosh(x)  exp(x)*(1/2)+exp(x)^(1)*(1/2) 
tanh(x)  (exp(x)^2+1)^(1)*(exp(x)^2+(1)) 
x xor y  (not x and y) or (x and not y) 
// Print bottom_estack and top_estack #define USE_TI89 // Compile for TI89 #define USE_TI92PLUS // Compile for TI92 Plus #define USE_V200 // Compile for V200 #define MIN_AMS 100 // Compile for AMS 1.00 or higher #define SAVE_SCREEN // Save/Restore LCD Contents #include <tigcclib.h> // Include All Header Files // Main Function void _main(void) { ClrScr (); printf_xy (0, 40, "Bottom = 0x%lp", bottom_estack); printf_xy (0, 50, "Top = 0x%lp", top_estack); ngetchx (); }
Run this program in VTI and pass to it parameters as you want. top_estack will be shown on the screen. During waiting for a keypress, enter the debugger and look at the addresses shown, to see how parameters are stored.
See also: bottom_estack
#define NULL_INDEX ((CESI) 0) 
Describes an empty expression stack index.
NULL_INDEX is an expression stack index (ESI) equivalent to NULL. It can be used as a function argument in cases where the argument is optional.
typedef CALLBACK unsigned short (*CESI_Callback_t) (CESI); 
Represents a pointer to a CESI callback function.
CESI_Callback_t is a pointer to a function taking a CESI (expression stack index with constant data) as a parameter and returning an integer. It is used in all_tail and any_tail.
typedef const ESQ *CESI; 
Represents a pointer to a constant expression.
The type CESI acts like ESI, but the value pointed to by it may have to be constant. For example, it may be a SYM_STR whose contents are stored at a fixed place in the program.
typedef CALLBACK unsigned short (*ESI_Callback_Int_t) (ESI, unsigned short); 
Represents a pointer to an ESI callback function with integer extensions.
ESI_Callback_Int_t is a pointer to a function taking an ESI (expression stack index) and an integer as a parameter and returning an integer. It is used in map_tail_Int.
typedef CALLBACK void (*ESI_Callback_t) (ESI); 
Represents a pointer to an ESI callback function.
ESI_Callback_t is a pointer to a function taking an ESI (expression stack index) as a parameter and returning nothing. It is used in map_tail and map_unary_over_comparison.
typedef ESQ *ESI; 
Represents an index of a value on the TIOS expression stack.
The type ESI is an "expression stack index", which is, in fact,
a pointer to a tag byte on the TIOS expression stack.
See top_estack and Tags
for more info about the expression stack.
typedef unsigned char ESQ; 
Represents a quantum within an expression.
ESQ represents a quantum (the smallest meaningful unit) of an expression. It can be a tag from the Tags enum, or any other byte value.
#define EStackIndex ESI 
Represents an index of a value on the TIOS expression stack.
EStackIndex is a synonym for ESI.
enum ExtTags {...}; 
An enumeration to describe extra types of entries on the expression stack.
If the tag of an entry on the expression stack is EXT_TAG (0xE3), then the
byte below it is the extra TIBasic function tag. ExtTags is enumerated type for describing
such extended entries (see top_estack for more info about how entries
on the expression stack are organized). This enum is quite big, and here is a complete list of
extended function tags defined in it (all values are in hex), with their meaning (used notation
is RPN):
01  INDIR_TAG  string_expr # (indirection) 
02  GETKEY_TAG  [] getKey 
03  GETFOLD_TAG  [] getFold 
04  SWITCH_TAG  [int] switch 
05  UNITCONV_TAG  unit1 unit2 > (unit conversion, unit1 > unit2) 
06  ORD_TAG  string ord 
07  EXPR_TAG  string expr 
08  CHAR_TAG  int char 
09  STRING_TAG  expr string 
0A  GETTYPE_TAG  var getType 
0B  GETMODE_TAG  string getMode 
0C  SETFOLD_TAG  var setFold 
0D  PTTEST_TAG  y x ptTest 
0E  PXLTEST_TAG  column row pxlTest 
0F  SETGRAPH_TAG  string string setGraph 
10  SETTABLE_TAG  string string setTable 
11  SETMODE_TAG  [] string string setMode 
12  FORMAT_TAG  [string] expr format 
13  INSTRING_TAG  [start] substring searchstring inString 
14  APPEND_TAG  string1 string2 & (append) 
15  DD_TAG  dmsnumber >DD 
16  EXPR2DMS_TAG  expr >DMS 
17  VEC2RECT_TAG  vec >Rect 
18  VEC2POLAR_TAG  vec >Polar 
19  VEC2CYLIND_TAG  vec >Cylind 
1A  VEC2SPHERE_TAG  vec >Sphere 
1B  PARENTH_START_TAG  ( (used only internally for the parser, not in expressions) 
1C  PARENTH_END_TAG  ) (used only internally for the parser, not in expressions) 
1D  MAT_START_TAG  [ (used only internally for the parser, not in expressions) 
1E  MAT_END_TAG  ] (used only internally for the parser, not in expressions) 
1F  LIST_START_TAG  { (used only internally for the parser, not in expressions) 
20  LIST_END_TAG  } (used only internally for the parser, not in expressions) 
21  COMMA_TAG  , (used only internally for the parser, not in expressions) 
22  SEMICOLON_TAG  ; (used only internally for the parser, not in expressions) 
23  COMPLEX_ANGLE_TAG  /_ (used only internally for the parser, not in expressions) 
24  SINGLE_QUOTE_TAG  ' (used only internally for the parser, not in expressions) 
25  QUOTE_TAG  " (used only internally for the parser, not in expressions) 
26  POLCPLX_TAG  magnitude angle /_ (polar complex number) 
27  TMPCNV_TAG  expr2 expr1 tmpCnv 
28  DELTA_TMPCNV_TAG  expr2 expr1 DtmpCnv 
29  GETUNITS_TAG  [] getUnits 
2A  SETUNITS_TAG  list setUnits 
2B  BIN_TAG  int 0b (i.e. 0bint) 
2C  HEX_TAG  expr 0h (i.e. 0hexpr) 
2D  INT2BIN_TAG  int >Bin 
2E  INT2DEC_TAG  int >Dec 
2F  INT2HEX_TAG  int >Hex 
30  DET_TOL_TAG  tol mat det 
31  REF_TOL_TAG  tol mat ref 
32  RREF_TOL_TAG  tol mat rref 
33  SIMULT_TOL_TAG  tol vec mat simult 
34  GETCONFG_TAG  [] getConfg 
35  V_AUGMENT_TAG  mat2 ; mat1 augment 
36  MEAN_TWOARG_TAG  list list mean (AMS 2.00 or higher) 
37  PRODUCT_TWOARG_TAG  [end] start list product (AMS 2.00 or higher) 
38  STDDEV_TWOARG_TAG  list list stdDev (AMS 2.00 or higher) 
39  SUM_TWOARG_TAG  [end] start list sum (AMS 2.00 or higher) 
3A  VARIANCE_TWOARG_TAG  list list variance (AMS 2.00 or higher) 
3B  DELTA_LIST_TAG  list Dlist (AMS 2.00 or higher) 
46  ISCLKON_TAG  [] isClkOn (AMS 2.07 or higher) 
47  GETDATE_TAG  [] getDate (AMS 2.07 or higher) 
48  GETTIME_TAG  [] getTime (AMS 2.07 or higher) 
49  GETTMZN_TAG  [] getTmZn (AMS 2.07 or higher) 
4A  SETDATE_TAG  [] d mo y setDate (AMS 2.07 or higher) 
4B  SETTIME_TAG  [] s min h setTime (AMS 2.07 or higher) 
4C  SETTMZN_TAG  int setTmZn (AMS 2.07 or higher) 
4D  DAYOFWK_TAG  [] d mo y dayOfWk (AMS 2.07 or higher) 
4E  STARTTMR_TAG  [] startTmr (AMS 2.07 or higher) 
4F  CHECKTMR_TAG  seconds checkTmr (AMS 2.07 or higher) 
50  TIMECNV_TAG  seconds timeCnv (AMS 2.07 or higher) 
51  GETDTFMT_TAG  [] getDtFmt (AMS 2.07 or higher) 
52  GETTMFMT_TAG  [] getTmFmt (AMS 2.07 or higher) 
53  GETDTSTR_TAG  [int] getDtStr (AMS 2.07 or higher) 
54  GETTMSTR_TAG  [int] getTmStr (AMS 2.07 or higher) 
55  SETDTFMT_TAG  [int] setDtFmt (AMS 2.07 or higher) 
56  SETTMFMT_TAG  [int] setTmFmt (AMS 2.07 or higher) 
enum InstructionTags {...}; 
An enumeration to describe types of instructions on the expression stack.
If the tag of an entry on the expression stack is EXT_INSTR_TAG (0xE4), then the
byte below it is the tag of a TIBasic command token. Although TIBasic tokens are not interesting
for programming, they are defined in enumerated type InstructionTags, due to completeness. This
enum is quite big, and here is a complete list of TIBasic instruction token tags defined in it
(all values are in hex), with their meaning (used notation is RPN):
01  CLRDRAW_ITAG  ClrDraw 
02  CLRGRAPH_ITAG  ClrGraph 
03  CLRHOME_ITAG  ClrHome 
04  CLRIO_ITAG  ClrIO 
05  CLRTABLE_ITAG  ClrTable 
06  CUSTOM_ITAG  Custom 
07  CYCLE_ITAG  displacement Cycle (displacement towards the instruction ending the loop) 
08  DIALOG_ITAG  Dialog 
09  DISPG_ITAG  DispG 
0A  DISPTBL_ITAG  DispTbl 
0B  ELSE_ITAG  Else (in If...EndIf statement) 
0C  ENDCUSTM_ITAG  EndCustm 
0D  ENDDLOG_ITAG  EndDlog 
0E  ENDFOR_ITAG  displacement EndFor 
0F  ENDFUNC_ITAG  EndFunc 
10  ENDIF_ITAG  EndIf 
11  ENDLOOP_ITAG  displacement EndLoop 
12  ENDPRGM_ITAG  EndPrgm 
13  ENDTBAR_ITAG  EndTBar 
14  ENDTRY_ITAG  EndTry 
15  ENDWHILE_ITAG  displacement EndWhile 
16  EXIT_ITAG  displacement Exit (displacement towards the end of the loop, i.e. the instruction following the loop ending instruction) 
17  FUNC_ITAG  Func 
18  LOOP_ITAG  Loop 
19  PRGM_ITAG  Prgm 
1A  SHOWSTAT_ITAG  ShowStat 
1B  STOP_ITAG  Stop 
1C  THEN_ITAG  Then 
1D  TOOLBAR_ITAG  Toolbar 
1E  TRACE_ITAG  Trace 
1F  TRY_ITAG  Try 
20  ZOOMBOX_ITAG  ZoomBox 
21  ZOOMDATA_ITAG  ZoomData 
22  ZOOMDEC_ITAG  ZoomDec 
23  ZOOMFIT_ITAG  ZoomFit 
24  ZOOMIN_ITAG  ZoomIn 
25  ZOOMINT_ITAG  ZoomInt 
26  ZOOMOUT_ITAG  ZoomOut 
27  ZOOMPREV_ITAG  ZoomPrev 
28  ZOOMRCL_ITAG  ZoomRcl 
29  ZOOMSQR_ITAG  ZoomSqr 
2A  ZOOMSTD_ITAG  ZoomStd 
2B  ZOOMSTO_ITAG  ZoomSto 
2C  ZOOMTRIG_ITAG  ZoomTrig 
2D  DRAWFUNC_ITAG  expr DrawFunc 
2E  DRAWINV_ITAG  expr DrawInv 
2F  GOTO_ITAG  expr Goto (Expr = LABEL) 
30  LBL_ITAG  expr Lbl (Expr = LABEL) 
31  GET_ITAG  var Get 
32  SEND_ITAG  list Send 
33  GETCALC_ITAG  var GetCalc 
34  SENDCALC_ITAG  var SendCalc 
35  NEWFOLD_ITAG  foldername NewFold 
36  PRINTOBJ_ITAG  var PrintObj 
37  RCLGDB_ITAG  var RclGDB 
38  STOGDB_ITAG  var StoGDB 
39  ELSEIF_ITAG  condition ElseIf 
3A  IF_ITAG  condition If (simple variant) 
3B  IFTHEN_ITAG  condition If...Then (If condition Then) 
3C  RANDSEED_ITAG  expr RandSeed 
3D  WHILE_ITAG  condition While 
3E  LINETAN_ITAG  point expr LineTan 
3F  COPYVAR_ITAG  var2 var1 CopyVar 
40  RENAME_ITAG  newname oldname Rename 
41  STYLE_ITAG  string expr Style 
42  FILL_ITAG  var expr Fill 
43  REQUEST_ITAG  var string Request 
44  POPUP_ITAG  var itemlist PopUp 
45  PTCHG_ITAG  y x PtChg 
46  PTOFF_ITAG  y x PtOff 
47  PTON_ITAG  y x PtOn 
48  PXLCHG_ITAG  column row PxlChg 
49  PXLOFF_ITAG  column row PxlOff 
4A  PXLON_ITAG  column row PxlOn 
4B  MOVEVAR_ITAG  newfolder oldfolder var MoveVar 
4C  DROPDOWN_ITAG  var list title_string DropDown 
4D  OUTPUT_ITAG  expr column row Output 
4E  PTTEXT_ITAG  y x string PtText 
4F  PXLTEXT_ITAG  column row string PxlText 
50  DRAWSLP_ITAG  slope y x DrawSlp 
51  PAUSE_ITAG  [expr] Pause 
52  RETURN_ITAG  [expr] Return 
53  INPUT_ITAG  [var [string]] Input 
54  PLOTSOFF_ITAG  [9] ... [2] [1] PlotsOff 
55  PLOTSON_ITAG  [9] ... [2] [1] PlotsOn 
56  TITLE_ITAG  [label] string Title 
57  ITEM_ITAG  [label] string Item 
58  INPUTSTR_ITAG  var [string] InputStr 
59  LINEHORZ_ITAG  [drawmode] y LineHorz 
5A  LINEVERT_ITAG  [drawmode] x LineVert 
5B  PXLHORZ_ITAG  [drawmode] row PxlHorz 
5C  PXLVERT_ITAG  [drawmode] column PxlVert 
5D  ANDPIC_ITAG  [pxlcol pxlrow] picvar AndPic 
5E  RCLPIC_ITAG  [pxlcol pxlrow] picvar RclPic 
5F  RPLCPIC_ITAG  [pxlcol pxlrow] picvar RplcPic 
60  XORPIC_ITAG  [pxlcol pxlrow] picvar XorPic 
61  DRAWPOL_ITAG  [qstep] [qmax] [qmin] DrawPol 
62  TEXT_ITAG  [] string Text 
63  ONEVAR_ITAG  [L4] [L3] [L2] [L1] OneVar 
64  STOPIC_ITAG  [height width] [pxlcol pxlrow] var StoPic 
65  GRAPH_ITAG  [var2] [var1] [expr2] expr1 Graph 
66  TABLE_ITAG  [var] [expr2] expr1 Table 
67  NEWPIC_ITAG  [maxcol] [maxrow] picvar mat NewPic 
68  DRAWPARM_ITAG  [tstep] [tmax] [tmin] expr2 expr1 DrawParm 
69  CYCLEPIC_ITAG  [direction] [cycle] [wait] N picname_string CyclePic 
6A  CUBICREG_ITAG  [[L5 L4] [L3]] L2 L1 CubicReg 
6B  EXPREG_ITAG  [[L5 L4] [L3]] L2 L1 ExpReg 
6C  LINREG_ITAG  [[L5 L4] [L3]] L2 L1 LinReg 
6D  LNREG_ITAG  [[L5 L4] [L3]] L2 L1 LnReg 
6E  MEDMED_ITAG  [[L5 L4] [L3]] L2 L1 MedMed 
6F  POWERREG_ITAG  [[L5 L4] [L3]] L2 L1 PowerReg 
70  QUADREG_ITAG  [[L5 L4] [L3]] L2 L1 QuadReg 
71  QUARTREG_ITAG  [[L5 L4] [L3]] L2 L1 QuartReg 
72  TWOVAR_ITAG  [[L5 L4] [L3]] L2 L1 TwoVar 
73  SHADE_ITAG  [patres] [pat] [xhigh] [xlow] expr2 expr1 Shade 
74  FOR_ITAG  [step] high low var For 
75  CIRCLE_ITAG  [drawmode] r y x Circle 
76  PXLCRCL_ITAG  [drawmode] r col row PxlCrcl 
77  NEWPLOT_ITAG  [bucket] [mark] [inc] [cat] [frq] [ylist] xlist type N NewPlot 
78  LINE_ITAG  [drawmode] yend xend ystart xstart Line 
79  PXLLINE_ITAG  [drawmode] colend rowend colstart rowstart PxlLine 
7A  DISP_ITAG  [[...] expr1] Disp 
7B  FNOFF_ITAG  [99] ... [2] [1] FnOff 
7C  FNON_ITAG  [99] ... [2] [1] FnOn 
7D  LOCAL_ITAG  [...] var1 Local 
7E  DELFOLD_ITAG  [...] var1 DelFold 
7F  DELVAR_ITAG  [...] var1 DelVar 
80  LOCK_ITAG  [...] var1 Lock 
81  PROMPT_ITAG  [...] var1 Prompt 
82  SORTA_ITAG  [...] list1 SortA 
83  SORTD_ITAG  [...] list1 SortD 
84  UNLOCK_ITAG  [...] var1 UnLock 
85  NEWDATA_ITAG  [...] list1 datavar NewData 
86  DEFINE_ITAG  expr varuserfunc Define 
87  ELSE_TRY_ITAG  Else (in Try...EndTry statement) 
88  CLRERR_ITAG  ClrErr 
89  PASSERR_ITAG  PassErr 
8A  DISPHOME_ITAG  DispHome 
8B  EXEC_ITAG  [[...] expr] string Exec 
8C  ARCHIVE_ITAG  [...] var1 Archive 
8D  UNARCHIV_ITAG  [...] var1 Unarchiv 
8E  LU_ITAG  [tol] pvar uvar lvar mat LU 
8F  QR_ITAG  [tol] rvar qvar mat QR 
90  BLDDATA_ITAG  varsysdata BldData 
91  DRWCTOUR_ITAG  expr DrwCtour 
92  NEWPROB_ITAG  NewProb 
93  SINREG_ITAG  [[L4 L3] [period] [iter]] L2 L1 SinReg 
94  LOGISTIC_ITAG  [[L4 L3] [period] [iter]] L2 L1 Logistic 
95  CUSTMON_ITAG  CustmOn 
96  CUSTMOFF_ITAG  CustmOff 
97  SENDCHAT_ITAG  var SendChat 
99  REQUEST_THREEARG_ITAG  [] alphalock var string Request (AMS 2.07 or higher) 
9A  CLOCKON_ITAG  ClockOn (AMS 2.07 or higher) 
9B  CLOCKOFF_ITAG  ClockOff (AMS 2.07 or higher) 
typedef struct {

Describes a multiexpression, which is processed as a separate expression stack.
MULTI_EXPR is a structure describing a multiexpression. It can be applied to the
contents of every VAT symbol, because all symbols contain size bytes at the
beginning. It can also be used to describe a multiexpression passed to
Parse2DMultiExpr, or used by the FIFO
elements in homescr.h.
The Size field contains the size of the data in Expr, in bytes
(but note that ESQ is one byte large). For real
multiexpressions, Expr should start with
ENDSTACK_TAG, followed by the actual expressions.
These expressions are processed from the end to the beginning, as usual
(using the Size field to find the end). So the last quantum needs to
be a tag from the Tags enum.
Multiple expressions are separated with
NEXTEXPR_TAG, or with
NEWLINE_TAG (only in TIBasic programs and
functions).
If you have a handle to a MULTI_EXPR structure, you can use the
HToESI function to get a pointer to the last
quantum (i.e. the tag).
See also: top_estack, HToESI, Parse2DMultiExpr, homescr.h
#define Quantum ESQ 
Represents a quantum within an expression.
Quantum is a synonym for ESQ.
typedef CESI SYM_STR; 
Represents a pointer to the terminating zero byte of a string.
The type SYM_STR is in fact the same as CESI. It represents a string created with the SYMSTR macro. This type of string is usually used in expressions on the expression stack, or in functions from vat.h or bascmd.h.
enum SysvarTags {...}; 
An enumeration to describe types of system variable entries on the expression stack.
If the tag of an entry on the expression stack is EXT_SYSTEM_TAG (0x1C), then the
byte below it is the tag of a TIBasic system variable. SysvarTags is enumerated type for describing
such extended entries (see top_estack for more info about how entries
on the expression stack are organized). This enum is quite big, and here is a complete list of
system variables tags defined in it (all values are in hex), with their meaning:
enum Tags {...}; 
An enumeration to describe types of entries on the expression stack.
This enum is very large, as there are a lot of various entries.
See top_estack for more info about how entries on the
expression stack are organized.
Here is a complete list of tags with their values in hexadecimal notation, along with their meaning written in RPN:
00  VAR_NAME_TAG  variable name (with more than one letter): '\0' var_name '\0' 
01  _VAR_Q_TAG  variable q (but not used  1B is used normally) 
02  VAR_R_TAG  variable r 
03  VAR_S_TAG  variable s 
04  VAR_T_TAG  variable t 
05  VAR_U_TAG  variable u 
06  VAR_V_TAG  variable v 
07  VAR_W_TAG  variable w 
08  VAR_X_TAG  variable x 
09  VAR_Y_TAG  variable y 
0A  VAR_Z_TAG  variable z 
0B  VAR_A_TAG  variable a 
0C  VAR_B_TAG  variable b 
0D  VAR_C_TAG  variable c 
0E  VAR_D_TAG  variable d 
0F  VAR_E_TAG  variable e 
10  VAR_F_TAG  variable f 
11  VAR_G_TAG  variable g 
12  VAR_H_TAG  variable h 
13  VAR_I_TAG  variable i 
14  VAR_J_TAG  variable j 
15  VAR_K_TAG  variable k 
16  VAR_L_TAG  variable l 
17  VAR_M_TAG  variable m 
18  VAR_N_TAG  variable n 
19  VAR_O_TAG  variable o 
1A  VAR_P_TAG  variable p 
1B  VAR_Q_TAG  variable q 
1C  EXT_SYSTEM_TAG  system token (a byte before the tag identifies a system variable, see SysvarTags) 
1D  ARB_REAL_TAG  arbitrary real number @xxx (byte before the tag determines xxx) 
1E  ARB_INT_TAG  arbitrary integer number @nxxx (byte before the tag determines xxx) 
1F  POSINT_TAG  positive integer tag 
20  NEGINT_TAG  negative integer tag 
21  POSFRAC_TAG  positive fraction tag 
22  NEGFRAC_TAG  negative fraction tag 
23  FLOAT_TAG  floating point tag 
23  BCD_TAG  floating point tag (alias tag name) 
24  PI_TAG  constant p 
25  EXP_TAG  constant e 
26  IM_TAG  constant i 
27  NEGINFINITY_TAG  ¥ 
28  INFINITY_TAG  ¥ 
29  PN_INFINITY_TAG  +/ ¥ 
2A  UNDEF_TAG  undef 
2B  FALSE_TAG  false 
2C  TRUE_TAG  true 
2D  STR_TAG  string tag: '\0' string '\0' STR_TAG 
2E  NOTHING_TAG  allows missing terms in expressions 
2F  ACOSH_TAG  expr acosh 
30  ASINH_TAG  expr asinh 
31  ATANH_TAG  expr atanh 
32  ASECH_TAG  expr asech (AMS 2.08 or higher) 
33  ACSCH_TAG  expr acsch (AMS 2.08 or higher) 
34  ACOTH_TAG  expr acoth (AMS 2.08 or higher) 
35  COSH_TAG  expr cosh 
36  SINH_TAG  expr sinh 
37  TANH_TAG  expr tanh 
38  SECH_TAG  expr sech (AMS 2.08 or higher) 
39  CSCH_TAG  expr csch (AMS 2.08 or higher) 
3A  COTH_TAG  expr coth (AMS 2.08 or higher) 
3B  ACOS_TAG  expr acos 
3C  ASIN_TAG  expr asin 
3D  ATAN_TAG  expr atan 
3E  ASEC_TAG  expr asec (AMS 2.08 or higher) 
3F  ACSC_TAG  expr acsc (AMS 2.08 or higher) 
40  ACOT_TAG  expr acot (AMS 2.08 or higher) 
41  RACOS_TAG  expr arcos (used only internally) 
42  RASIN_TAG  expr arsin (used only internally) 
43  RATAN_TAG  expr artan (used only internally) 
44  COS_TAG  expr cos 
45  SIN_TAG  expr sin 
46  TAN_TAG  expr tan 
47  SEC_TAG  expr sec (AMS 2.08 or higher) 
48  CSC_TAG  expr csc (AMS 2.08 or higher) 
49  COT_TAG  expr cot (AMS 2.08 or higher) 
4A  ITAN_TAG  expr tan (used only internally) 
4B  ABS_TAG  expr abs 
4C  ANGLE_TAG  expr angle 
4D  CEILING_TAG  expr ceiling 
4E  FLOOR_TAG  expr floor 
4F  INT_TAG  expr int 
50  SIGN_TAG  expr sign 
51  SQRT_TAG  expr Ö 
52  EXPF_TAG  expr e^ 
53  LN_TAG  expr ln 
54  LOG_TAG  expr log 
55  FPART_TAG  expr fPart 
56  IPART_TAG  expr iPart 
57  CONJ_TAG  expr conj 
58  IMAG_TAG  expr imag 
59  REAL_TAG  expr real 
5A  APPROX_TAG  expr approx 
5B  TEXPAND_TAG  expr tExpand 
5C  TCOLLECT_TAG  expr tCollect 
5D  GETDENOM_TAG  expr getDenom 
5E  GETNUM_TAG  expr getNum 
5F  ERROR_TAG  expr _ERROR_ (used only internally) 
60  CUMSUM_TAG  list cumSum 
61  DET_TAG  mat det 
62  COLNORM_TAG  mat colNorm 
63  ROWNORM_TAG  mat rowNorm 
64  NORM_TAG  mat norm 
65  MEAN_TAG  list mean 
66  MEDIAN_TAG  list median 
67  PRODUCT_TAG  list product 
68  STDDEV_TAG  list stdDev 
69  SUM_TAG  list sum 
6A  VARIANCE_TAG  list variance 
6B  UNITV_TAG  vec unitV 
6C  DIM_TAG  mat dim 
6D  MAT2LIST_TAG  mat mat>list 
6E  NEWLIST_TAG  no_of_elements newList 
6F  RREF_TAG  mat rref 
70  REF_TAG  mat ref 
71  IDENTITY_TAG  integer identity 
72  DIAG_TAG  mat diag 
73  COLDIM_TAG  mat colDim 
74  ROWDIM_TAG  mat rowDim 
75  TRANSPOSE_TAG  mat ^{T} 
76  FACTORIAL_TAG  expr ! 
77  PERCENT_TAG  expr % 
78  RADIANS_TAG  expr ^{r} 
79  NOT_TAG  expr not 
7A  MINUS_TAG  expr _negative_ 
7B  VEC_POLAR_TAG  mat _polar_vector_ (mat is assumed to be [[r,q]]) 
7C  VEC_CYLIND_TAG  mat _cylind_vector_ (mat is assumed to be [[r,q,z]]) 
7D  VEC_SPHERE_TAG  mat _sphere_vector_ (mat is assumed to be [[r,q,F]]) 
7E  START_TAG  ( (used only internally, don't use it) 
7F  ISTORE_TAG  expr var > (internal version: don't use) 
80  STORE_TAG  expr var > 
81  WITH_TAG  condition expr  
82  XOR_TAG  expr2 expr1 xor 
83  OR_TAG  expr2 expr1 or 
84  AND_TAG  expr2 expr1 and 
85  LT_TAG  expr2 expr1 < 
86  LE_TAG  expr2 expr1 <= 
87  EQ_TAG  expr2 expr1 = 
88  GE_TAG  expr2 expr1 >= 
89  GT_TAG  expr2 expr1 > 
8A  NE_TAG  expr2 expr1 /= 
8B  ADD_TAG  expr1 expr2 + 
8C  ADDELT_TAG  expr1 expr2 .+ 
8D  SUB_TAG  expr1 expr2  
8E  SUBELT_TAG  expr1 expr2 . 
8F  MUL_TAG  expr1 expr2 * 
90  MULELT_TAG  expr1 expr2 .* 
91  DIV_TAG  expr1 expr2 / 
92  DIVELT_TAG  expr1 expr2 ./ 
93  POW_TAG  expr2 expr1 ^ 
94  POWELT_TAG  expr2 expr1 .^ 
95  SINCOS_TAG  int expr trig (where trig(expr,int)=cos(expr+(int1)*pi/2)) 
96  SOLVE_TAG  var equation solve 
97  CSOLVE_TAG  var equation cSolve 
98  NSOLVE_TAG  var equation nSolve 
99  ZEROS_TAG  var expr_in_var zeros 
9A  CZEROS_TAG  var expr_in_var cZeros 
9B  FMIN_TAG  var expr_in_var fMin 
9C  FMAX_TAG  var expr_in_var fMax 
9D  COMPLEX_TAG  complex number 
9E  POLYEVAL_TAG  expr list polyEval 
9F  RANDPOLY_TAG  order var randPoly 
A0  CROSSP_TAG  vec2 vec1 crossP 
A1  DOTP_TAG  vec2 vec1 dotP 
A2  GCD_TAG  expr2 expr1 gcd 
A3  LCM_TAG  expr2 expr1 lcm 
A4  MOD_TAG  expr2 expr1 mod 
A5  INTDIV_TAG  expr2 expr1 intDiv 
A6  REMAIN_TAG  expr2 expr1 remain 
A7  NCR_TAG  expr2 expr1 nCr 
A8  NPR_TAG  expr2 expr1 nPr 
A9  P2RX_TAG  q_expr r_expr P>Rx 
AA  P2RY_TAG  q_expr r_expr P>Ry 
AB  P2PTHETA_TAG  y_expr x_expr R>Pq 
AC  P2PR_TAG  y_expr x_expr R>Pr 
AD  AUGMENT_TAG  mat2 mat1 augment 
AE  NEWMAT_TAG  num_columns num_rows newMat 
AF  RANDMAT_TAG  num_columns num_rows randMat 
B0  SIMULT_TAG  vec mat simult 
B1  PART_TAG  [#] expr part 
B2  EXP2LIST_TAG  var list exp>list 
B3  RANDNORM_TAG  sd mean randNorm 
B4  MROW_TAG  [] index mat expr mRow 
B5  ROWADD_TAG  [] index2 index1 mat rowAdd 
B6  ROWSWAP_TAG  [] index2 index1 mat rowSwap 
B7  ARCLEN_TAG  [] end start var expr arcLen 
B8  NINT_TAG  [] up low var expr nInt 
B9  PI_PRODUCT_TAG  [] high low var expr Õ 
BA  SIGMA_SUM_TAG  [] high low var expr å 
BB  MROWADD_TAG  [] index2 index1 mat expr mRowAdd 
BC  ANS_TAG  [int] ans 
BD  ENTRY_TAG  [int] entry 
BE  EXACT_TAG  [tol] expr exact 
BF  LOGB_TAG  expr2 expr1 logb (where logb(expr1,expr2)=ln(expr1)/ln(expr2)) 
C0  COMDENOM_TAG  [var] expr comDenom 
C1  EXPAND_TAG  [var] expr expand 
C2  FACTOR_TAG  [var] expr factor 
C3  CFACTOR_TAG  [var] expr cFactor 
C4  INTEGRATE_TAG  [up low] var expr ò 
C5  DIFFERENTIATE_TAG  [order] var expr ¶ 
C6  AVGRC_TAG  [h] var expr avgRC 
C7  NDERIV_TAG  [h] var expr nDeriv 
C8  TAYLOR_TAG  [point] order var expr taylor 
C9  LIMIT_TAG  [direction] point var expr limit 
CA  PROPFRAC_TAG  [var] expr propFrac 
CB  WHEN_TAG  [[undef_val] false_val] true_val condition when 
CC  ROUND_TAG  [digits] expr round 
CD  DMS_TAG  [[ss] mm] dd _DMSNUMBER_ 
CE  LEFT_TAG  [num] string left 
CF  RIGHT_TAG  [num] string right 
D0  MID_TAG  [count] start string mid 
D1  SHIFT_TAG  [int] list shift 
D2  SEQ_TAG  [step] high low var expr seq 
D3  LIST2MAT_TAG  [elements_per_row] list list>mat 
D4  SUBMAT_TAG  [[[[col2] row2] col1] row1] mat subMat 
D5  SUBSCRIPT_TAG  [col] row var _subscript_ (i.e. var[row] or var[row,col]) 
D6  RAND_TAG  [int] rand 
D7  MIN_TAG  [expr2] listexpr1 min 
D8  MAX_TAG  [expr2] listexpr1 max 
D9  LIST_TAG  list tag, or matrix represented as "list of list" 
DA  USERFUNC_TAG  user defined function/program call: [[...] arg1] '\0' fnc_name '\0' USERFUNC_TAG 
DB  MATRIX_TAG  matrix tag (only in data editor) 
DC  FUNC_TAG  program/function tag (not used in expressions) 
DD  DATA_TAG  data tag (not used in expressions) 
DE  GDB_TAG  GDB tag (not used in expressions) 
DF  PIC_TAG  picture tag (not used in expressions) 
E0  TEXT_TAG  text tag (not used in expressions) 
E1  FIG_TAG  figure tag (not used in expressions) 
E2  MAC_TAG  macro tag (not used in expressions) 
E3  EXT_TAG  extra TIBasic function token (see ExtTags) 
E4  EXT_INSTR_TAG  TIBasic command token (not used in expressions, see InstructionTags) 
E5  END_TAG  end of the expression or the list 
E6  COMMENT_TAG  comment (not used in expressions): '\0' string '\0' indentation COMMENT_TAG, where indentation is a single byte indicating the number of spaces between © and the first comment character 
E7  NEXTEXPR_TAG  ":" between tokens on same line in the program (not used in expressions): indentation NEXTEXPR_TAG, where indentation is a single byte indicating the number of spaces between : and the first character of the next logical line 
E8  NEWLINE_TAG  marks end of line in TIBasic (not used in expressions): indentation NEWLINE_TAG, where indentation is a single byte indicating the number of spaces in front of the first character of the next line 
E9  ENDSTACK_TAG  end of TIBasic program (not used in expressions), or end of the expression stack 
EA  PN1_TAG  expr +/ 
EB  PN2_TAG  expr1 expr2 +/ 
EC  ERROR_MSG_TAG  name error_message 
ED  EIGVC_TAG  mat eigVc 
EE  EIGVL_TAG  mat eigVl 
EF  DASH_TAG  expr ' (prime, i.e. expr') 
F0  LOCALVAR_TAG  var _local_ (parameter/local variable reference) 
F1  DESOLVE_TAG  [] depend_var indep_var equation deSolve 
F2  FDASH_TAG  func_params func_name ' (prime, i.e. func_name'(func_params) 
F3  ASM_TAG  ASM program tag (not used in expressions) 
F4  ISPRIME_TAG  int isPrime 
F8  OTH_TAG  Other file tag, for custom file types (not used in expressions) 
F9  ROTATE_TAG  [count] listintstring rotate 
enum TokenizeSymNameFlags {TSF_FULLY_QUALIFIED = 0x01, TSF_ALLOW_RESERVED = 0x02, TSF_PASS_ERRORS = 0x04}; 
Contains flags specifying how a symbol name is tokenized.
TokenizeSymNameFlags is an enumeration containing flags used by TokenizeSymName.