-
Notifications
You must be signed in to change notification settings - Fork 16
/
estack.html
3969 lines (3516 loc) · 336 KB
/
estack.html
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<HTML>
<HEAD>
<TITLE>estack.h</TITLE>
<STYLE TYPE="TEXT/CSS">
<!--
.IE3-DUMMY { CONT-SIZE: 100%; }
BODY { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; BACKGROUND-COLOR: #E0E0E0; }
P { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H1 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H2 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H3 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H4 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H5 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
H6 { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
UL { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; }
TD { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; BACKGROUND-COLOR: #FFFFFF; }
.NOBORDER { BACKGROUND-COLOR: #E0E0E0; PADDING: 0pt; }
.NOBORDER TD { FONT-FAMILY: Verdana,Arial,Helvetica,Sans-Serif; BACKGROUND-COLOR: #E0E0E0; PADDING: 0pt; }
.CODE { FONT-FAMILY: Courier New; }
-->
</STYLE>
</HEAD>
<BODY TEXT="#000000" BGCOLOR="#E0E0E0">
<FONT SIZE="5"><B>The <estack.h> Header File</B></FONT>
<HR>
<P><B>Routines for symbolic manipulation and expression handling</B></P>
<H3><U>Functions</U></H3>
<DL INDENT="20"><DT><B><A HREF="#add_to_top">add_to_top</A></B><DD>Adds a value to the expression on the top of the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#add1_to_top">add1_to_top</A></B><DD>Adds 1 to the top of the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#all_tail">all_tail</A></B><DD>Checks whether all elements in the list have some property.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#and_onto_top">and_onto_top</A></B><DD>Logical ANDs an expression onto the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#any_tail">any_tail</A></B><DD>Checks whether any element in the list has some property.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#are_expressions_identical">are_expressions_identical</A></B><DD>Checks whether two expressions are identical.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#can_be_approxed">can_be_approxed</A></B><DD>Checks whether an expression can be approximated to a number.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#check_estack_size">check_estack_size</A></B><DD>Checks if there is enough room on the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#compare_complex_magnitudes">compare_complex_magnitudes</A></B><DD>Compares magnitudes of two complex number entries on the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#compare_expressions">compare_expressions</A></B><DD>Compares two expressions.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#compare_Floats">compare_Floats</A></B><DD>Compares two floating point entries on the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#CreateEmptyList">CreateEmptyList</A></B><DD>Creates a MULTI_EXPR containing an empty list and returns its handle.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#delete_between">delete_between</A></B><DD>Deletes a sequence of bytes from the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#delete_expression">delete_expression</A></B><DD>Deletes an expression from the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#deleted_between">deleted_between</A></B><DD>Deletes a sequence of bytes from the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#deleted_expression">deleted_expression</A></B><DD>Deletes an expression from the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#did_push_cnvrt_Float_to_integer">did_push_cnvrt_Float_to_integer</A></B><DD>Pushes a floating point entry converted to an integer, but only if it is an exact whole number.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#display_statements">display_statements</A></B><DD>Converts tokenized expressions or TI-Basic statements to the printable form.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#divide_top">divide_top</A></B><DD>Divides the expression onto the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#estack_number_to_Float">estack_number_to_Float</A></B><DD>Converts entry on the expression stack to floating point number.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#estack_to_short">estack_to_short</A></B><DD>Converts entry on the expression stack to signed short integer.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#estack_to_ushort">estack_to_ushort</A></B><DD>Converts entry on the expression stack to unsigned short integer.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#ESTACK">ESTACK</A></B><DD>Reads the expression stack at a specific index.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#factor_base_index">factor_base_index</A></B><DD>Gets the index of the base of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#factor_exponent_index">factor_exponent_index</A></B><DD>Gets the index of the exponent of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#gcd_exact_whole_Floats">gcd_exact_whole_Floats</A></B><DD>Finds the greatest common divisor of two floating point entries.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#get_key_ptr">get_key_ptr</A></B><DD>Converts a tag code to a tag name.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#GetValue">GetValue</A></B><DD>Converts entry on the expression stack to short integer and checks whether it is in a given range.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="homescr.html#HS_popEStack">HS_popEStack</A></B><DD>Pops the entire expression stack into memory.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#HToESI">HToESI</A></B><DD>Converts a handle to an expression stack index.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#im_index">im_index</A></B><DD>Gets the index of the imaginary part of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#index_below_display_expression_aux">index_below_display_expression_aux</A></B><DD>Main routine for detokenizing.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#index_main_var">index_main_var</A></B><DD>Searches an expression for a first encountered variable.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#index_numeric_term">index_numeric_term</A></B><DD>Searches terms in the expression for a numeric term.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#index_of_lead_base_of_lead_term">index_of_lead_base_of_lead_term</A></B><DD>Gets the index of the base of the lead term of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#init_list_indices">init_list_indices</A></B><DD>Computes and stores the indices of the elements of a list.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#init_matrix_indices">init_matrix_indices</A></B><DD>Computes and stores the indices of the elements of a matrix.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#integer_non_unknown">integer_non_unknown</A></B><DD>Tests if an expression is an integer.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is0">is0</A></B><DD>Tests if an expression is equal to 0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is1">is1</A></B><DD>Tests if an expression is equal to 1.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_advanced_tag">is_advanced_tag</A></B><DD>Checks whether a tag is an advanced tag.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_antisymmetric">is_antisymmetric</A></B><DD>Checks for a antisymmetry.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_complex0">is_complex0</A></B><DD>Checks whether an expression is reducible to zero.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_complex_number">is_complex_number</A></B><DD>Checks whether an expression is a number.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_constant">is_constant</A></B><DD>Checks whether an expression is constant.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_Float_exact_whole_number">is_Float_exact_whole_number</A></B><DD>Checks whether a floating point entry is an exact whole number.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_free_of_tag">is_free_of_tag</A></B><DD>Checks whether an expression is free of a particular tag.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_independent_of_de_seq_vars">is_independent_of_de_seq_vars</A></B><DD>Checks whether an expression is independent of differential equation and sequence variables.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_independent_of_elements">is_independent_of_elements</A></B><DD>Checks whether an expression is independent of the elements of a list.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_independent_of_tail">is_independent_of_tail</A></B><DD>Checks whether an expression is independent of a sequence of variables (or expressions).<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_independent_of">is_independent_of</A></B><DD>Checks whether an expression is independent of a variable (or expression).<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_matrix">is_matrix</A></B><DD>Checks whether an expression is a matrix.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_minus1">is_minus1</A></B><DD>Tests if an expression is equal to -1.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_monomial_in_kernel">is_monomial_in_kernel</A></B><DD>Checks whether an expression is a monomial in kernel.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_monomial">is_monomial</A></B><DD>Checks whether an expression is a monomial.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_narrowly_independent_of">is_narrowly_independent_of</A></B><DD>Checks whether an expression is narrowly independent of a variable (???).<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_negative">is_negative</A></B><DD>Tests if an expression is less than 0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_never0">is_never0</A></B><DD>Tests if an expression is never 0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_nonnegative">is_nonnegative</A></B><DD>Tests if an expression is >= 0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_nonpositive">is_nonpositive</A></B><DD>Tests if an expression is <= 0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_polynomial_in_var_or_kern">is_polynomial_in_var_or_kern</A></B><DD>Checks if an expression is a polynomial with respect to another expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_pos_int_and_eq_quantum">is_pos_int_and_eq_quantum</A></B><DD>Determines whether <I>expr</I> points to the tag of a positive integer equal to <I>num</I>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_positive">is_positive</A></B><DD>Tests if an expression is greater than 0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_reciprocal_of_quantum">is_reciprocal_of_quantum</A></B><DD>Determines whether <I>expr</I> points to the tag of the reciprocal of <CODE>ESQ</CODE> <I>num</I>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_square_matrix">is_square_matrix</A></B><DD>Checks whether an expression is a square matrix.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_symmetric">is_symmetric</A></B><DD>Checks for symmetry.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_tail_independent_of">is_tail_independent_of</A></B><DD>Checks whether a sequence of expressions is independent of a variable (or expression).<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_temperature_unit">is_temperature_unit</A></B><DD>Checks for strings of temperature units.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_totally_polynomial">is_totally_polynomial</A></B><DD>Checks if an expression is polynomial in all variables.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_valid_smap_aggregate">is_valid_smap_aggregate</A></B><DD>Checks whether an expression is a valid aggregate type.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_variable">is_variable</A></B><DD>Checks if the expression is a variable.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#is_whole_number">is_whole_number</A></B><DD>Tests if an expression is a whole number.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#last_element_index">last_element_index</A></B><DD>Searches for the last expression in the list.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#lead_base_index">lead_base_index</A></B><DD>Gets the index of the base of the lead factor of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#lead_exponent_index">lead_exponent_index</A></B><DD>Gets the index of the exponent of the lead factor of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#lead_factor_index">lead_factor_index</A></B><DD>Gets the index of the lead factor of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#lead_term_index">lead_term_index</A></B><DD>Gets the index of the lead term of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#likely_approx_to_complex_number">likely_approx_to_complex_number</A></B><DD>Checks if it is likely that an expression can be approxed to a complex number.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#likely_approx_to_number">likely_approx_to_number</A></B><DD>Checks is it likely that an expression can be approxed to a real number.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#main_gen_var_index">main_gen_var_index</A></B><DD>Searches an expression for a generalized variable.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#map_tail_Int">map_tail_Int</A></B><DD>Applies an extended function to all elements in the list.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#map_tail">map_tail</A></B><DD>Applies a function to all elements in the list.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#map_unary_over_comparison">map_unary_over_comparison</A></B><DD>Calls callback function for both comparison terms and pushes the comparison tag.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#min_quantum">min_quantum</A></B><DD>Finds smaller of two tags.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#move_between_to_top">move_between_to_top</A></B><DD>Moves a sequence of bytes to the top of the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#moved_between_to_top">moved_between_to_top</A></B><DD>Moves a sequence of bytes to the top of the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#negate_top">negate_top</A></B><DD>Negates the top of the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#next_expression_index">next_expression_index</A></B><DD>Finds the next entry on the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#NG_approxESI">NG_approxESI</A></B><DD>Evaluates an expression in "APPROX" mode.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#NG_execute">NG_execute</A></B><DD>Executes TI-Basic statements.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#NG_graphESI">NG_graphESI</A></B><DD>Evaluates an expressions for graphing purposes.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#NG_rationalESI">NG_rationalESI</A></B><DD>Evaluates an expression in "EXACT" mode.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#NG_RPNToText">NG_RPNToText</A></B><DD>Detokenizes a tokenized structure associated with a handle.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#NG_tokenize">NG_tokenize</A></B><DD>Tokenizes text associated with a handle and pushes them to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#norm1_complex_Float">norm1_complex_Float</A></B><DD>Finds the 1-norm of a complex number entry.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#numeric_factor_index">numeric_factor_index</A></B><DD>Searches factors in the expression for a numeric factor.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#or_onto_top">or_onto_top</A></B><DD>Logical ORs an expression onto the estack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Parms2D">Parms2D</A></B><DD>Gets information about dimensions of block which will be "pretty printed".<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Parse1DExpr">Parse1DExpr</A></B><DD>Parses a tokenized expression to be printed.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Parse2DExpr">Parse2DExpr</A></B><DD>Parses a tokenized expression to be pretty printed using Print2DExpr.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Parse2DMultiExpr">Parse2DMultiExpr</A></B><DD>Parses a multi-statement expression associated with a handle to be pretty printed using Print2DExpr.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Print2DExpr">Print2DExpr</A></B><DD>Performs "pretty printing" (or "2D printing") of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push0">push0</A></B><DD>Pushes a tagged integer or a tagged float 0, depending on the mode setting.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push1">push1</A></B><DD>Pushes a tagged integer or a tagged float 1, depending on the mode setting.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_ANSI_string">push_ANSI_string</A></B><DD>Pushes a standard C string to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_between">push_between</A></B><DD>Pushes a sequence of bytes to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_cnvrt_integer_if_whole_nmb">push_cnvrt_integer_if_whole_nmb</A></B><DD>Pushes a floating point entry eventually converted to an integer.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_e">push_e</A></B><DD>Pushes <B><I>e</I></B>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_END_TAG">push_END_TAG</A></B><DD>Pushes end-of-list marker to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_exact0">push_exact0</A></B><DD>Pushes a tagged integer 0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_exact1">push_exact1</A></B><DD>Pushes a tagged integer 1.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_exact_minus1">push_exact_minus1</A></B><DD>Pushes a tagged integer -1.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_expr_quantum">push_expr_quantum</A></B><DD>Pushes an expression followed by a tag to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_expr2_quantum">push_expr2_quantum</A></B><DD>Pushes two expressions followed by a tag to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_expression">push_expression</A></B><DD>Pushes an expression to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_Float_to_nonneg_int">push_Float_to_nonneg_int</A></B><DD>Rounds a floating point value to an integer, then pushes it to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_Float_to_rat">push_Float_to_rat</A></B><DD>Pushes a rational approximation of a floating point entry.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_Float">push_Float</A></B><DD>Pushes a floating point value to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_half">push_half</A></B><DD>Pushes a tagged fraction +1/2 or a tagged float 0.5, depending on the mode setting.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_i">push_i</A></B><DD>Pushes <B><I>i</I></B>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_internal_simplify">push_internal_simplify</A></B><DD>Converts an expression into internal canonic form and pushes the result to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_LIST_TAG">push_LIST_TAG</A></B><DD>Pushes list tag to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_long_to_integer">push_long_to_integer</A></B><DD>Pushes a signed long integer to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_longint">push_longint</A></B><DD>Pushes a long integer to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_longlongint">push_longlongint</A></B><DD>Pushes a double-long integer to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_minus1">push_minus1</A></B><DD>Pushes a tagged integer or a tagged float -1, depending on the mode setting.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_minus_half">push_minus_half</A></B><DD>Pushes a tagged fraction -1/2 or a tagged float -0.5, depending on the mode setting.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_minus_recip_of_quantum">push_minus_recip_of_quantum</A></B><DD>Pushes on the EStack minus the reciprocal of the argument as a tagged negative fraction.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_negate_quantum_as_negint">push_negate_quantum_as_negint</A></B><DD>Pushes on the EStack the argument as a tagged negative integer.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_next_arb_int">push_next_arb_int</A></B><DD>Pushes a next "arbitrary integer" symbol to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_next_arb_real">push_next_arb_real</A></B><DD>Pushes a next "arbitrary real" symbol to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_next_internal_var">push_next_internal_var</A></B><DD>Pushes an internal variable to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_no_solution_found_string">push_no_solution_found_string</A></B><DD>Pushes "No solution found", or its localized version if a language localization is active (on AMS 2.xx), on the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_offset_array">push_offset_array</A></B><DD>Pushes an array of offsets to the list items.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_overflow_to_infinity">push_overflow_to_infinity</A></B><DD>Displays a warning, and pushes a tag to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_parse_text">push_parse_text</A></B><DD>Parses an expression given in a string and pushes tokenized expression to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_pi_on_quantum">push_pi_on_quantum</A></B><DD>Pushes on the EStack the quotient of PI (numerator) and of the argument (denominator), in a way depending on the mode setting.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_pi">push_pi</A></B><DD>Pushes on the EStack a tagged float PI if the mode setting is APPROX, otherwise pushes a <A HREF="#PI_TAG">PI_TAG</A>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_quantum_as_nonnegative_int">push_quantum_as_nonnegative_int</A></B><DD>Pushes on the EStack the argument as a tagged positive integer.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_quantum_pair_as_pos_frac">push_quantum_pair_as_pos_frac</A></B><DD>Pushes on the EStack the quotient of the first argument (numerator) and the second argument (denominator).<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_quantum_pair">push_quantum_pair</A></B><DD>Pushes two bytes (tags) to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_quantum">push_quantum</A></B><DD>Pushes a byte (tag) to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_reciprocal_of_quantum">push_reciprocal_of_quantum</A></B><DD>Pushes on the EStack the reciprocal of the argument as a tagged positive fraction.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_reversed_tail">push_reversed_tail</A></B><DD>Pushes elements of the list up to tail onto the stack in reversed order.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_round_Float">push_round_Float</A></B><DD>Pushes an approximation of a floating point entry.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_shortint">push_shortint</A></B><DD>Pushes a short integer to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_simplify">push_simplify</A></B><DD>Simplifies the argument and pushes onto the estack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_transpose_aux">push_transpose_aux</A></B><DD>Pushes transposed matrix to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_ulong_to_integer">push_ulong_to_integer</A></B><DD>Pushes an unsigned long integer to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_ushort_to_integer">push_ushort_to_integer</A></B><DD>Pushes an unsigned short integer to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#push_zstr">push_zstr</A></B><DD>Pushes a standard C string to the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#raise_to_top">raise_to_top</A></B><DD>Raises a value to the power given by the expression on the top of the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#re_index">re_index</A></B><DD>Gets the index of the real part of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#reductum_index">reductum_index</A></B><DD>Gets the index of remaining terms of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#remaining_element_count">remaining_element_count</A></B><DD>Returns number of elements remaining.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#remaining_factors_index">remaining_factors_index</A></B><DD>Gets the index of remaining factors of an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top_with_post_simplified">replace_top_with_post_simplified</A></B><DD>Replaces the expression on top of the EStack, in internal form, with the external (printing) form.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top_with_reciprocal">replace_top_with_reciprocal</A></B><DD>Replaces the expression on top of the EStack by its reciprocal.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top2_with_and">replace_top2_with_and</A></B><DD>Replace the two top-most expressions on the EStack by their logical AND.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top2_with_difference">replace_top2_with_difference</A></B><DD>Replace the two top-most expressions on the EStack by their difference.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top2_with_imre">replace_top2_with_imre</A></B><DD>Replace the two top-most expressions on the EStack by a complex number.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top2_with_or">replace_top2_with_or</A></B><DD>Replace the two top-most expressions on the EStack by their logical OR.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top2_with_pow">replace_top2_with_pow</A></B><DD>Replace the two top-most expressions on the EStack by a power.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top2_with_prod">replace_top2_with_prod</A></B><DD>Replace the two top-most expressions on the EStack by their product.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top2_with_ratio">replace_top2_with_ratio</A></B><DD>Replace the two top-most expressions on the EStack by their ratio.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#replace_top2_with_sum">replace_top2_with_sum</A></B><DD>Replace the two top-most expressions on the EStack by their sum.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#reset_control_flags">reset_control_flags</A></B><DD>Resets the control flags for operations with the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#reset_estack_size">reset_estack_size</A></B><DD>Reallocates the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#should_and_did_push_approx_arg2">should_and_did_push_approx_arg2</A></B><DD>Pushes a second floating point argument, if possible.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#signum_Float">signum_Float</A></B><DD>Finds the signum of a floating point entry.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#subtract_from_top">subtract_from_top</A></B><DD>Subtracts a value from the top of the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#subtract1_from_top">subtract1_from_top</A></B><DD>Subtracts 1 from the top of the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#times_top">times_top</A></B><DD>Multiplies the expression onto the EStack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#TokenizeSymName">TokenizeSymName</A></B><DD>Tokenizes a C string into a symbol name.</DL>
<H3><U>Global Variables</U></H3>
<DL INDENT="20"><DT><B><A HREF="#ARb_int_count">ARb_int_count</A></B><DD>Represents the number of times arbitrary-integer variables were already used by some calculus.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#ARb_real_count">ARb_real_count</A></B><DD>Represents the number of times arbitrary variables were already used by some calculus.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#bottom_estack">bottom_estack</A></B><DD>Points to the bottom of the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#command_tag_list">command_tag_list</A></B><DD>Array of structures containing information on <A HREF="#InstructionTags">InstructionTags</A>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#estack_max_index">estack_max_index</A></B><DD>Points to the end of the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Float0Index">Float0Index</A></B><DD>Pointer to the end tag (FLOAT_TAG) of a 14-digit tagged floating-point value 0.0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Float1Index">Float1Index</A></B><DD>Pointer to the end tag (FLOAT_TAG) of a 14-digit tagged floating-point value 1.0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#FloatExp1Index">FloatExp1Index</A></B><DD>Pointer to the end tag (FLOAT_TAG) of a 14-digit tagged floating-point value <I>e</I>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#FloatHalfIndex">FloatHalfIndex</A></B><DD>Pointer to the end tag (FLOAT_TAG) of a 14-digit tagged floating-point value 0.5.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#FloatMinus1Index">FloatMinus1Index</A></B><DD>Pointer to the end tag (FLOAT_TAG) of a 14-digit tagged floating-point value -1.0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#FloatPiIndex">FloatPiIndex</A></B><DD>Pointer to the end tag (FLOAT_TAG) of a 14-digit tagged floating-point value <I>pi</I>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#FLOATTAB">FLOATTAB</A></B><DD>A pointer to an array of more or less commonly used <U>untagged</U> floats.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#index_false">index_false</A></B><DD>Pointer on a <CODE>FALSE_TAG</CODE> (0x2B) stored in the Flash.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#index_true">index_true</A></B><DD>Pointer on a <CODE>TRUE_TAG</CODE> (0x2C) stored in the Flash.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Integer0Index">Integer0Index</A></B><DD>Pointer to the end tag (POSINT_TAG) of an integer value 0.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Integer1Index">Integer1Index</A></B><DD>Pointer to the end tag (POSINT_TAG) of an integer value 1.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Integer2Index">Integer2Index</A></B><DD>Pointer to the end tag (POSINT_TAG) of an integer value 2.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#IntegerMinus1Index">IntegerMinus1Index</A></B><DD>Pointer to the end tag (NEGINT_TAG) of an integer value -1.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#primary_tag_list">primary_tag_list</A></B><DD>Array of structures containing information on <A HREF="#Tags">Tags</A>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#secondary_tag_list">secondary_tag_list</A></B><DD>Array of structures containing information on <A HREF="#ExtTags">ExtTags</A>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#sysvar_tag_list">sysvar_tag_list</A></B><DD>Array of structures containing information on <A HREF="#SysvarTags">SysvarTags</A>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#top_estack">top_estack</A></B><DD>Points to the top of the expression stack.</DL>
<H3><U>Constants</U></H3>
<DL INDENT="20"><DT><B><A HREF="alloc.html#H_NULL">H_NULL</A></B><DD>A null-handle value.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#NULL_INDEX">NULL_INDEX</A></B><DD>Describes an empty expression stack index.</DL>
<H3><U>Predefined Types</U></H3>
<DL INDENT="20"><DT><B><A HREF="timath.html#bcd">bcd</A></B><DD>Represents the internal organization of floating point numbers
in the format recognized by the TIOS.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="alloc.html#Bool">Bool</A></B><DD>An enumeration to describe true or false values.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#CESI_Callback_t">CESI_Callback_t</A></B><DD>Represents a pointer to a CESI callback function.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#CESI">CESI</A></B><DD>Represents a pointer to a constant expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#cmd_info">cmd_info</A></B><DD>Structure containing information about AMS EStack command tags (<A HREF="#InstructionTags">InstructionTags</A>).<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#ESI_Callback_Int_t">ESI_Callback_Int_t</A></B><DD>Represents a pointer to an ESI callback function with integer extensions.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#ESI_Callback_t">ESI_Callback_t</A></B><DD>Represents a pointer to an ESI callback function.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#ESI">ESI</A></B><DD>Represents an index of a value on the TIOS expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#ESQ">ESQ</A></B><DD>Represents a quantum within an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#EStackDisplacement">EStackDisplacement</A></B><DD>Type used for representing difference of two <A HREF="#ESI">ESI</A> pointers.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#EStackIndex">EStackIndex</A></B><DD>Represents an index of a value on the TIOS expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#ExtTags">ExtTags</A></B><DD>An enumeration to describe extra types of entries on the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#FLOATTABIndexes">FLOATTABIndexes</A></B><DD>An enumeration for describing the valid indexes for <A HREF="#FLOATTAB">FLOATTAB</A>.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="alloc.html#HANDLE">HANDLE</A></B><DD>Represents a handle associated with an allocated memory block.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#InstructionTags">InstructionTags</A></B><DD>An enumeration to describe types of instructions on the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#MULTI_EXPR">MULTI_EXPR</A></B><DD>Describes a multi-expression, which is processed as a separate expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Quantum">Quantum</A></B><DD>Represents a quantum within an expression.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="graph.html#SCR_RECT">SCR_RECT</A></B><DD>A scructure for defining a rectangular area.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="graph.html#SCR_STATE">SCR_STATE</A></B><DD>A structure for saving the state of the graphics system.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#SYM_STR">SYM_STR</A></B><DD>Represents a pointer to the terminating zero byte of a string.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#sysvar_info">sysvar_info</A></B><DD>Structure containing information about AMS EStack tags (<A HREF="#SysvarTags">SysvarTags</A>).<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#SysvarTags">SysvarTags</A></B><DD>An enumeration to describe types of system variable entries on the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#tag_info">tag_info</A></B><DD>Structure containing information about AMS EStack tags (<A HREF="#Tags">Tags</A>, <A HREF="#ExtTags">ExtTags</A>).<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#Tags">Tags</A></B><DD>An enumeration to describe types of entries on the expression stack.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="timath.html#ti_float">ti_float</A></B><DD>An alias for the standard ANSI float type.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="#TokenizeSymNameFlags">TokenizeSymNameFlags</A></B><DD>Contains flags specifying how a symbol name is tokenized.<IMG WIDTH="1" HEIGHT="20" ALIGN="TOP"><DT><B><A HREF="wingraph.html#WINDOW">WINDOW</A></B><DD>The main window-describing structure.</DL>
<P>See also: <A HREF="args.html">args.h</A></P>
<HR>
<H3><A NAME="add_to_top"><U>add_to_top</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#void">void</A></B> add_to_top (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Adds a value to the expression on the top of the EStack.</B></P>
<P>add_to_top adds the expression pointed to by <I>ptr</I> 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.</P>
<P>See also: <A HREF="#subtract_from_top">subtract_from_top</A>, <A HREF="#negate_top">negate_top</A>, <A HREF="#add1_to_top">add1_to_top</A>, <A HREF="#subtract1_from_top">subtract1_from_top</A></P>
<HR>
<H3><A NAME="add1_to_top"><U>add1_to_top</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#void">void</A></B> add1_to_top (<B><A HREF="keywords.html#void">void</A></B>);</TD></TR></TABLE></P>
<P><B>Adds 1 to the top of the EStack.</B></P>
<P>add1_to_top adds 1 (or 1.0) to the value on the top of the EStack. This routine basically calls
<A HREF="#add_to_top">add_to_top</A> with "1" as the pointed-to value.</P>
<P>See also: <A HREF="#add_to_top">add_to_top</A>, <A HREF="#subtract1_from_top">subtract1_from_top</A></P>
<HR>
<H3><A NAME="all_tail"><U>all_tail</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> all_tail (<A HREF="#CESI_Callback_t">CESI_Callback_t</A> f, <A HREF="#ESI">ESI</A> start_ptr);</TD></TR></TABLE></P>
<P><B>Checks whether all elements in the list have some property.</B></P>
<P>all_tail is similar to <A HREF="#map_tail">map_tail</A>, but callback function <I>f</I> is
not void. It needs to return a Boolean value (<A HREF="alloc.html#Bool">TRUE</A> or <A HREF="alloc.html#Bool">FALSE</A>).
If <I>f</I> returns <A HREF="alloc.html#Bool">FALSE</A>, any further processing of the list tail will
be stopped, even if <A HREF="#END_TAG">END_TAG</A> is not reached yet. The result of all_tail is
the last value returned from <I>f</I>. In other words, it returns <A HREF="alloc.html#Bool">TRUE</A> if
and only if the callback function <I>f</I> returns <A HREF="alloc.html#Bool">TRUE</A> for each expression
in the tail of expressions indexed by <I>element_ptr</I>.
<BR><BR>
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:</P>
<PRE>short is_positive_integer (ESI ptr)
{
return (*ptr == POSINT_TAG);
}
</PRE>
<P>and suppose that <I>start_ptr</I> points to the first element of the list (one byte below
<A HREF="#LIST_TAG">LIST_TAG</A>). Then, you can use the following call to check whether all
elements of the lists are positive integers:</P>
<PRE>are_all_positive_integers = all_tail (is_positive_integer, <I>start_ptr</I>);
</PRE>
<HR>
<H3><A NAME="and_onto_top"><U>and_onto_top</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#void">void</A></B> and_onto_top (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Logical ANDs an expression onto the EStack.</B></P>
<P>and_onto_top replaces the top expression on the EStack with the logical AND of itself and
the expression pointed to by <I>ptr</I>.</P>
<P>See also: <A HREF="#or_onto_top">or_onto_top</A></P>
<HR>
<H3><A NAME="any_tail"><U>any_tail</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> any_tail (<A HREF="#CESI_Callback_t">CESI_Callback_t</A> f, <A HREF="#ESI">ESI</A> start_ptr);</TD></TR></TABLE></P>
<P><B>Checks whether any element in the list has some property.</B></P>
<P>any_tail is similar like <A HREF="#all_tail">all_tail</A>, except further processing of
the list will be stopped if <I>f</I> returns <A HREF="alloc.html#Bool">TRUE</A> instead
of <A HREF="alloc.html#Bool">FALSE</A>. In other words, it returns <A HREF="alloc.html#Bool">TRUE</A> if
and only if the callback function <I>f</I> returns <A HREF="alloc.html#Bool">TRUE</A> for at least
one expression in the tail of expressions indexed by <I>element_ptr</I>.
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
<A HREF="#all_tail">all_tail</A>, the following call will check whether any element of
the list is a positive integer:</P>
<PRE>is_any_positive_integer = any_tail (is_positive_integer, <I>start_ptr</I>);
</PRE>
<HR>
<H3><A NAME="are_expressions_identical"><U>are_expressions_identical</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> are_expressions_identical (<A HREF="#CESI">CESI</A> ptr1, <A HREF="#CESI">CESI</A> ptr2);</TD></TR></TABLE></P>
<P><B>Checks whether two expressions are identical.</B></P>
<P>are_expressions_identical returns <A HREF="alloc.html#Bool">TRUE</A> if expressions pointed to by
<I>ptr1</I> and <I>ptr2</I> are syntactically identical, else returns <A HREF="alloc.html#Bool">FALSE</A>.
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 <A HREF="alloc.html#Bool">TRUE</A> 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.</P>
<HR>
<H3><A NAME="can_be_approxed"><U>can_be_approxed</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> can_be_approxed (<A HREF="#CESI">CESI</A> ptr, <B><A HREF="keywords.html#short">short</A></B> Complex);</TD></TR></TABLE></P>
<P><B>Checks whether an expression can be approximated to a number.</B></P>
<P>can_be_approxed returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> can be approximated to a number (including transfinite ones) or a list of
numbers (such expression are for example
<CODE>'ln(2+sin(1))/5'</CODE>, <CODE>'1/0'</CODE> or
<CODE>'x^2+1-x*x'</CODE>), else returns <A HREF="alloc.html#Bool">FALSE</A>.
<I>Complex</I> is a Boolean parameter:
if it is <A HREF="alloc.html#Bool">TRUE</A>, complex results will be allowed, but if it
is <A HREF="alloc.html#Bool">FALSE</A>, complex results will be treated as "cannot be approxed".
<BR><BR>
<B>Note:</B> can_be_approxed performs much detailed investigation than functions
<A HREF="#likely_approx_to_number">likely_approx_to_number</A> and
<A HREF="#likely_approx_to_complex_number">likely_approx_to_complex_number</A>.</P>
<HR>
<H3><A NAME="check_estack_size"><U>check_estack_size</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#void">void</A></B> check_estack_size (<B><A HREF="keywords.html#short">unsigned</A></B> <B><A HREF="keywords.html#short">short</A></B> Size);</TD></TR></TABLE></P>
<P><B>Checks if there is enough room on the expression stack.</B></P>
<P>check_estack_size checks if there is enough room to push <I>Size</I> bytes to
the expression stack. If there is not enough space, it tries to enlarge the stack
(using <A HREF="alloc.html#HeapRealloc">HeapRealloc</A>) 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.</P>
<HR>
<H3><A NAME="compare_complex_magnitudes"><U>compare_complex_magnitudes</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> compare_complex_magnitudes (<A HREF="#CESI">CESI</A> ptr1, <A HREF="#CESI">CESI</A> ptr2);</TD></TR></TABLE></P>
<P><B>Compares magnitudes of two complex number entries on the expression stack.</B></P>
<P>compare_complex_magnitudes compares two complex number entries (which may be real also)
on the expression stack pointed to by
<I>ptr1</I> and <I>ptr2</I>, and returns a value which is</P>
<UL>
<LI><P>< 0 if the magnitude of the number pointed to by <I>ptr1</I> is less than the magnitude of the number pointed to by <I>ptr2</I></P></LI>
<LI><P>== 0 if the magnitude of the number pointed to by <I>ptr1</I> is the same as the magnitude of the number pointed to by <I>ptr2</I></P></LI>
<LI><P>> 0 if the magnitude of the number pointed to by <I>ptr1</I> is greater than the magnitude of the number pointed to by <I>ptr2</I></P></LI>
</UL>
<HR>
<H3><A NAME="compare_expressions"><U>compare_expressions</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> compare_expressions (<A HREF="#CESI">CESI</A> ptr1, <A HREF="#CESI">CESI</A> ptr2);</TD></TR></TABLE></P>
<P><B>Compares two expressions.</B></P>
<P>compare_expressions returns 0 if two expressions pointed to by <I>ptr1</I> and <I>ptr2</I>
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 non-zero value which may be positive or negative
(more precise, 1 or -1). Positive result means that the
expression pointed to by <I>ptr1</I> is "more main" that the expression pointed to by <I>ptr2</I>,
and negative result means "less main". Principally, variables are more main than symbolic constants
such as <B>pi</B>, which are more main than numbers. In expressions such
as <CODE>'expand(...,var)'</CODE> or <CODE>'Integral(...,var)'</CODE>, a variable <I>var</I>
is "most main". Otherwise, the 26 Roman one-letter 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:</P>
<UL>
<LI><P>-2.0 and -2 are equal;</P></LI>
<LI><P>-2.0 is less main than -1;</P></LI>
<LI><P><B>pi</B> is more main than 4;</P></LI>
<LI><P><CODE>x</CODE> is more main than 4;</P></LI>
<LI><P><CODE>x</CODE> is less main than <CODE>r</CODE>;</P></LI>
<LI><P><CODE>x</CODE> is more main than <CODE>ln(y)</CODE>;</P></LI>
<LI><P><CODE>x</CODE> is less main than <CODE>ln(x)</CODE>.</P></LI>
</UL>
<P><B>Note:</B> Both expressions should be in internal canonic form
(see <A HREF="#push_internal_simplify">push_internal_simplify</A>),
else this function may not work as expected.</P>
<HR>
<H3><A NAME="compare_Floats"><U>compare_Floats</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">long</A></B> compare_Floats (<A HREF="#CESI">CESI</A> ptr1, <A HREF="#CESI">CESI</A> ptr2);</TD></TR></TABLE></P>
<P><B>Compares two floating point entries on the expression stack.</B></P>
<P>compare_Floats compares two floating point entries on the expression stack pointed to by
<I>ptr1</I> and <I>ptr2</I>, and returns a value which is</P>
<UL>
<LI><P>< 0 if the number pointed to by <I>ptr1</I> is less than the number pointed to by <I>ptr2</I></P></LI>
<LI><P>== 0 if the number pointed to by <I>ptr1</I> is the same as the number pointed to by <I>ptr2</I></P></LI>
<LI><P>> 0 if the number pointed to by <I>ptr1</I> is greater than the number pointed to by <I>ptr2</I></P></LI>
</UL>
<P>So, this function is similar like <A HREF="timath.html#fcmp">fcmp</A>, except the arguments are
different (<A HREF="timath.html#fcmp">fcmp</A> uses floating point arguments, and compare_Floats
uses pointers to floating point entries on the expression stack).</P>
<HR>
<H3><A NAME="CreateEmptyList"><U>CreateEmptyList</U></A></H3>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="alloc.html#HANDLE">HANDLE</A> CreateEmptyList (<B><A HREF="keywords.html#void">void</A></B>);</TD></TR></TABLE></P>
<P><B>Creates a MULTI_EXPR containing an empty list and returns its handle.</B></P>
<P>This function throws an error if there is not enough memory to allocate the handle.</P>
<HR>
<H3><A NAME="delete_between"><U>delete_between</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#void">void</A></B> delete_between (<A HREF="#ESI">ESI</A> ptr1, <A HREF="#ESI">ESI</A> ptr2);</TD></TR></TABLE></P>
<P><B>Deletes a sequence of bytes from the expression stack.</B></P>
<P>delete_between deletes a sequence of bytes between <I>ptr1</I> and <I>ptr2</I>
(more precise, starting at <I>ptr1</I>+1 and ending at <I>ptr2</I>) from the
expression stack. It does this by moving the memory from <I>ptr2</I>+1 to
<A HREF="#top_estack">top_estack</A> downwards (using <A HREF="mem.html#memmove">memmove</A>)
and adjusting <A HREF="#top_estack">top_estack</A>. This routine assumes that
<I>ptr1</I> and <I>ptr2</I> really point to parts of the expression stack
and that <I>ptr2</I> is above <I>ptr1</I>, otherwise the result is unpredictable.</P>
<HR>
<H3><A NAME="delete_expression"><U>delete_expression</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#void">void</A></B> delete_expression (<A HREF="#ESI">ESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Deletes an expression from the expression stack.</B></P>
<P>delete_expression deletes an entry on the expression stack pointed to by
<I>ptr</I> (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
<A HREF="#next_expression_index">next_expression_index</A> and
<A HREF="#delete_between">delete_between</A>.</P>
<HR>
<H3><A NAME="deleted_between"><U>deleted_between</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">unsigned</A></B> <B><A HREF="keywords.html#short">short</A></B> deleted_between (<A HREF="#ESI">ESI</A> ptr1, <A HREF="#ESI">ESI</A> ptr2);</TD></TR></TABLE></P>
<P><B>Deletes a sequence of bytes from the expression stack.</B></P>
<P>deleted_between acts like <A HREF="#delete_between">delete_between</A>, but it also
returns a number of deleted bytes. Note that <A HREF="#delete_between">delete_between</A> calls
<A HREF="mem.html#memmove">memmove</A> for moving memory after <I>ptr2</I>, 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?</P>
<HR>
<H3><A NAME="deleted_expression"><U>deleted_expression</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">unsigned</A></B> <B><A HREF="keywords.html#short">short</A></B> deleted_expression (<A HREF="#ESI">ESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Deletes an expression from the expression stack.</B></P>
<P>deleted_expression acts like <A HREF="#delete_expression">delete_expression</A>, but it also
returns a number of deleted bytes. It calls <A HREF="#deleted_between">deleted_between</A>
instead of <A HREF="#delete_between">delete_between</A>.</P>
<HR>
<H3><A NAME="did_push_cnvrt_Float_to_integer"><U>did_push_cnvrt_Float_to_integer</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> did_push_cnvrt_Float_to_integer (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Pushes a floating point entry converted to an integer, but only if it is an exact whole number.</B></P>
<P>did_push_cnvrt_Float_to_integer is a subroutine used in
<A HREF="#push_cnvrt_integer_if_whole_nmb">push_cnvrt_integer_if_whole_nmb</A>. It assumes
that <I>ptr</I> 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 <A HREF="alloc.html#Bool">TRUE</A>, otherwise it does nothing and returns
<A HREF="alloc.html#Bool">FALSE</A>.</P>
<HR>
<H3><A NAME="display_statements"><U>display_statements</U></A></H3>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="alloc.html#HANDLE">HANDLE</A> display_statements (<A HREF="#CESI">CESI</A> ptr, <B><A HREF="keywords.html#short">unsigned</A></B> <B><A HREF="keywords.html#short">short</A></B> Newlines, <B><A HREF="keywords.html#short">unsigned</A></B> <B><A HREF="keywords.html#short">short</A></B> FullPrec);</TD></TR></TABLE></P>
<P><B>Converts tokenized expressions or TI-Basic statements to the printable form.</B></P>
<P>display_statements converts the expression (or a group of tokenized TI-Basic statements)
pointed to by <I>ptr</I> 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 <A HREF="alloc.html#H_NULL">H_NULL</A> if memory is full.
<I>Newline</I> is a Boolean flag: when it is
nonzero, all newline characters will be replaced with ':', otherwise they will remain intact.
<I>FullPrec</I> is also a Boolean flag: when it is non-zero,
all floating point values will be converted using the maximal precision (14 digits), else
current precision settings (from TI-Basic MODE dialog) will be used. Here is an illustrative
example for usage of this command (take a look at the "Integrate" example as well):</P>
<PRE>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);
</PRE>
<P>See <A HREF="#push_parse_text">push_parse_text</A>, <A HREF="#NG_rationalESI">NG_rationalESI</A>,
<A HREF="alloc.html#HeapDeref">HeapDeref</A> and <A HREF="alloc.html#HeapFree">HeapFree</A>
to understand how this example works.
<BR><BR>
<B>Note:</B> Handles returned by <I>display_statements</I> aren't locked so any heap
compression will move the block associated with the handle. Therefore it is safer
to lock them using <A HREF="alloc.html#HLock">HLock</A> and
<A HREF="alloc.html#HeapUnlock">HeapUnlock</A> than to just dereference them
using <A HREF="alloc.html#HeapDeref">HeapDeref</A>.
<BR><BR>
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.
<BR><BR>
<B>Note:</B> Although display_statements is very similar to <A HREF="#Parse1DExpr">Parse1DExpr</A>
and both of them may usually be used for the same purposes, display_statements is used in TIOS for
printing TI-Basic statements (from programs) and for the detokenization (in <A HREF="#NG_RPNToText">NG_RPNToText</A>),
and <A HREF="#Parse1DExpr">Parse1DExpr</A> is used for printing expressions.</P>
<HR>
<H3><A NAME="divide_top"><U>divide_top</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#void">void</A></B> divide_top (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Divides the expression onto the EStack.</B></P>
<P>divide_top divides the expression currently at the top of the EStack by
the expression pointed to by <I>ptr</I>, and stores the result to the top of
the EStack, in place of the expression that was divided by.</P>
<P>See also: <A HREF="#times_top">times_top</A></P>
<HR>
<H3><A NAME="estack_number_to_Float"><U>estack_number_to_Float</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#float">float</A></B> estack_number_to_Float (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Converts entry on the expression stack to floating point number.</B></P>
<P>estack_number_to_Float converts an entry on the expression stack pointed to by
<I>ptr</I> (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
<A HREF="#FLOAT_TAG">FLOAT_TAG</A>: it also may be represented by an integer, or
by a fraction. This function does not remove the entry from the stack.
<BR><BR>
<B>Note:</B> 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
<A HREF="error.html#ER_catch">ER_catch</A> to catch eventual errors.</P>
<HR>
<H3><A NAME="estack_to_short"><U>estack_to_short</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> estack_to_short (<A HREF="#CESI">CESI</A> ptr, <B><A HREF="keywords.html#short">short</A></B> *value_ptr);</TD></TR></TABLE></P>
<P><B>Converts entry on the expression stack to signed short integer.</B></P>
<P>estack_to_short converts an entry on the expression stack pointed to by
<I>ptr</I> (it needs to point to the entry tag) to a signed short integer
and stores the result in the location pointed to by <I>value_ptr</I>.
Note that the entry need not be represented by <A HREF="#POSINT_TAG">POSINT_TAG</A>
or <A HREF="#NEGINT_TAG">NEGINT_TAG</A>: it also may be represented by
<A HREF="#FLOAT_TAG">FLOAT_TAG</A> for example, but the value itself needs to be a whole
number. This function does not remove the entry from the stack.
<BR><BR>
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 cannot be represented as a whole number (in
this case the result is undefined).</P>
<HR>
<H3><A NAME="estack_to_ushort"><U>estack_to_ushort</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> estack_to_ushort (<A HREF="#CESI">CESI</A> ptr, <B><A HREF="keywords.html#short">unsigned</A></B> <B><A HREF="keywords.html#short">short</A></B> *value_ptr);</TD></TR></TABLE></P>
<P><B>Converts entry on the expression stack to unsigned short integer.</B></P>
<P>estack_to_ushort converts an entry on the expression stack pointed to by
<I>ptr</I> (it needs to point to the entry tag) to a unsigned short integer
and stores the result in the location pointed to by <I>value_ptr</I>.
Note that the entry need not be represented by <A HREF="#POSINT_TAG">POSINT_TAG</A>
or <A HREF="#NEGINT_TAG">NEGINT_TAG</A>: it also may be represented by
<A HREF="#FLOAT_TAG">FLOAT_TAG</A> for example, but the value itself needs to be a whole
number. This function does not remove the entry from the stack.
<BR><BR>
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 cannot be represented as a whole number (in this case
the result is undefined).</P>
<HR>
<H3><A NAME="ESTACK"><U>ESTACK</U></A></H3>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="cpp.html#SEC10">#define</A></B> ESTACK(idx) (*(idx))</TD></TR></TABLE></P>
<P><B>Reads the expression stack at a specific index.</B></P>
<P>The ESTACK macro can be used to read the expression stack at the index <I>idx</I>.
It simply dereferences <I>idx</I>, since the <A HREF="#ESI">ESI</A> and
<A HREF="#CESI">CESI</A> types are in fact pointers to quantums of type
<A HREF="#ESQ">ESQ</A>.</P>
<HR>
<H3><A NAME="factor_base_index"><U>factor_base_index</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> factor_base_index (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Gets the index of the base of an expression.</B></P>
<P>If <I>ptr</I> points to the <A HREF="#POW_TAG">POW_TAG</A>, which is a case when it
points to an expression of form <I>base</I> ^ <I>exponent</I>
factor_base_index returns the pointer to <I>base</I>. If <I>ptr</I> does not point to the
<A HREF="#POW_TAG">POW_TAG</A>, factor_base_index returns <I>ptr</I> (i.e. the pointer to the expression itself).</P>
<HR>
<H3><A NAME="factor_exponent_index"><U>factor_exponent_index</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> factor_exponent_index (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Gets the index of the exponent of an expression.</B></P>
<P>If <I>ptr</I> points to the <A HREF="#POW_TAG">POW_TAG</A>, which is a case when it
points to an expression of form <I>base</I> ^ <I>exponent</I>
factor_exponent_index returns the pointer to <I>exponent</I>. If <I>ptr</I> does not
point to the <A HREF="#POW_TAG">POW_TAG</A>, 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).</P>
<HR>
<H3><A NAME="gcd_exact_whole_Floats"><U>gcd_exact_whole_Floats</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#float">float</A></B> gcd_exact_whole_Floats (<A HREF="#CESI">CESI</A> ptr1, <A HREF="#CESI">CESI</A> ptr2);</TD></TR></TABLE></P>
<P><B>Finds the greatest common divisor of two floating point entries.</B></P>
<P>gcd_exact_whole_Floats finds the greatest common divisor of two floating point entries
pointed to by <I>ptr1</I> and <I>ptr2</I> and returns the result (the result is a garbage
if <I>ptr1</I> or <I>ptr2</I> doesn't point to floating point entries).
<BR><BR>
<B>Note:</B> 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 <I>x</I> and <I>y</I> which is defined as the greatest number <I>z</I>
which has a property that both <I>x</I>/<I>z</I> and
<I>y</I>/<I>z</I> are whole numbers.</P>
<HR>
<H3><A NAME="get_key_ptr"><U>get_key_ptr</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#int">char</A></B> *get_key_ptr (<A HREF="#ESQ">ESQ</A> Tag1, <A HREF="#ESQ">ESQ</A> Tag2);</TD></TR></TABLE></P>
<P><B>Converts a tag code to a tag name.</B></P>
<P>get_key_ptr returns a static pointer to the string which represents the name of the
tag <I>Tag1</I>. <I>Tag2</I> is used only if <I>Tag1</I> is an extended tag
(i.e. <A HREF="#EXT_TAG">EXT_TAG</A>, <A HREF="#EXT_INSTR_TAG">EXT_INSTR_TAG</A> or <A HREF="#EXT_SYSTEM_TAG">EXT_SYSTEM_TAG</A>)
which can't be fully represented using only one byte.
<BR><BR>
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.</P>
<HR>
<H3><A NAME="GetValue"><U>GetValue</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">long</A></B> GetValue (<A HREF="#CESI">CESI</A> ptr, <B><A HREF="keywords.html#short">long</A></B> low, <B><A HREF="keywords.html#short">long</A></B> high);</TD></TR></TABLE></P>
<P><B>Converts entry on the expression stack to short integer and checks whether it is in a given range.</B></P>
<P>GetValue converts an entry on the expression stack pointed to by <I>ptr</I> (it needs
to point on the entry tag) to a short integer value using
<A HREF="#estack_to_short">estack_to_short</A> or <A HREF="#estack_to_ushort">estack_to_ushort</A>,
depending on the sign of <I>low</I>. Then, a "Domain Error" is thrown if the value
is smaller than <I>low</I> or greater than <I>high</I>, otherwise the value will be
returned as the result of the function. It will also throw a "Data type" error if the entry
cannot be represented as an integer.</P>
<HR>
<H3><A NAME="HToESI"><U>HToESI</U></A></H3>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> HToESI (<A HREF="alloc.html#HANDLE">HANDLE</A> Handle);</TD></TR></TABLE></P>
<P><B>Converts a handle to an expression stack index.</B></P>
<P>HToESI is a simple but very useful routine. It returns a pointer to the last
byte of the <A HREF="#MULTI_EXPR">MULTI_EXPR</A> structure referenced
by <I>Handle</I>. Therefore it allows for the use of TIOS variables as input
data in expression stack routines. Assuming that <I>Handle</I>
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 <A HREF="#CESI">CESI</A>, like
<A HREF="#NG_approxESI">NG_approxESI</A>, etc. (except in functions which manipulate
the actual memory space on the expression stack, like
<A HREF="#delete_between">delete_between</A>).
In fact, HToESI simply dereferences <I>Handle</I> 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.
<BR><BR>
<B>Note:</B> 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.</P>
<HR>
<H3><A NAME="im_index"><U>im_index</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> im_index (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Gets the index of the imaginary part of an expression.</B></P>
<P>If <I>ptr</I> points to the <A HREF="#COMPLEX_TAG">COMPLEX_TAG</A>
(i.e. if the expression is complex), im_index returns the pointer
to the imaginary part of the expression. If <I>ptr</I> does not point to the
<A HREF="#COMPLEX_TAG">COMPLEX_TAG</A> (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).
<BR><BR>
<B>Note:</B> The expression should be in internal canonic form
(see <A HREF="#push_internal_simplify">push_internal_simplify</A>), else this function
is not reliable.</P>
<HR>
<H3><A NAME="index_below_display_expression_aux"><U>index_below_display_expression_aux</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> index_below_display_expression_aux (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Main routine for detokenizing.</B></P>
<P>index_below_display_expression_aux is main (recursive) routine for detokenizing.
As it is just an auxiliary routine used in <A HREF="#display_statements">display_statements</A>
and <A HREF="#Parse1DExpr">Parse1DExpr</A>, it shouldn't need to be used directly.</P>
<HR>
<H3><A NAME="index_main_var"><U>index_main_var</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> index_main_var (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Searches an expression for a first encountered variable.</B></P>
<P>index_main_var returns the index of the first encountered variable in the expression
pointed to by <I>ptr</I>. More precise, it repeatedly decreases value of <I>ptr</I> by one
until the tag of a variable, a number or a symbolic constant (like <B>pi</B>) is
reached. As expressions are usually organized in "internal canonic" form (see notes given with
description of <A HREF="#numeric_factor_index">numeric_factor_index</A>) 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 <A HREF="#push_internal_simplify">push_internal_simplify</A>).</P>
<HR>
<H3><A NAME="index_numeric_term"><U>index_numeric_term</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> index_numeric_term (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Searches terms in the expression for a numeric term.</B></P>
<P>If <I>ptr</I> points to the <A HREF="#ADD_TAG">ADD_TAG</A>, which is a case when it
points to an expression of form <I>term1</I> + <I>term2</I> + <B>...</B>
(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 <I>ptr</I> (i.e. the pointer to the expression itself). If <I>ptr</I> does not point to
the <A HREF="#ADD_TAG">ADD_TAG</A> (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).
<BR><BR>
<B>Note:</B> 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
<A HREF="#push_parse_text">push_parse_text</A> function, nor after an evaluation using
<A HREF="#NG_rationalESI">NG_rationalESI</A> or <A HREF="#NG_approxESI">NG_approxESI</A>. In
other words, results of these commands are not always "correctly" organized. To force converting
an expression to the internal canonic form, always call
<A HREF="#push_internal_simplify">push_internal_simplify</A> after usage of any of the functions
mentioned above.</P>
<HR>
<H3><A NAME="index_of_lead_base_of_lead_term"><U>index_of_lead_base_of_lead_term</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> index_of_lead_base_of_lead_term (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Gets the index of the base of the lead term of an expression.</B></P>
<P>index_of_lead_base_of_lead_term first calls <A HREF="#lead_term_index">lead_term_index</A>,
then apply <A HREF="#lead_base_index">lead_base_index</A> 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 <I>ptr</I>.</P>
<HR>
<H3><A NAME="init_list_indices"><U>init_list_indices</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> *init_list_indices (<A HREF="#ESI">ESI</A> *indices, <A HREF="#CESI">CESI</A> expr);</TD></TR></TABLE></P>
<P><B>Computes and stores the indices of the elements of a list.</B></P>
<P>init_list_indices stores the index of the first element to <I>indices</I>, then it
repeatedly calls <A HREF="#next_expression_index">next_expression_index</A> and
stores the result to <I>indices</I> until <A HREF="#END_TAG">END_TAG</A> is reached.
<BR>
<I>expr</I> is assumed to point to a <A HREF="#LIST_TAG">LIST_TAG</A>.
init_list_indices returns <I>indices</I>.
<BR><BR>
Here is an example (called "List elements") which displays the list elements as returned by
init_list_indices: </P>
<PRE>// Shows how the init_list_indices function works.
#define USE_TI89 // Compile for TI-89
#define USE_TI92PLUS // Compile for TI-92 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
// The {1, 0, -1} list.
static const ESQ list_1_0_minus1[10] = {END_TAG, 0x01, 0x01, NEGINT_TAG, 0x00, POSINT_TAG, 0x01, 0x01, POSINT_TAG, LIST_TAG};
// Main Function
void _main(void)
{
ESI elements[3];
HANDLE h;
TRY
ClrScr();
DrawStr (0, 0, "The elements of list", A_NORMAL);
DrawStr (0, 20, "are", A_NORMAL);
// Print whole expression.
h = Parse1DExpr (list_1_0_minus1 + 9, FALSE, 0);
DrawStr(0, 10, HeapDeref(h), A_NORMAL);
HeapFree(h);
// Get the individual constituents of the expression and print them.
init_list_indices(elements, list_1_0_minus1 + 9);
h = Parse1DExpr (elements[0], FALSE, 0);
DrawStr(0, 30, HeapDeref(h), A_NORMAL);
HeapFree(h);
h = Parse1DExpr (elements[1], FALSE, 0);
DrawStr(0, 40, HeapDeref(h), A_NORMAL);
HeapFree(h);
h = Parse1DExpr (elements[2], FALSE, 0);
DrawStr(0, 50, HeapDeref(h), A_NORMAL);
HeapFree(h);
ONERR
DrawStr (0, 70, "Error!", A_NORMAL);
ENDTRY
GKeyIn (NULL, 0);
}
</PRE>
<HR>
<H3><A NAME="init_matrix_indices"><U>init_matrix_indices</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><A HREF="#ESI">ESI</A> *init_matrix_indices (<A HREF="#ESI">ESI</A> *indices, <A HREF="#CESI">CESI</A> expr);</TD></TR></TABLE></P>
<P><B>Computes and stores the indices of the elements of a matrix.</B></P>
<P>init_matrix_indices stores the index of the first element of the first row to <I>indices</I>, then
it repeatedly calls <A HREF="#next_expression_index">next_expression_index</A> and
stores the result to <I>indices</I> until the <A HREF="#END_TAG">END_TAG</A>
for the whole matrix is reached.<BR>
<I>expr</I> is assumed to point to a double <A HREF="#LIST_TAG">LIST_TAG</A>.
init_matrix_indices returns <I>indices</I>.
<BR><BR>
Here is an example (called "Matrix elements") which displays the matrix elements as returned by
init_matrix_indices: </P>
<PRE>// Shows how the init_matrix_indices function works.
#define USE_TI89 // Compile for TI-89
#define USE_TI92PLUS // Compile for TI-92 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
// The [1, 0; 0, 1] matrix.
static const ESQ matrix_identity_2[16] = {END_TAG, END_TAG, 0x01, 0x01, POSINT_TAG, 0x00, POSINT_TAG, LIST_TAG, END_TAG, 0x00, POSINT_TAG, 0x01, 0x01, POSINT_TAG, LIST_TAG, LIST_TAG};
// Main Function
void _main(void)
{
ESI elements[4];
HANDLE h;
TRY
ClrScr();
DrawStr (0, 0, "The elements of matrix", A_NORMAL);
DrawStr (0, 20, "are", A_NORMAL);
// Print whole expression.
h = Parse1DExpr (matrix_identity_2 + 15, FALSE, 0);
DrawStr(0, 10, HeapDeref(h), A_NORMAL);
HeapFree(h);
// Get the individual constituents of the expression and print them.
init_matrix_indices(elements, matrix_identity_2 + 15);
h = Parse1DExpr (elements[0], FALSE, 0);
DrawStr(0, 30, HeapDeref(h), A_NORMAL);
HeapFree(h);
h = Parse1DExpr (elements[1], FALSE, 0);
DrawStr(0, 40, HeapDeref(h), A_NORMAL);
HeapFree(h);
h = Parse1DExpr (elements[2], FALSE, 0);
DrawStr(0, 50, HeapDeref(h), A_NORMAL);
HeapFree(h);
h = Parse1DExpr (elements[3], FALSE, 0);
DrawStr(0, 60, HeapDeref(h), A_NORMAL);
HeapFree(h);
ONERR
DrawStr (0, 70, "Error!", A_NORMAL);
ENDTRY
GKeyIn (NULL, 0);
}
</PRE>
<HR>
<H3><A NAME="integer_non_unknown"><U>integer_non_unknown</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> integer_non_unknown (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Tests if an expression is an integer.</B></P>
<P>Returns 1 if the expression pointed to by <I>ptr</I> is an integer
or floating-point value; returns -1 for constants like <B><FONT FACE="Symbol">p</FONT></B> or <B><I>e</I></B>.
Returns 0 for everything else - this includes expressions like <CODE>ln(2)</CODE>,
<CODE>2<B><FONT FACE="Symbol">p</FONT></B></CODE>, or <CODE><B><FONT FACE="Symbol">Ö</FONT></B>(2)</CODE>.</P>
<HR>
<H3><A NAME="is0"><U>is0</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.00 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is0 (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Tests if an expression is equal to 0.</B></P>
<P>Returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is equal to zero (integer or floating point).</P>
<P>See also: <A HREF="#is1">is1</A>, <A HREF="#is_minus1">is_minus1</A>, <A HREF="#is_never0">is_never0</A></P>
<HR>
<H3><A NAME="is1"><U>is1</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.00 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is1 (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Tests if an expression is equal to 1.</B></P>
<P>Returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is equal to one (integer or floating point).</P>
<P>See also: <A HREF="#is0">is0</A>, <A HREF="#is_minus1">is_minus1</A></P>
<HR>
<H3><A NAME="is_advanced_tag"><U>is_advanced_tag</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_advanced_tag (<A HREF="#ESQ">ESQ</A> Tag);</TD></TR></TABLE></P>
<P><B>Checks whether a tag is an advanced tag.</B></P>
<P>is_advanced_tag returns <A HREF="alloc.html#Bool">TRUE</A> if a byte <I>Tag</I> is an
advanced tag, otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>. 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 element-by-element versions
"+<B>.</B>", "-<B>.</B>", "*<B>.</B>", "/<B>.</B>" and "^<B>.</B>").</P>
<HR>
<H3><A NAME="is_antisymmetric"><U>is_antisymmetric</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_antisymmetric (<A HREF="#CESI">CESI</A> expr_ptr, <A HREF="#CESI">CESI</A> var_ptr);</TD></TR></TABLE></P>
<P><B>Checks for a antisymmetry.</B></P>
<P>is_antisymmetric returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>expr_ptr</I> is such that it changes the sign but keeps the same magnitude
when the variable pointed to by
<I>var_ptr</I> changes it sign, otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>.</P>
<HR>
<H3><A NAME="is_complex0"><U>is_complex0</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_complex0 (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is reducible to zero.</B></P>
<P>is_complex0 returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is a zero (signed, unsigned, or even complex), otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>.
<BR><BR>
<B>Note:</B> The information about this routine in releases of TIGCCLIB before 2.3 was wrong.</P>
<HR>
<H3><A NAME="is_complex_number"><U>is_complex_number</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_complex_number (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is a number.</B></P>
<P>is_complex_number returns <A HREF="alloc.html#Bool">TRUE</A> if the expression (in RPN form,
of course) pointed to by <I>ptr</I> is a "number" (integer, rational, floating point, or
complex, but not irrational), otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>.
Note that <CODE>'sqrt(2)'</CODE> 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.
<BR><BR>
<B>Note:</B> The information about this routine in releases of TIGCCLIB before 2.3 was wrong.</P>
<P>See also: <A HREF="#likely_approx_to_number">likely_approx_to_number</A></P>
<HR>
<H3><A NAME="is_constant"><U>is_constant</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_constant (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is constant.</B></P>
<P>is_constant returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> does not rely on any variables (initialized, built-in, but not constants like <B><FONT FACE="Symbol">p</FONT></B>),
otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>.</P>
<HR>
<H3><A NAME="is_Float_exact_whole_number"><U>is_Float_exact_whole_number</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_Float_exact_whole_number (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Checks whether a floating point entry is an exact whole number.</B></P>
<P>is_Float_exact_whole_number returns <A HREF="alloc.html#Bool">TRUE</A> if the floating point
entry pointed to by <I>ptr</I> is an exact whole number whose magnitude is less than
the smallest whole number that is not represented exactly (1e15), otherwise it returns
<A HREF="alloc.html#Bool">FALSE</A>.</P>
<HR>
<H3><A NAME="is_free_of_tag"><U>is_free_of_tag</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_free_of_tag (<A HREF="#CESI">CESI</A> ptr, <A HREF="#ESQ">ESQ</A> Tag);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is free of a particular tag.</B></P>
<P>is_free_of_tag is a recursive function which returns <A HREF="alloc.html#Bool">TRUE</A>
if the expression structure pointed to by <I>ptr</I> is free of tag <I>Tag</I>,
otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>.</P>
<HR>
<H3><A NAME="is_independent_of_de_seq_vars"><U>is_independent_of_de_seq_vars</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_independent_of_de_seq_vars (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is independent of differential equation and sequence variables.</B></P>
<P>is_independent_of_de_seq_vars returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>expr_ptr</I> is independent of system variables which are used for differential
equation and sequence graphing (i.e. variables u1-u99
and y1'-y99'),
otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>.</P>
<HR>
<H3><A NAME="is_independent_of_elements"><U>is_independent_of_elements</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_independent_of_elements (<A HREF="#CESI">CESI</A> expr_ptr, <A HREF="#CESI">CESI</A> varlist_ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is independent of the elements of a list.</B></P>
<P>is_independent_of_elements is very similar to <A HREF="#is_independent_of_tail">is_independent_of_tail</A>.
Assuming that <I>varlist_ptr</I> points to the list of variables or expressions (more precise, to the
<A HREF="#LIST_TAG">LIST_TAG</A> of such list), is_independent_of_elements returns
<A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by <I>expr_ptr</I> is independent
of all variables from the list pointed to by <I>varlist_ptr</I>, otherwise it returns
<A HREF="alloc.html#Bool">FALSE</A>. More precisely,</P>
<PRE>is_independent_of_elements (expr_ptr, varlist_ptr)
</PRE>
<P>is the same as</P>
<PRE>is_independent_of_tail (expr_ptr, varlist_ptr - 1)
</PRE>
<HR>
<H3><A NAME="is_independent_of_tail"><U>is_independent_of_tail</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_independent_of_tail (<A HREF="#CESI">CESI</A> expr_ptr, <A HREF="#CESI">CESI</A> start_ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is independent of a sequence of variables (or expressions).</B></P>
<P>is_independent_of_tail returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>expr_ptr</I> is independent of all entries on the expression stack stored below
<I>start_ptr</I> up to <A HREF="#END_TAG">END_TAG</A> tag, otherwise it returns
<A HREF="alloc.html#Bool">FALSE</A>.</P>
<P>See also: <A HREF="#is_independent_of">is_independent_of</A>, <A HREF="#is_independent_of_elements">is_independent_of_elements</A>, <A HREF="#map_tail">map_tail</A>, <A HREF="#all_tail">all_tail</A></P>
<HR>
<H3><A NAME="is_independent_of"><U>is_independent_of</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_independent_of (<A HREF="#CESI">CESI</A> expr_ptr, <A HREF="#CESI">CESI</A> var_ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is independent of a variable (or expression).</B></P>
<P>is_independent_of returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>expr_ptr</I> is independent of the variable pointed to by
<I>var_ptr</I>, else returns <A HREF="alloc.html#Bool">FALSE</A>. Although <I>var_ptr</I>
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).
<BR><BR>
<B>Note:</B> This routine (and all other "independence" routines also)
is not reliable if expressions are not in internal canonic form
(see <A HREF="#push_internal_simplify">push_internal_simplify</A>).</P>
<HR>
<H3><A NAME="is_matrix"><U>is_matrix</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_matrix (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is a matrix.</B></P>
<P>is_matrix returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is a matrix (i.e. a list which consists of equally sized lists),
otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>.</P>
<HR>
<H3><A NAME="is_minus1"><U>is_minus1</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_minus1 (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Tests if an expression is equal to -1.</B></P>
<P>Returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is equal to negative one (integer or floating point).</P>
<P>See also: <A HREF="#is0">is0</A>, <A HREF="#is1">is1</A></P>
<HR>
<H3><A NAME="is_monomial_in_kernel"><U>is_monomial_in_kernel</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_monomial_in_kernel (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is a monomial in kernel.</B></P>
<P>is_monomial_in_kernel returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is a monomial in kernel, i.e. if it is a monomial function of kernels,
where "kernel" means any irrational subexpression, else returns <A HREF="alloc.html#Bool">FALSE</A>.
For example, <CODE>'sin(x)*ln(y)'</CODE> is not monomial (in respect to <CODE>'x'</CODE>
and <CODE>'y'</CODE>), but it is monomial in kernel (in respect to <CODE>'sin(x)'</CODE>
and <CODE>'ln(y)'</CODE>).</P>
<HR>
<H3><A NAME="is_monomial"><U>is_monomial</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_monomial (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is a monomial.</B></P>
<P>is_monomial returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is a monomial expression, otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>.
For example, the expression <CODE>'x*y^3'</CODE> is a monomial, and
<CODE>x+y*z'</CODE> or <CODE>'ln(x)'</CODE> are not.</P>
<HR>
<H3><A NAME="is_narrowly_independent_of"><U>is_narrowly_independent_of</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 1.01 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_narrowly_independent_of (<A HREF="#CESI">CESI</A> expr_ptr, <A HREF="#CESI">CESI</A> var_ptr);</TD></TR></TABLE></P>
<P><B>Checks whether an expression is narrowly independent of a variable (???).</B></P>
<P>is_narrowly_independent_of returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>expr_ptr</I> is narrowly independent of the variable pointed to by
<I>var_ptr</I>, otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>. I am not sure what
"narrowly independent" really means, and what the difference between this function
and <A HREF="#is_independent_of">is_independent_of</A> is.</P>
<HR>
<H3><A NAME="is_negative"><U>is_negative</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_negative (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Tests if an expression is less than 0.</B></P>
<P>Returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is known to be negative, <A HREF="alloc.html#Bool">FALSE</A> otherwise.</P>
<P>See also: <A HREF="#is_nonnegative">is_nonnegative</A>, <A HREF="#is_positive">is_positive</A>, <A HREF="#is_nonpositive">is_nonpositive</A></P>
<HR>
<H3><A NAME="is_never0"><U>is_never0</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_never0 (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Tests if an expression is never 0.</B></P>
<P>Returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> cannot be equal to zero.</P>
<P>See also: <A HREF="#is0">is0</A></P>
<HR>
<H3><A NAME="is_nonnegative"><U>is_nonnegative</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_nonnegative (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Tests if an expression is >= 0.</B></P>
<P>Returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is known to be positive or zero, <A HREF="alloc.html#Bool">FALSE</A> otherwise.</P>
<P>See also: <A HREF="#is_negative">is_negative</A>, <A HREF="#is_positive">is_positive</A>, <A HREF="#is_nonpositive">is_nonpositive</A></P>
<HR>
<H3><A NAME="is_nonpositive"><U>is_nonpositive</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_nonpositive (<A HREF="#CESI">CESI</A> ptr);</TD></TR></TABLE></P>
<P><B>Tests if an expression is <= 0.</B></P>
<P>Returns <A HREF="alloc.html#Bool">TRUE</A> if the expression pointed to by
<I>ptr</I> is known to be negative or zero, <A HREF="alloc.html#Bool">FALSE</A> otherwise.</P>
<P>See also: <A HREF="#is_positive">is_positive</A>, <A HREF="#is_negative">is_negative</A>, <A HREF="#is_nonnegative">is_nonnegative</A></P>
<HR>
<H3><A NAME="is_polynomial_in_var_or_kern"><U>is_polynomial_in_var_or_kern</U></A></H3>
<P><A HREF="httigcc.html#minams">AMS 2.02 or higher</A></P>
<P><TABLE BORDER="1" CELLPADDING="2"><TR><TD CLASS="CODE"><B><A HREF="keywords.html#short">short</A></B> is_polynomial_in_var_or_kern (<A HREF="#CESI">CESI</A> test, <A HREF="#CESI">CESI</A> var_or_kern);</TD></TR></TABLE></P>
<P><B>Checks if an expression is a polynomial with respect to another expression.</B></P>
<P>is_polynomial_in_var_or_kern returns <A HREF="alloc.html#Bool">TRUE</A> if the expression
pointed to by <I>test</I> is a polynomial with respect to the expression <I>var_or_kern</I>,
otherwise it returns <A HREF="alloc.html#Bool">FALSE</A>. The definition of "polynomial