Source code: com/hartmath/lib/C.java
1 /*
2 * C.java
3 * Copyright (C) 2000, 2001 Klaus Hartlage
4 *
5 * This program is free software; you can redistribute it and/or
6 * modify it under the terms of the GNU General Public License
7 * as published by the Free Software Foundation; either version 2
8 * of the License, or any later version.
9 *
10 * This program is distributed in the hope that it will be useful,
11 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13 * GNU General Public License for more details.
14 *
15 * You should have received a copy of the GNU General Public License
16 * along with this program; if not, write to the Free Software
17 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
18 */
19 package com.hartmath.lib;
20
21 import com.hartmath.util.*;
22 import com.hartmath.mapping.*;
23 import com.hartmath.patternmatching.*;
24 import com.hartmath.Main;
25
26 import java.io.*;
27 import java.net.*;
28 import java.lang.*;
29 import java.applet.*;
30 import java.awt.Label;
31 import java.util.Properties;
32 import com.hartmath.expression.HObject;
33 import com.hartmath.expression.HComplex;
34 import com.hartmath.expression.HDoubleComplex;
35 import com.hartmath.expression.HSymbol;
36 import com.hartmath.expression.HFunction;
37 import com.hartmath.expression.HDouble;
38 import com.hartmath.expression.HFraction;
39 import com.hartmath.expression.HInteger;
40 import com.hartmath.expression.HPattern;
41 import com.hartmath.initial.Programming;
42 import com.hartmath.initial.BooleanOperators;
43 import com.hartmath.initial.SymbolOperators;
44 import com.hartmath.initial.MathOperators;
45
46 /**
47 * The <b>C.java</b> class defines global constants. These constants are
48 * function-symbols like C.Sin, C.Cos; symbol-constants like C.Pi,
49 * C.EulerGamma; variable constants like C.x C.y; pattern-constants like C.x_,
50 * C.y_; integer constants like C.CN1, C.C0, C.C1,...; fraction constants like
51 * C.CN1D2, C.C1D2,...;<br>
52 * composed expressions (HFunction's) like CPiP2;<br>
53 * <br>
54 * You can construct new mathematical expressions from these constants with the
55 * HSymbol.f(...) methods.<br>
56 * Example: C.Add.f(C.CN1D3,C.Sin.f( C.PiP2 ) ) constructs the expresssion
57 * -1/3+Sin( Pi^2 )
58 *
59 *@author khartlage
60 *@created 31. Juli 2001
61 */
62 public class C {
63 /**
64 * Description of the Field
65 */
66 public final static Label statusLine = new Label("Loading HartMath");
67 /**
68 * Description of the Field
69 */
70 public final static SymbolEvaluator dummyFunction = new SymbolEvaluator();
71 /**
72 * Description of the Field
73 */
74 public final static FunctionEvaluator loadScript = new ELoadScript();
75 /**
76 * Description of the Field
77 */
78 public final static FunctionEvaluator loadBeanShell = new ELoadBeanShell();
79 /**
80 * Description of the Field
81 */
82 public final static FunctionEvaluator loadClass = new ELoadClass();
83 /**
84 * main DEBUG flag
85 */
86 public final static boolean DEBUG = false;
87 /**
88 * main exception log flag
89 */
90 public final static boolean LOG_EXCEPTIONS = true;
91 /**
92 * Description of the Field
93 */
94 public static int sessionCounter = 1;
95
96 /**
97 * Description of the Field
98 */
99 public final static String version = new String("HartMath version ");
100
101 //final static public int BUILD = 141;
102 /**
103 * Description of the Field
104 */
105 public static Boolean initialized = Boolean.FALSE;
106 /**
107 * Description of the Field
108 */
109 public static URL codeBase = null;
110 /**
111 * Description of the Field
112 */
113 public static int timeConstrained = 0;
114
115 // operator precedece constants:
116
117 public final static int MINIMUM_PRECEDENCE = 0;
118 /**
119 * Description of the Field
120 */
121 public final static int STATEMENT_PRECEDENCE = 100;
122
123 /**
124 * Description of the Field
125 */
126 public final static int SET_PRECEDENCE = 200;
127 /**
128 * Description of the Field
129 */
130 public final static int SETDELAYED_PRECEDENCE = 200;
131 /**
132 * Description of the Field
133 */
134 public final static int UPSET_PRECEDENCE = 200;
135 /**
136 * Description of the Field
137 */
138 public final static int UPSETDELAYED_PRECEDENCE = 200;
139
140 /**
141 * Description of the Field
142 */
143 public final static int ADDTO_PRECEDENCE = 300;
144 /**
145 * Description of the Field
146 */
147 public final static int SUBTRACTFROM_PRECEDENCE = 300;
148 /**
149 * Description of the Field
150 */
151 public final static int TIMESBY_PRECEDENCE = 300;
152 /**
153 * Description of the Field
154 */
155 public final static int DIVIDEBY_PRECEDENCE = 300;
156
157 /**
158 * Description of the Field
159 */
160 public final static int REPLACEALL_PRECEDENCE = 400;
161 /**
162 * Description of the Field
163 */
164 public final static int RULE_PRECEDENCE = 500;
165 /**
166 * Description of the Field
167 */
168 public final static int RULEDELAYED_PRECEDENCE = 500;
169
170 /**
171 * Description of the Field
172 */
173 public final static int OR_PRECEDENCE = 600;
174 /**
175 * Description of the Field
176 */
177 public final static int AND_PRECEDENCE = 700;
178 /**
179 * Description of the Field
180 */
181 public final static int NOT_PRECEDENCE = 800;
182
183 /**
184 * Description of the Field
185 */
186 public final static int EQUAL_PRECEDENCE = 900;
187 /**
188 * Description of the Field
189 */
190 public final static int UNEQUAL_PRECEDENCE = 900;
191 /**
192 * Description of the Field
193 */
194 public final static int LESS_PRECEDENCE = 900;
195 /**
196 * Description of the Field
197 */
198 public final static int LESSEQUAL_PRECEDENCE = 900;
199 /**
200 * Description of the Field
201 */
202 public final static int GREATER_PRECEDENCE = 900;
203 /**
204 * Description of the Field
205 */
206 public final static int GREATEREQUAL_PRECEDENCE = 900;
207
208 /**
209 * Description of the Field
210 */
211 public final static int ADD_PRECEDENCE_DEC = 999;
212 /**
213 * Description of the Field
214 */
215 public final static int ADD_PRECEDENCE = 1000;
216 /**
217 * Description of the Field
218 */
219 public final static int MINUS_PRECEDENCE = 1000;
220
221 /**
222 * Description of the Field
223 */
224 public final static int MULTIPLY_PRECEDENCE = 1100;
225 /**
226 * Description of the Field
227 */
228 public final static int DOT_PRECEDENCE = 1200;
229 /**
230 * Description of the Field
231 */
232 public final static int POW_PRECEDENCE = 1300;
233 /**
234 * Description of the Field
235 */
236 public final static int INC_DEC_PRECEDENCE = 1400;
237
238 /**
239 * Description of the Field
240 */
241 public final static int MAXIMUM_PRECEDENCE = 999999;
242 /**
243 * Constant: HDouble value -1.0
244 */
245 public final static HDouble CDN1 = new HDouble(-1.0d);
246
247 /**
248 * Constant: HDouble value 0.0
249 */
250 public final static HDouble CD0 = new HDouble(0.0d);
251
252 /**
253 * Constant: HDouble value 1.0
254 */
255 public final static HDouble CD1 = new HDouble(1.0d);
256
257 /**
258 * Constant: HInteger value -5
259 */
260 public final static HInteger CN5 = new HInteger(HInteger.IN5);
261
262 /**
263 * Constant: HInteger value -4
264 */
265 public final static HInteger CN4 = new HInteger(HInteger.IN4);
266
267 /**
268 * Constant: HInteger value -3
269 */
270 public final static HInteger CN3 = new HInteger(HInteger.IN3);
271
272 /**
273 * Constant: HInteger value -2
274 */
275 public final static HInteger CN2 = new HInteger(HInteger.IN2);
276
277 /**
278 * Constant: HInteger value -1
279 */
280 public final static HInteger CN1 = new HInteger(HInteger.IN1);
281
282 /**
283 * Constant: HInteger value 0
284 */
285 public final static HInteger C0 = new HInteger(HInteger.I0);
286
287 /**
288 * Constant: HInteger value 1
289 */
290 public final static HInteger C1 = new HInteger(HInteger.I1);
291
292 /**
293 * Constant: HInteger value 2
294 */
295 public final static HInteger C2 = new HInteger(HInteger.I2);
296
297 /**
298 * Constant: HInteger value 3
299 */
300 public final static HInteger C3 = new HInteger(HInteger.I3);
301
302 /**
303 * Constant: HInteger value 4
304 */
305 public final static HInteger C4 = new HInteger(HInteger.I4);
306
307 /**
308 * Constant: HInteger value 5
309 */
310 public final static HInteger C5 = new HInteger(HInteger.I5);
311
312 /**
313 * Constant: HInteger value 6
314 */
315 //bugfix by pfa:
316 //final static public HInteger C6 = new HInteger(HInteger.I5);
317 public final static HInteger C6 = new HInteger(HInteger.I6);
318
319 /**
320 * Constant: HInteger value 10
321 */
322 public final static HInteger C10 = new HInteger(HInteger.I10);
323
324 /**
325 * Constant: HInteger value 100
326 */
327 public final static HInteger C100 = new HInteger(HInteger.I100);
328 /**
329 * Constant: HFraction value 1/2
330 */
331 public final static HFraction C1D2 = new HFraction(HInteger.I1,
332 HInteger.I2);
333
334 /**
335 * Constant: HFraction value 1/3
336 */
337 public final static HFraction C1D3 = new HFraction(HInteger.I1,
338 HInteger.I3);
339
340 /**
341 * Constant: HFraction value 1/4
342 */
343 public final static HFraction C1D4 = new HFraction(HInteger.I1,
344 HInteger.I4);
345
346 /**
347 * Constant: HFraction value 1/5
348 */
349 public final static HFraction C1D5 = new HFraction(HInteger.I1,
350 HInteger.I5);
351
352 /**
353 * Constant: HFraction value 1/6
354 */
355 public final static HFraction C1D6 = new HFraction(HInteger.I1,
356 HInteger.I6);
357
358 /**
359 * Constant: HFraction value 1/7
360 */
361 public final static HFraction C1D7 = new HFraction(HInteger.I1,
362 HInteger.I7);
363
364 /**
365 * Constant: HFraction value 1/8
366 */
367 public final static HFraction C1D8 = new HFraction(HInteger.I1,
368 HInteger.I8);
369
370 /**
371 * Constant: HFraction value 1/9
372 */
373 public final static HFraction C1D9 = new HFraction(HInteger.I1,
374 HInteger.I9);
375 /**
376 * Constant: HFraction value 1/10
377 */
378 public final static HFraction C1D10 = new HFraction(HInteger.I1,
379 HInteger.I10);
380
381 /**
382 * Constant: HFraction value 2/3
383 */
384 public final static HFraction C2D3 = new HFraction(HInteger.I2,
385 HInteger.I3);
386
387 /**
388 * Constant: HFraction value 3/4
389 */
390 public final static HFraction C3D4 = new HFraction(HInteger.I3,
391 HInteger.I4);
392
393 /**
394 * Constant: HFraction value 2/5
395 */
396 public final static HFraction C2D5 = new HFraction(HInteger.I2,
397 HInteger.I5);
398
399 /**
400 * Constant: HFraction value 3/5
401 */
402 public final static HFraction C3D5 = new HFraction(HInteger.I3,
403 HInteger.I5);
404
405 /**
406 * Constant: HFraction value 4/5
407 */
408 public final static HFraction C4D5 = new HFraction(HInteger.I4,
409 HInteger.I5);
410
411 /**
412 * Constant: HFraction value 5/6
413 */
414 public final static HFraction C5D6 = new HFraction(HInteger.I5,
415 HInteger.I6);
416
417 /**
418 * Constant: HFraction value 2/7
419 */
420 public final static HFraction C2D7 = new HFraction(HInteger.I2,
421 HInteger.I7);
422
423 /**
424 * Constant: HFraction value 3/7
425 */
426 public final static HFraction C3D7 = new HFraction(HInteger.I3,
427 HInteger.I7);
428
429 /**
430 * Constant: HFraction value 4/7
431 */
432 public final static HFraction C4D7 = new HFraction(HInteger.I4,
433 HInteger.I7);
434
435 /**
436 * Constant: HFraction value 5/7
437 */
438 public final static HFraction C5D7 = new HFraction(HInteger.I5,
439 HInteger.I7);
440
441 /**
442 * Constant: HFraction value 6/7
443 */
444 public final static HFraction C6D7 = new HFraction(HInteger.I6,
445 HInteger.I7);
446
447 /**
448 * Constant: HFraction value -1/2
449 */
450 public final static HFraction CN1D2 = new HFraction(HInteger.IN1,
451 HInteger.I2);
452
453 /**
454 * Constant: HFraction value -1/3
455 */
456 public final static HFraction CN1D3 = new HFraction(HInteger.IN1,
457 HInteger.I3);
458
459 /**
460 * Constant: HFraction value -1/4
461 */
462 public final static HFraction CN1D4 = new HFraction(HInteger.IN1,
463 HInteger.I4);
464
465 /**
466 * Constant: HFraction value -1/5
467 */
468 public final static HFraction CN1D5 = new HFraction(HInteger.IN1,
469 HInteger.I5);
470
471 /**
472 * Constant: HFraction value -1/6
473 */
474 public final static HFraction CN1D6 = new HFraction(HInteger.IN1,
475 HInteger.I6);
476
477 /**
478 * Constant: HFraction value -1/7
479 */
480 public final static HFraction CN1D7 = new HFraction(HInteger.IN1,
481 HInteger.I7);
482
483 /**
484 * Constant: HFraction value -1/8
485 */
486 public final static HFraction CN1D8 = new HFraction(HInteger.IN1,
487 HInteger.I8);
488
489 /**
490 * Constant: HFraction value -1/9
491 */
492 public final static HFraction CN1D9 = new HFraction(HInteger.IN1,
493 HInteger.I9);
494
495 /**
496 * Constant: HFraction value -1/10
497 */
498 public final static HFraction CN1D10 = new HFraction(HInteger.IN1,
499 HInteger.I10);
500
501 /**
502 * Constant: HFraction value -2/3
503 */
504 public final static HFraction CN2D3 = new HFraction(HInteger.IN2,
505 HInteger.I3);
506
507 /**
508 * Constant: HFraction value -3/4
509 */
510 public final static HFraction CN3D4 = new HFraction(HInteger.IN3,
511 HInteger.I4);
512
513 /**
514 * Constant: HFraction value -2/5
515 */
516 public final static HFraction CN2D5 = new HFraction(HInteger.IN2,
517 HInteger.I5);
518
519 /**
520 * Constant: HFraction value -3/5
521 */
522 public final static HFraction CN3D5 = new HFraction(HInteger.IN3,
523 HInteger.I5);
524
525 /**
526 * Constant: HFraction value -4/5
527 */
528 public final static HFraction CN4D5 = new HFraction(HInteger.IN4,
529 HInteger.I5);
530
531 /**
532 * Constant: HFraction value -5/6
533 */
534 public final static HFraction CN5D6 = new HFraction(HInteger.IN5,
535 HInteger.I6);
536
537 /**
538 * Constant: HFraction value -2/7
539 */
540 public final static HFraction CN2D7 = new HFraction(HInteger.IN2,
541 HInteger.I7);
542
543 /**
544 * Constant: HFraction value -3/7
545 */
546 public final static HFraction CN3D7 = new HFraction(HInteger.IN3,
547 HInteger.I7);
548
549 /**
550 * Constant: HFraction value -4/7
551 */
552 public final static HFraction CN4D7 = new HFraction(HInteger.IN4,
553 HInteger.I7);
554
555 /**
556 * Constant: HFraction value -5/7
557 */
558 public final static HFraction CN5D7 = new HFraction(HInteger.IN5,
559 HInteger.I7);
560
561 /**
562 * Constant: HFraction value -6/7
563 */
564 public final static HFraction CN6D7 = new HFraction(HInteger.IN6,
565 HInteger.I7);
566
567 /**
568 * Constant: HSymbol "Error"
569 */
570 public final static HSymbol Error = new HSymbol("Error");
571
572 /**
573 * Constant: HSymbol "ArithmeticError"
574 */
575 public final static HSymbol ArithmeticError =
576 new HSymbol("ArithmeticError");
577
578 /**
579 * Constant: HSymbol "SingularityError"
580 */
581 public final static HSymbol SingularityError =
582 new HSymbol("SingularityError");
583
584 /**
585 * Constant: HSymbol "NumberOfArgumentsError"
586 */
587 public final static HSymbol NumberOfArgumentsError =
588 new HSymbol("NumberOfArgumentsError");
589
590 /**
591 * Constant: HSymbol "UndefinedError"
592 */
593 public final static HSymbol UndefinedError =
594 new HSymbol("UndefinedError");
595
596 /**
597 * Constant: HSymbol "InfinityError"
598 */
599 public final static HSymbol InfinityError =
600 new HSymbol("InfinityError");
601
602 /**
603 * Constant: HSymbol "HeadFormatError"
604 */
605 public final static HSymbol HeadFormatError =
606 new HSymbol("HeadFormatError");
607
608 /**
609 * Constant: HSymbol "OutOfRangeError"
610 */
611 public final static HSymbol OutOfRangeError =
612 new HSymbol("OutOfRangeError");
613
614 /**
615 * Mathematical constant: HSymbol "Catalan"
616 *
617 *@see C.E
618 *@see C.EulerGamma
619 *@see C.Pi
620 */
621 public final static HSymbol Catalan = new HSymbol("Catalan",
622 new ConstantNumericEvaluator(new HDouble(HDouble.CATALAN)));
623 /**
624 * Constant: HComplex "I" (imaginary unit)
625 */
626 public final static HComplex CI = new HComplex(C.C0, C.C1);
627
628 /**
629 * Constant: HSymbol "Complex"
630 *
631 *@see HComplex.head()
632 */
633 public final static HSymbol Complex = new HSymbol("Complex");
634
635 /**
636 * Constant: HSymbol "DiagonalMatrix" (function-header)
637 */
638 public final static HSymbol DiagonalMatrix =
639 new HSymbol("DiagonalMatrix", C.loadClass);
640
641 /**
642 * Constant: HSymbol "Dimensions" (function-header)
643 */
644 public final static HSymbol Dimensions =
645 new HSymbol("Dimensions", C.loadClass);
646
647 /**
648 * Constant: HSymbol "Double"
649 *
650 *@see HDouble.head()
651 */
652 public final static HSymbol Double = new HSymbol("Double");
653
654 /**
655 * Constant: HSymbol "DoubleComplex"
656 *
657 *@see HDoubleComplex.head()
658 */
659 public final static HSymbol DoubleComplex =
660 new HSymbol("DoubleComplex");
661
662 /**
663 * Mathematical constant: HSymbol "E"
664 *
665 *@see C.Pi
666 */
667 public final static HSymbol E = new HSymbol("E",
668 new ConstantNumericEvaluator(new HDouble(Math.E)));
669
670 /**
671 * Mathematical constant: HSymbol "EulerGamma"
672 *
673 *@see C.Pi
674 *@see C.E
675 */
676 public final static HSymbol EulerGamma = new HSymbol("EulerGamma",
677 new ConstantNumericEvaluator(new HDouble(HDouble.EULERGAMMA)));
678 /**
679 * Constant: HSymbol "False" (boolean value)
680 *
681 *@see C.True
682 */
683 public final static HSymbol False = new HSymbol("False");
684
685 /**
686 * Constant: HSymbol "Fraction"
687 *
688 *@see HFraction.head()
689 */
690 public final static HSymbol Fraction = new HSymbol("Fraction");
691
692 /**
693 * Mathematical constant: HSymbol "I"
694 *
695 *@see C.Pi
696 *@see C.E
697 */
698 public final static HSymbol I = new HSymbol("I",
699 new ConstantEvaluator(new HDoubleComplex(0.0, 1.0), C.CI));
700
701 /**
702 * Constant: HSymbol "Infinity"
703 */
704 public final static HSymbol Infinity = new HSymbol("Infinity");
705
706 /**
707 * Constant: HSymbol "Integer"
708 *
709 *@see HInteger.head()
710 */
711 public final static HSymbol Integer = new HSymbol("Integer");
712
713 /**
714 * Constant: HSymbol "List" (function-header)
715 *
716 *@see HSymbol.LISTABLE
717 */
718 public final static HSymbol List = new HSymbol("List");
719
720 /**
721 * Constant: HSymbol "Dot" (function-header) matrix-multiplication
722 */
723 public final static HSymbol Dot = new HSymbol("Dot");
724
725 /**
726 * Constant: HSymbol "FactorInteger" (function-header)
727 */
728 public final static HSymbol FactorInteger =
729 new HSymbol("FactorInteger", C.loadClass);
730
731 /**
732 * Constant: HSymbol "EigenvaluesHermitian" (function-header)
733 */
734 public final static HSymbol EigenvaluesHermitian =
735 new HSymbol("EigenvaluesHermitian", C.loadClass);
736
737 /**
738 * Constant: HSymbol "HermitianAdjoint" (function-header)
739 */
740 public final static HSymbol HermitianAdjoint =
741 new HSymbol("HermitianAdjoint", C.loadClass);
742
743 /**
744 * Constant: HSymbol "IsHermitian" (function-header)
745 */
746 public final static HSymbol IsHermitian =
747 new HSymbol("IsHermitian", C.loadClass);
748
749 /**
750 * Constant: HSymbol "IsUnitary" (function-header)
751 */
752 public final static HSymbol IsUnitary =
753 new HSymbol("IsUnitary", C.loadClass);
754
755 /**
756 * Constant: HSymbol "EigenvaluesSymmetric" (function-header)
757 */
758 public final static HSymbol EigenvaluesSymmetric =
759 new HSymbol("EigenvaluesSymmetric", C.loadClass);
760
761 /**
762 * Constant: HSymbol "NLinearSolve" (function-header)
763 */
764 public final static HSymbol NLinearSolve =
765 new HSymbol("NLinearSolve", C.loadClass);
766
767 /**
768 * Constant: HSymbol "Fit" (function-header)
769 */
770 public final static HSymbol Fit =
771 new HSymbol("Fit", C.loadClass);
772
773 /**
774 * Constant: HSymbol "IdentityMatrix" (function-header)
775 */
776 public final static HSymbol IdentityMatrix =
777 new HSymbol("IdentityMatrix", C.loadClass);
778
779 /**
780 * Constant: HSymbol "MatrixPow" (function-header)
781 */
782 public final static HSymbol MatrixPow = new HSymbol("MatrixPow",
783 C.loadClass);
784
785 /**
786 * Constant: HSymbol "Max" (function-header)
787 */
788 public final static HSymbol Max = new HSymbol("Max", C.loadClass);
789
790 /**
791 * Constant: HSymbol "Min" (function-header)
792 */
793 public final static HSymbol Min = new HSymbol("Min", C.loadClass);
794
795 /**
796 * Constant: HSymbol "Null" symbol for "no evaluation result"
797 */
798 public final static HSymbol Null = new HSymbol("Null");
799
800 /**
801 * Constant: HSymbol "Expression"
802 *
803 *@see HString.head()
804 */
805 public final static HSymbol Expression = new HSymbol("Expression");
806
807 /**
808 * Constant: HSymbol "Pattern"
809 *
810 *@see HPattern.head()
811 */
812 public final static HSymbol Pattern = new HSymbol("Pattern");
813
814 /**
815 * Mathematical constant: HSymbol "Pi"
816 *
817 *@see C.E
818 *@see C.CI
819 */
820 public final static HSymbol Pi = new HSymbol("Pi",
821 new ConstantNumericEvaluator(new HDouble(Math.PI)));
822
823 /**
824 * Constant: HSymbol "String"
825 *
826 *@see HString.head()
827 */
828 public final static HSymbol String = new HSymbol("String");
829
830 /**
831 * Constant: HSymbol "Symbol"
832 *
833 *@see HSymbol.head()
834 */
835 public final static HSymbol Symbol = new HSymbol("Symbol");
836
837 /**
838 * Constant: HSymbol "True" (boolean value)
839 *
840 *@see C.False
841 */
842 public final static HSymbol True = new HSymbol("True");
843
844 /**
845 * Constant: HSymbol "Break" (function for flow-control)
846 */
847 public final static HSymbol Break = new HSymbol("Break",
848 C.loadClass);
849
850 /**
851 * Constant: HSymbol "Continue" (function for flow-control)
852 */
853 public final static HSymbol Continue = new HSymbol("Continue",
854 C.loadClass);
855
856 /**
857 * Constant: HSymbol "Catch" (function for flow-control)
858 */
859 public final static HSymbol Catch = new HSymbol("Catch",
860 C.loadClass);
861
862 /**
863 * Constant: HSymbol "Check" (function for flow-control in pattern-matching)
864 */
865 public final static HSymbol Check = new HSymbol("Check");
866
867 /**
868 * Constant: HSymbol "Exec" (function-header)
869 */
870 public final static HSymbol Exec = new HSymbol("Exec",
871 C.loadClass);
872
873 /**
874 * Constant: HSymbol "If" (function for flow-control)
875 */
876 public final static HSymbol If = new HSymbol("If", C.loadClass);
877
878 /**
879 * Constant: HSymbol "FixedPoint" (function for flow-control)
880 */
881 public final static HSymbol FixedPoint = new HSymbol("FixedPoint",
882 C.loadClass);
883
884 /**
885 * Constant: HSymbol "For" (function for flow-control)
886 */
887 public final static HSymbol For = new HSymbol("For", C.loadClass);
888
889 /**
890 * Constant: HSymbol "Function"
891 */
892 public final static HSymbol Function = new HSymbol("Function");
893
894 /**
895 * Constant: HSymbol "Hold" (function for flow-control)
896 */
897 public final static HSymbol Hold = new HSymbol("Hold");
898
899 /**
900 * Description of the Field
901 */
902 public final static HSymbol HoldForm = new HSymbol("HoldForm");
903
904 /**
905 * Constant: HSymbol "PureFunction" (function-header)
906 */
907 public final static HSymbol PureFunction = new HSymbol("PureFunction");
908
909 /**
910 * Constant: HSymbol "Slot" (function-header)
911 */
912 public final static HSymbol Slot = new HSymbol("Slot");
913
914 /**
915 * Constant: HSymbol "Level" (function-header)
916 */
917 public final static HSymbol Level = new HSymbol("Level",
918 C.loadClass);
919
920 /**
921 * Constant: HSymbol "LoadClass" (function-header)
922 */
923 public final static HSymbol LoadClassLibrary = new HSymbol("LoadClassLibrary",
924 new ELoadClassLibrary());
925
926 /**
927 * Constant: HSymbol "Nest" (function-header)
928 */
929 public final static HSymbol Nest = new HSymbol("Nest",
930 C.loadClass);
931
932 /**
933 * Constant: HSymbol "Part" (function-header)
934 */
935 public final static HSymbol Part = new HSymbol("Part",
936 C.loadClass);
937
938 // final static public HSymbol PowFun = new HSymbol("PowFun", new EPowFun());
939
940 /**
941 * Constant: HSymbol "ReplaceAll" (function-header)
942 */
943 public final static HSymbol ReplaceAll = new HSymbol("ReplaceAll");
944
945 /**
946 * Constant: HSymbol "Return" (function for flow-control)
947 *
948 *@see EReturn
949 *@see HReturnException
950 */
951 public final static HSymbol Return = new HSymbol("Return",
952 C.loadClass);
953
954 /**
955 * Constant: HSymbol "Rule" (function-header)
956 */
957 public final static HSymbol Rule = new HSymbol("Rule",
958 C.loadClass);
959
960 /**
961 * Constant: HSymbol "RuleDelayed" (function-header)
962 */
963 public final static HSymbol RuleDelayed =
964 new HSymbol("RuleDelayed", C.loadClass);
965
966 /**
967 * Constant: HSymbol "Set" (function-header)
968 */
969 public final static HSymbol Set = new HSymbol("Set");
970 /**
971 * Constant: HSymbol "SetDelayed" (function-header)
972 */
973 public final static HSymbol SetDelayed = new HSymbol("SetDelayed");
974
975 /**
976 * Constant: HSymbol "Sort" (function-header)
977 */
978 public final static HSymbol Sort = new HSymbol("Sort",
979 C.loadClass);
980
981 /**
982 * Constant: HSymbol "Statement" (function-header)
983 */
984 public final static HSymbol Statement = new HSymbol("Statement");
985
986 /**
987 * Constant: HSymbol "Switch" (function for flow-control)
988 */
989 public final static HSymbol Switch = new HSymbol("Switch",
990 C.loadClass);
991
992 /**
993 * Constant: HSymbol "Throw" (function for flow-control)
994 */
995 public final static HSymbol Throw = new HSymbol("Throw",
996 C.loadClass);
997
998 /**
999 * Constant: HSymbol "TimeConstrained"
1000 *
1001 *@see ETimeConstrained
1002 */
1003 public final static HSymbol TimeConstrained = new HSymbol("TimeConstrained", C.loadClass);
1004
1005 /**
1006 * Description of the Field
1007 */
1008 public final static HSymbol Interrupted = new HSymbol("$Interrupted");
1009
1010 /**
1011 * Constant: HSymbol "Timing"
1012 */
1013 public final static HSymbol Timing = new HSymbol("Timing",
1014 C.loadClass);
1015
1016 /**
1017 * Constant: HSymbol "Together" (function-header)
1018 */
1019 public final static HSymbol Together = new HSymbol("Together",
1020 C.loadClass);
1021
1022 /**
1023 * Constant: HSymbol "Trace" (function-header)
1024 */
1025 public final static HSymbol Trace = new HSymbol("Trace",
1026 C.loadClass);
1027
1028 /**
1029 * Constant: HSymbol "TraceRule" (function-header)
1030 */
1031 //final static public HSymbol TraceRule = new HSymbol("TraceRule");
1032
1033 /**
1034 * Constant: HSymbol "TraceRule" (function-header)
1035 *
1036 * Constant: HSymbol "TraceRule" (function-header) Constant: HSymbol
1037 * "TraceRule" (function-header) Constant: HSymbol "TraceRule"
1038 * (function-header) Constant: HSymbol "TraceRule" (function-header) Constant:
1039 * HSymbol "TraceRule" (function-header) Constant: HSymbol "UpSet"
1040 * (function-header)
1041 *
1042 */
1043 public final static HSymbol UpSet = new HSymbol("UpSet");
1044
1045 /**
1046 * Constant: HSymbol "UpSetDelayed" (function-header)
1047 */
1048 public final static HSymbol UpSetDelayed =
1049 new HSymbol("UpSetDelayed");
1050
1051 /**
1052 * Constant: HSymbol "While" (function for flow-control)
1053 *
1054 *@see EWhile
1055 */
1056 public final static HSymbol While = new HSymbol("While",
1057 C.loadClass);
1058
1059 /**
1060 * Constant: HSymbol "ACos" (function-header)
1061 */
1062 public final static HSymbol ACos = new HSymbol("ACos",
1063 C.loadClass);
1064 /**
1065 * Constant: HSymbol "And"
1066 */
1067 public final static HSymbol And = new HSymbol("And");
1068
1069 /**
1070 * Constant: HSymbol "ASin" (function-header)
1071 */
1072 public final static HSymbol ASin = new HSymbol("ASin",
1073 C.loadClass);
1074
1075 /**
1076 * Constant: HSymbol "ATan" (function-header)
1077 */
1078 public final static HSymbol ATan = new HSymbol("ATan",
1079 C.loadClass);
1080
1081 /**
1082 * Constant: HSymbol "Append" (function-header)
1083 */
1084 public final static HSymbol Append = new HSymbol("Append",
1085 C.loadClass);
1086
1087 /**
1088 * Constant: HSymbol "AppendTo" (function-header)
1089 */
1090 public final static HSymbol AppendTo = new HSymbol("AppendTo",
1091 C.loadClass);
1092
1093 /**
1094 * Constant: HSymbol "Apply" (function-header)
1095 */
1096 public final static HSymbol Apply = new HSymbol("Apply",
1097 C.loadClass);
1098
1099 /**
1100 * Constant: HSymbol "Array" (function-header)
1101 */
1102 public final static HSymbol Array = new HSymbol("Array",
1103 C.loadClass);
1104
1105 /**
1106 * Constant: HSymbol "Block" (function-header)
1107 */
1108 public final static HSymbol Block = new HSymbol("Block",
1109 C.loadClass);
1110 /**
1111 * Constant: HSymbol "Cos"
1112 */
1113 public final static HSymbol Cos = new HSymbol("Cos", C.loadClass);
1114
1115 /**
1116 * Constant: HSymbol "Cosh" (function-header)
1117 */
1118 public final static HSymbol Cosh = new HSymbol("Cosh",
1119 C.loadClass);
1120
1121 /**
1122 * Constant: HSymbol "ACosh" (function-header)
1123 */
1124 public final static HSymbol ACosh = new HSymbol("ACosh",
1125 C.loadClass);
1126
1127 /**
1128 * Description of the Field
1129 */
1130 public final static HSymbol Cot = new HSymbol("Cot", C.loadClass);
1131 /**
1132 * Description of the Field
1133 */
1134 public final static HSymbol Coth = new HSymbol("Coth",
1135 C.loadClass);
1136 /**
1137 * Description of the Field
1138 */
1139 public final static HSymbol ACot = new HSymbol("ACot",
1140 C.loadClass);
1141 /**
1142 * Description of the Field
1143 */
1144 public final static HSymbol ACoth = new HSymbol("ACoth",
1145 C.loadClass);
1146 // final static public HSymbol Cot = new HSymbol("Cot");
1147
1148 /**
1149 * Constant: HSymbol "Complement" (function-header)
1150 */
1151 // final static public HSymbol Complement =
1152 // new HSymbol("Complement");
1153
1154 /**
1155 * Constant: HSymbol "Complement" (function-header)
1156 *
1157 * Constant: HSymbol "Complement" (function-header) Constant: HSymbol
1158 * "Complement" (function-header) Constant: HSymbol "Complement"
1159 * (function-header) Constant: HSymbol "Complement" (function-header)
1160 * Constant: HSymbol "Complement" (function-header) Constant: HSymbol "Delete"
1161 * (function-header)
1162 *
1163 */
1164 public final static HSymbol Delete = new HSymbol("Delete",
1165 C.loadClass);
1166
1167 /**
1168 * Constant: HSymbol "Depth" (function-header)
1169 */
1170 public final static HSymbol Depth = new HSymbol("Depth",
1171 C.loadClass);
1172
1173 /**
1174 * Constant: HSymbol "Do" (function-header)
1175 */
1176 public final static HSymbol Do = new HSymbol("Do", C.loadClass);
1177 /**
1178 * Constant: HSymbol "Exp" (function-header)
1179 */
1180 public final static HSymbol Exp = new HSymbol("Exp", C.loadClass);
1181
1182 /**
1183 * Constant: HSymbol "First" (function-header)
1184 */
1185 public final static HSymbol First = new HSymbol("First",
1186 C.loadClass);
1187
1188 /**
1189 * Constant: HSymbol "Head" (function-header)
1190 */
1191 public final static HSymbol Head = new HSymbol("Head",
1192 C.loadClass);
1193
1194 /**
1195 * Constant: HSymbol "Insert" (function-header)
1196 */
1197 public final static HSymbol Insert = new HSymbol("Insert",
1198 C.loadClass);
1199
1200 /**
1201 * Constant: HSymbol "Intersection" (function-header)
1202 */
1203 //final static public HSymbol Intersection =
1204 // new HSymbol("Intersection");
1205
1206 /**
1207 * Constant: HSymbol "Intersection" (function-header)
1208 *
1209 * Constant: HSymbol "Intersection" (function-header) Constant: HSymbol
1210 * "Intersection" (function-header) Constant: HSymbol "Intersection"
1211 * (function-header) Constant: HSymbol "Intersection" (function-header)
1212 * Constant: HSymbol "Intersection" (function-header) Constant: HSymbol
1213 * "Inverse" (function-header)
1214 *
1215 */
1216 public final static HSymbol Inverse = new HSymbol("Inverse",
1217 C.loadClass);
1218
1219 /**
1220 * Description of the Field
1221 */
1222 public final static HSymbol CrossProduct = new HSymbol("CrossProduct",
1223 C.loadClass);
1224 /**
1225 * Description of the Field
1226 */
1227 public final static HSymbol Det = new HSymbol("Det", C.loadClass);
1228 /**
1229 * Description of the Field
1230 */
1231 public final static HSymbol Spur = new HSymbol("Spur", C.loadClass);
1232 /**
1233 * Description of the Field
1234 */
1235 public final static HSymbol Transpose = new HSymbol("Transpose",
1236 C.loadClass);
1237
1238 /**
1239 * Constant: HSymbol "Join" (function-header)
1240 */
1241 public final static HSymbol Join = new HSymbol("Join",
1242 C.loadClass);
1243
1244 /**
1245 * Constant: HSymbol "Last" (function-header)
1246 */
1247 public final static HSymbol Last = new HSymbol("Last",
1248 C.loadClass);
1249
1250 /**
1251 * Constant: HSymbol "Not" (function-header)
1252 */
1253 public final static HSymbol Not = new HSymbol("Not");
1254 /**
1255 * Constant: HSymbol "Or" (function-header)
1256 */
1257 public final static HSymbol Or = new HSymbol("Or");
1258
1259 /**
1260 * Constant: HSymbol "KSubsets" (function-header)
1261 */
1262 public final static HSymbol KSubsets = new HSymbol("KSubsets",
1263 C.loadClass);
1264
1265 /**
1266 * Constant: HSymbol "KPartitions" (function-header)
1267 */
1268 public final static HSymbol KPartitions = new HSymbol("KPartitions",
1269 C.loadClass);
1270
1271 /**
1272 * Constant: HSymbol "NumberPartitions" (function-header)
1273 */
1274 public final static HSymbol NumberPartitions = new HSymbol("NumberPartitions", C.loadClass);
1275
1276 /**
1277 * Constant: HSymbol "Partition" (function-header)
1278 */
1279 public final static HSymbol Partition = new HSymbol("Partition",
1280 C.loadClass);
1281
1282 /**
1283 * Constant: HSymbol "Permutations" (function-header)
1284 */
1285 public final static HSymbol Permutations = new HSymbol("Permutations", C.loadClass);
1286
1287 /**
1288 * Constant: HSymbol "Product" (function-header)
1289 */
1290 public final static HSymbol Product = new HSymbol("Product",
1291 C.loadClass);
1292
1293 /**
1294 * Constant: HSymbol "Range" (function-header)
1295 */
1296 public final static HSymbol Range = new HSymbol("Range",
1297 C.loadClass);
1298
1299 /**
1300 * Constant: HSymbol "Rest" (function-header)
1301 */
1302 public final static HSymbol Rest = new HSymbol("Rest",
1303 C.loadClass);
1304
1305 /**
1306 * Constant: HSymbol "Log" (function-header)
1307 */
1308 public final static HSymbol Log = new HSymbol("Log", C.loadClass);
1309
1310 /**
1311 * Constant: HSymbol "Map" (function-header)
1312 */
1313 public final static HSymbol Map = new HSymbol("Map", C.loadClass);
1314
1315 /**
1316 * Constant: HSymbol "Prepend" (function-header)
1317 */
1318 public final static HSymbol Prepend = new HSymbol("Prepend",
1319 C.loadClass);
1320
1321 /**
1322 * Constant: HSymbol "PrependTo" (function-header)
1323 */
1324 public final static HSymbol PrependTo = new HSymbol("PrependTo",
1325 C.loadClass);
1326
1327 /**
1328 * Constant: HSymbol "Sin" (function-header)
1329 */
1330 public final static HSymbol Sin = new HSymbol("Sin", C.loadClass);
1331
1332 /**
1333 * Constant: HSymbol "Sinh" (function-header)
1334 */
1335 public final static HSymbol Sinh = new HSymbol("Sinh",
1336 C.loadClass);
1337
1338 /**
1339 * Constant: HSymbol "ASinh" (function-header)
1340 */
1341 public final static HSymbol ASinh = new HSymbol("ASinh",
1342 C.loadClass);
1343
1344 /**
1345 * Constant: HSymbol "Sum" (function-header)
1346 */
1347 public final static HSymbol Sum = new HSymbol("Sum", C.loadClass);
1348
1349 /**
1350 * Constant: HSymbol "Table" (function-header)
1351 */
1352 public final static HSymbol Table = new HSymbol("Table",
1353 C.loadClass);
1354
1355 /**
1356 * Constant: HSymbol "Tan" (function-header)
1357 */
1358 public final static HSymbol Tan = new HSymbol("Tan", C.loadClass);
1359
1360 /**
1361 * Constant: HSymbol "Tanh" (function-header)
1362 */
1363 public final static HSymbol Tanh = new HSymbol("Tanh",
1364 C.loadClass);
1365
1366 /**
1367 * Constant: HSymbol "ATanh" (function-header)
1368 */
1369 public final static HSymbol ATanh = new HSymbol("ATanh",
1370 C.loadClass);
1371
1372 /**
1373 * Constant: HSymbol "Add" (function-header)
1374 */
1375 public final static HSymbol Add = new HSymbol("Add");
1376
1377 /**
1378 * Constant: HSymbol "AddTo" (function-header)
1379 */
1380 public final static HSymbol AddTo = new HSymbol("AddTo");
1381
1382 /**
1383 * Constant: HSymbol "Equal" (function-header)
1384 */
1385 public final static HSymbol Equal = new HSymbol("Equal");
1386
1387 /**
1388 * Constant: HSymbol "Greater" (function-header)
1389 */
1390 public final static HSymbol Greater = new HSymbol("Greater");
1391
1392 /**
1393 * Constant: HSymbol "GreaterEqual" (function-header)
1394 */
1395 public final static HSymbol GreaterEqual =
1396 new HSymbol("GreaterEqual");
1397
1398 /**
1399 * Constant: HSymbol "IsAtom" (function-header)
1400 */
1401 public final static HSymbol IsAtom = new HSymbol("IsAtom",