UNPKG

algebrite/runtime/init.coffee

Version:

8.64 kBtext/coffeescriptView Raw

1
2
3init = ->
#debugger
#console.log "DOING AN INIT ========================================================================"
i = 0
flag = 0
8
reset_after_error()
chainOfUserSymbolsNotFunctionsBeingEvaluated = []
11
if (flag)
return		# already initted
14
flag = 1
16
17
# total clearout of symbol table
for i in [0...NSYM]
symtab[i] =  new U()
symtab[i].k = SYM
binding[i] = symtab[i]
isSymbolReclaimable[i] = false
24
defn()
26
27### cross =====================================================================
28
29Tags
30----
31scripting, JS, internal, treenode, general concept, script_defined
32
33Parameters
34----------
35u,v
36
37General description
38-------------------
39Returns the cross product of vectors u and v.
40
41###
42
43### curl =====================================================================
44
45Tags
46----
47scripting, JS, internal, treenode, general concept, script_defined
48
49Parameters
50----------
51u
52
53General description
54-------------------
55Returns the curl of vector u.
56
57###
58
59defn_str = [
"version=\"" + version + "\"",
"e=exp(1)",
"i=sqrt(-1)",
"autoexpand=1",
"assumeRealVariables=1",
"trange=[-pi,pi]",
"xrange=[-10,10]",
"yrange=[-10,10]",
"last=0",
"trace=0",
"printLeaveEAlone=1",
"printLeaveXAlone=0",
# cross definition
"cross(u,v)=[u[2]*v[3]-u[3]*v[2],u[3]*v[1]-u[1]*v[3],u[1]*v[2]-u[2]*v[1]]",
# curl definition
"curl(v)=[d(v[3],y)-d(v[2],z),d(v[1],z)-d(v[3],x),d(v[2],x)-d(v[1],y)]",
# div definition
"div(v)=d(v[1],x)+d(v[2],y)+d(v[3],z)",
# Note that we use the mathematics / Javascript / Mathematica
# convention that "log" is indeed the natural logarithm.
#
# In engineering, biology, astronomy, "log" can stand instead
# for the "common" logarithm i.e. base 10. Also note that Google
# calculations use log for the common logarithm.
"ln(x)=log(x)",
85]
86
87defn = ->
p0 = symbol(NIL)
p1 = symbol(NIL)
p2 = symbol(NIL)
p3 = symbol(NIL)
p4 = symbol(NIL)
p5 = symbol(NIL)
p6 = symbol(NIL)
p7 = symbol(NIL)
p8 = symbol(NIL)
p9 = symbol(NIL)
98
std_symbol("abs", ABS)
std_symbol("add", ADD)
std_symbol("adj", ADJ)
std_symbol("and", AND)
std_symbol("approxratio", APPROXRATIO)
std_symbol("arccos", ARCCOS)
std_symbol("arccosh", ARCCOSH)
std_symbol("arcsin", ARCSIN)
std_symbol("arcsinh", ARCSINH)
std_symbol("arctan", ARCTAN)
std_symbol("arctanh", ARCTANH)
std_symbol("arg", ARG)
std_symbol("atomize", ATOMIZE)
std_symbol("besselj", BESSELJ)
std_symbol("bessely", BESSELY)
std_symbol("binding", BINDING)
std_symbol("binomial", BINOMIAL)
std_symbol("ceiling", CEILING)
std_symbol("check", CHECK)
std_symbol("choose", CHOOSE)
std_symbol("circexp", CIRCEXP)
std_symbol("clear", CLEAR)
std_symbol("clearall", CLEARALL)
std_symbol("clearpatterns", CLEARPATTERNS)
std_symbol("clock", CLOCK)
std_symbol("coeff", COEFF)
std_symbol("cofactor", COFACTOR)
std_symbol("condense", CONDENSE)
std_symbol("conj", CONJ)
std_symbol("contract", CONTRACT)
std_symbol("cos", COS)
std_symbol("cosh", COSH)
std_symbol("decomp", DECOMP)
std_symbol("defint", DEFINT)
std_symbol("deg", DEGREE)
std_symbol("denominator", DENOMINATOR)
std_symbol("det", DET)
std_symbol("derivative", DERIVATIVE)
std_symbol("dim", DIM)
std_symbol("dirac", DIRAC)
std_symbol("divisors", DIVISORS)
std_symbol("do", DO)
std_symbol("dot", DOT)
std_symbol("draw", DRAW)
std_symbol("dsolve", DSOLVE)
std_symbol("erf", ERF)
std_symbol("erfc", ERFC)
std_symbol("eigen", EIGEN)
std_symbol("eigenval", EIGENVAL)
std_symbol("eigenvec", EIGENVEC)
std_symbol("eval", EVAL)
std_symbol("exp", EXP)
std_symbol("expand", EXPAND)
std_symbol("expcos", EXPCOS)
std_symbol("expsin", EXPSIN)
std_symbol("factor", FACTOR)
std_symbol("factorial", FACTORIAL)
std_symbol("factorpoly", FACTORPOLY)
std_symbol("filter", FILTER)
std_symbol("float", FLOATF)
std_symbol("floor", FLOOR)
std_symbol("for", FOR)
std_symbol("function", FUNCTION)
std_symbol("Gamma", GAMMA)
std_symbol("gcd", GCD)
std_symbol("hermite", HERMITE)
std_symbol("hilbert", HILBERT)
std_symbol("imag", IMAG)
std_symbol("component", INDEX)
std_symbol("inner", INNER)
std_symbol("integral", INTEGRAL)
std_symbol("inv", INV)
std_symbol("invg", INVG)
std_symbol("isinteger", ISINTEGER)
std_symbol("isprime", ISPRIME)
std_symbol("laguerre", LAGUERRE)
#	std_symbol("laplace", LAPLACE)
std_symbol("lcm", LCM)
std_symbol("leading", LEADING)
std_symbol("legendre", LEGENDRE)
std_symbol("log", LOG)
std_symbol("lookup", LOOKUP)
std_symbol("mod", MOD)
std_symbol("multiply", MULTIPLY)
std_symbol("not", NOT)
std_symbol("nroots", NROOTS)
std_symbol("number", NUMBER)
std_symbol("numerator", NUMERATOR)
std_symbol("operator", OPERATOR)
std_symbol("or", OR)
std_symbol("outer", OUTER)
std_symbol("pattern", PATTERN)
std_symbol("patternsinfo", PATTERNSINFO)
std_symbol("polar", POLAR)
std_symbol("power", POWER)
std_symbol("prime", PRIME)
std_symbol("print", PRINT)
std_symbol("print2dascii", PRINT2DASCII)
std_symbol("printfull", PRINTFULL)
std_symbol("printlatex", PRINTLATEX)
std_symbol("printlist", PRINTLIST)
std_symbol("printplain", PRINTPLAIN)
std_symbol("printLeaveEAlone", PRINT_LEAVE_E_ALONE)
std_symbol("printLeaveXAlone", PRINT_LEAVE_X_ALONE)
std_symbol("product", PRODUCT)
std_symbol("quote", QUOTE)
std_symbol("quotient", QUOTIENT)
std_symbol("rank", RANK)
std_symbol("rationalize", RATIONALIZE)
std_symbol("real", REAL)
std_symbol("rect", YYRECT)
std_symbol("roots", ROOTS)
std_symbol("round", ROUND)
std_symbol("equals", SETQ)
std_symbol("sgn", SGN)
std_symbol("silentpattern", SILENTPATTERN)
std_symbol("simplify", SIMPLIFY)
std_symbol("sin", SIN)
std_symbol("sinh", SINH)
std_symbol("shape", SHAPE)
std_symbol("sqrt", SQRT)
std_symbol("stop", STOP)
std_symbol("subst", SUBST)
std_symbol("sum", SUM)
std_symbol("symbolsinfo", SYMBOLSINFO)
std_symbol("tan", TAN)
std_symbol("tanh", TANH)
std_symbol("taylor", TAYLOR)
std_symbol("test", TEST)
std_symbol("testeq", TESTEQ)
std_symbol("testge", TESTGE)
std_symbol("testgt", TESTGT)
std_symbol("testle", TESTLE)
std_symbol("testlt", TESTLT)
std_symbol("transpose", TRANSPOSE)
std_symbol("unit", UNIT)
std_symbol("zero", ZERO)
236
std_symbol("nil", NIL)
238
std_symbol("autoexpand", AUTOEXPAND)
std_symbol("bake", BAKE)
std_symbol("assumeRealVariables", ASSUME_REAL_VARIABLES)
242
243
std_symbol("last", LAST)
245
std_symbol("lastprint", LAST_PRINT)
std_symbol("last2dasciiprint", LAST_2DASCII_PRINT)
std_symbol("lastfullprint", LAST_FULL_PRINT)
std_symbol("lastlatexprint", LAST_LATEX_PRINT)
std_symbol("lastlistprint", LAST_LIST_PRINT)
std_symbol("lastplainprint", LAST_PLAIN_PRINT)
252
std_symbol("trace", TRACE)
254
std_symbol("~", YYE)	# tilde so sort puts it after other symbols
256
std_symbol("$DRAWX", DRAWX)	# special purpose internal symbols
std_symbol("$METAA", METAA)
std_symbol("$METAB", METAB)
std_symbol("$METAX", METAX)
std_symbol("$SECRETX", SECRETX)
262
std_symbol("version", VERSION)
264
std_symbol("pi", PI)
std_symbol("a", SYMBOL_A)
std_symbol("b", SYMBOL_B)
std_symbol("c", SYMBOL_C)
std_symbol("d", SYMBOL_D)
std_symbol("i", SYMBOL_I)
std_symbol("j", SYMBOL_J)
std_symbol("n", SYMBOL_N)
std_symbol("r", SYMBOL_R)
std_symbol("s", SYMBOL_S)
std_symbol("t", SYMBOL_T)
std_symbol("x", SYMBOL_X)
std_symbol("y", SYMBOL_Y)
std_symbol("z", SYMBOL_Z)
std_symbol("I", SYMBOL_IDENTITY_MATRIX)
280
std_symbol("a_", SYMBOL_A_UNDERSCORE)
std_symbol("b_", SYMBOL_B_UNDERSCORE)
std_symbol("x_", SYMBOL_X_UNDERSCORE)
284
std_symbol("$C1", C1)
std_symbol("$C2", C2)
std_symbol("$C3", C3)
std_symbol("$C4", C4)
std_symbol("$C5", C5)
std_symbol("$C6", C6)
291
defineSomeHandyConstants()
293
294
# don't add all these functions to the
# symbolsDependencies, clone the original
originalCodeGen = codeGen
codeGen = false
299
for defn_i in [0...defn_str.length]
definitionOfInterest = defn_str[defn_i]
scan(definitionOfInterest)
if DEBUG
	console.log "... evaling " + definitionOfInterest
	console.log("top of stack:")
	console.log print_list(stack[tos-1])
Eval()
pop()
309
# restore the symbol dependencies as they were before.
codeGen = originalCodeGen
312
313defineSomeHandyConstants = ->
push_integer(0)
zero = pop()		# must be untagged in gc
316
push_integer(1)
one = pop()		# must be untagged in gc
319
push_double(1.0)
one_as_double = pop()
322
# i is the square root of -1 i.e. -1 ^ 1/2
push_symbol(POWER)
if DEBUG then console.log print_list(stack[tos-1])
push_integer(-1)
if DEBUG then console.log print_list(stack[tos-1])
push_rational(1, 2)
if DEBUG then console.log print_list(stack[tos-1])
list(3)
if DEBUG then console.log print_list(stack[tos-1])
imaginaryunit = pop()	# must be untagged in gc

1
2
3	`init = ->`
4	`#debugger`
5	`#console.log "DOING AN INIT ========================================================================"`
6	`i = 0`
7	`flag = 0`
8
9	`reset_after_error()`
10	`chainOfUserSymbolsNotFunctionsBeingEvaluated = []`
11
12	`if (flag)`
13	`return # already initted`
14
15	`flag = 1`
16
17
18	`# total clearout of symbol table`
19	`for i in [0...NSYM]`
20	`symtab[i] = new U()`
21	`symtab[i].k = SYM`
22	`binding[i] = symtab[i]`
23	`isSymbolReclaimable[i] = false`
24
25	`defn()`
26
27	`### cross =====================================================================`
28
29	`Tags`
30	`----`
31	`scripting, JS, internal, treenode, general concept, script_defined`
32
33	`Parameters`
34	`----------`
35	`u,v`
36
37	`General description`
38	`-------------------`
39	`Returns the cross product of vectors u and v.`
40
41	`###`
42
43	`### curl =====================================================================`
44
45	`Tags`
46	`----`
47	`scripting, JS, internal, treenode, general concept, script_defined`
48
49	`Parameters`
50	`----------`
51	`u`
52
53	`General description`
54	`-------------------`
55	`Returns the curl of vector u.`
56
57	`###`
58
59	`defn_str = [`
60	`"version=\"" + version + "\"",`
61	`"e=exp(1)",`
62	`"i=sqrt(-1)",`
63	`"autoexpand=1",`
64	`"assumeRealVariables=1",`
65	`"trange=[-pi,pi]",`
66	`"xrange=[-10,10]",`
67	`"yrange=[-10,10]",`
68	`"last=0",`
69	`"trace=0",`
70	`"printLeaveEAlone=1",`
71	`"printLeaveXAlone=0",`
72	`# cross definition`
73	`"cross(u,v)=[u[2]v[3]-u[3]v[2],u[3]v[1]-u[1]v[3],u[1]v[2]-u[2]v[1]]",`
74	`# curl definition`
75	`"curl(v)=[d(v[3],y)-d(v[2],z),d(v[1],z)-d(v[3],x),d(v[2],x)-d(v[1],y)]",`
76	`# div definition`
77	`"div(v)=d(v[1],x)+d(v[2],y)+d(v[3],z)",`
78	`# Note that we use the mathematics / Javascript / Mathematica`
79	`# convention that "log" is indeed the natural logarithm.`
80	`#`
81	`# In engineering, biology, astronomy, "log" can stand instead`
82	`# for the "common" logarithm i.e. base 10. Also note that Google`
83	`# calculations use log for the common logarithm.`
84	`"ln(x)=log(x)",`
85	`]`
86
87	`defn = ->`
88	`p0 = symbol(NIL)`
89	`p1 = symbol(NIL)`
90	`p2 = symbol(NIL)`
91	`p3 = symbol(NIL)`
92	`p4 = symbol(NIL)`
93	`p5 = symbol(NIL)`
94	`p6 = symbol(NIL)`
95	`p7 = symbol(NIL)`
96	`p8 = symbol(NIL)`
97	`p9 = symbol(NIL)`
98
99	`std_symbol("abs", ABS)`
100	`std_symbol("add", ADD)`
101	`std_symbol("adj", ADJ)`
102	`std_symbol("and", AND)`
103	`std_symbol("approxratio", APPROXRATIO)`
104	`std_symbol("arccos", ARCCOS)`
105	`std_symbol("arccosh", ARCCOSH)`
106	`std_symbol("arcsin", ARCSIN)`
107	`std_symbol("arcsinh", ARCSINH)`
108	`std_symbol("arctan", ARCTAN)`
109	`std_symbol("arctanh", ARCTANH)`
110	`std_symbol("arg", ARG)`
111	`std_symbol("atomize", ATOMIZE)`
112	`std_symbol("besselj", BESSELJ)`
113	`std_symbol("bessely", BESSELY)`
114	`std_symbol("binding", BINDING)`
115	`std_symbol("binomial", BINOMIAL)`
116	`std_symbol("ceiling", CEILING)`
117	`std_symbol("check", CHECK)`
118	`std_symbol("choose", CHOOSE)`
119	`std_symbol("circexp", CIRCEXP)`
120	`std_symbol("clear", CLEAR)`
121	`std_symbol("clearall", CLEARALL)`
122	`std_symbol("clearpatterns", CLEARPATTERNS)`
123	`std_symbol("clock", CLOCK)`
124	`std_symbol("coeff", COEFF)`
125	`std_symbol("cofactor", COFACTOR)`
126	`std_symbol("condense", CONDENSE)`
127	`std_symbol("conj", CONJ)`
128	`std_symbol("contract", CONTRACT)`
129	`std_symbol("cos", COS)`
130	`std_symbol("cosh", COSH)`
131	`std_symbol("decomp", DECOMP)`
132	`std_symbol("defint", DEFINT)`
133	`std_symbol("deg", DEGREE)`
134	`std_symbol("denominator", DENOMINATOR)`
135	`std_symbol("det", DET)`
136	`std_symbol("derivative", DERIVATIVE)`
137	`std_symbol("dim", DIM)`
138	`std_symbol("dirac", DIRAC)`
139	`std_symbol("divisors", DIVISORS)`
140	`std_symbol("do", DO)`
141	`std_symbol("dot", DOT)`
142	`std_symbol("draw", DRAW)`
143	`std_symbol("dsolve", DSOLVE)`
144	`std_symbol("erf", ERF)`
145	`std_symbol("erfc", ERFC)`
146	`std_symbol("eigen", EIGEN)`
147	`std_symbol("eigenval", EIGENVAL)`
148	`std_symbol("eigenvec", EIGENVEC)`
149	`std_symbol("eval", EVAL)`
150	`std_symbol("exp", EXP)`
151	`std_symbol("expand", EXPAND)`
152	`std_symbol("expcos", EXPCOS)`
153	`std_symbol("expsin", EXPSIN)`
154	`std_symbol("factor", FACTOR)`
155	`std_symbol("factorial", FACTORIAL)`
156	`std_symbol("factorpoly", FACTORPOLY)`
157	`std_symbol("filter", FILTER)`
158	`std_symbol("float", FLOATF)`
159	`std_symbol("floor", FLOOR)`
160	`std_symbol("for", FOR)`
161	`std_symbol("function", FUNCTION)`
162	`std_symbol("Gamma", GAMMA)`
163	`std_symbol("gcd", GCD)`
164	`std_symbol("hermite", HERMITE)`
165	`std_symbol("hilbert", HILBERT)`
166	`std_symbol("imag", IMAG)`
167	`std_symbol("component", INDEX)`
168	`std_symbol("inner", INNER)`
169	`std_symbol("integral", INTEGRAL)`
170	`std_symbol("inv", INV)`
171	`std_symbol("invg", INVG)`
172	`std_symbol("isinteger", ISINTEGER)`
173	`std_symbol("isprime", ISPRIME)`
174	`std_symbol("laguerre", LAGUERRE)`
175	`# std_symbol("laplace", LAPLACE)`
176	`std_symbol("lcm", LCM)`
177	`std_symbol("leading", LEADING)`
178	`std_symbol("legendre", LEGENDRE)`
179	`std_symbol("log", LOG)`
180	`std_symbol("lookup", LOOKUP)`
181	`std_symbol("mod", MOD)`
182	`std_symbol("multiply", MULTIPLY)`
183	`std_symbol("not", NOT)`
184	`std_symbol("nroots", NROOTS)`
185	`std_symbol("number", NUMBER)`
186	`std_symbol("numerator", NUMERATOR)`
187	`std_symbol("operator", OPERATOR)`
188	`std_symbol("or", OR)`
189	`std_symbol("outer", OUTER)`
190	`std_symbol("pattern", PATTERN)`
191	`std_symbol("patternsinfo", PATTERNSINFO)`
192	`std_symbol("polar", POLAR)`
193	`std_symbol("power", POWER)`
194	`std_symbol("prime", PRIME)`
195	`std_symbol("print", PRINT)`
196	`std_symbol("print2dascii", PRINT2DASCII)`
197	`std_symbol("printfull", PRINTFULL)`
198	`std_symbol("printlatex", PRINTLATEX)`
199	`std_symbol("printlist", PRINTLIST)`
200	`std_symbol("printplain", PRINTPLAIN)`
201	`std_symbol("printLeaveEAlone", PRINT_LEAVE_E_ALONE)`
202	`std_symbol("printLeaveXAlone", PRINT_LEAVE_X_ALONE)`
203	`std_symbol("product", PRODUCT)`
204	`std_symbol("quote", QUOTE)`
205	`std_symbol("quotient", QUOTIENT)`
206	`std_symbol("rank", RANK)`
207	`std_symbol("rationalize", RATIONALIZE)`
208	`std_symbol("real", REAL)`
209	`std_symbol("rect", YYRECT)`
210	`std_symbol("roots", ROOTS)`
211	`std_symbol("round", ROUND)`
212	`std_symbol("equals", SETQ)`
213	`std_symbol("sgn", SGN)`
214	`std_symbol("silentpattern", SILENTPATTERN)`
215	`std_symbol("simplify", SIMPLIFY)`
216	`std_symbol("sin", SIN)`
217	`std_symbol("sinh", SINH)`
218	`std_symbol("shape", SHAPE)`
219	`std_symbol("sqrt", SQRT)`
220	`std_symbol("stop", STOP)`
221	`std_symbol("subst", SUBST)`
222	`std_symbol("sum", SUM)`
223	`std_symbol("symbolsinfo", SYMBOLSINFO)`
224	`std_symbol("tan", TAN)`
225	`std_symbol("tanh", TANH)`
226	`std_symbol("taylor", TAYLOR)`
227	`std_symbol("test", TEST)`
228	`std_symbol("testeq", TESTEQ)`
229	`std_symbol("testge", TESTGE)`
230	`std_symbol("testgt", TESTGT)`
231	`std_symbol("testle", TESTLE)`
232	`std_symbol("testlt", TESTLT)`
233	`std_symbol("transpose", TRANSPOSE)`
234	`std_symbol("unit", UNIT)`
235	`std_symbol("zero", ZERO)`
236
237	`std_symbol("nil", NIL)`
238
239	`std_symbol("autoexpand", AUTOEXPAND)`
240	`std_symbol("bake", BAKE)`
241	`std_symbol("assumeRealVariables", ASSUME_REAL_VARIABLES)`
242
243
244	`std_symbol("last", LAST)`
245
246	`std_symbol("lastprint", LAST_PRINT)`
247	`std_symbol("last2dasciiprint", LAST_2DASCII_PRINT)`
248	`std_symbol("lastfullprint", LAST_FULL_PRINT)`
249	`std_symbol("lastlatexprint", LAST_LATEX_PRINT)`
250	`std_symbol("lastlistprint", LAST_LIST_PRINT)`
251	`std_symbol("lastplainprint", LAST_PLAIN_PRINT)`
252
253	`std_symbol("trace", TRACE)`
254
255	`std_symbol("~", YYE) # tilde so sort puts it after other symbols`
256
257	`std_symbol("$DRAWX", DRAWX) # special purpose internal symbols`
258	`std_symbol("$METAA", METAA)`
259	`std_symbol("$METAB", METAB)`
260	`std_symbol("$METAX", METAX)`
261	`std_symbol("$SECRETX", SECRETX)`
262
263	`std_symbol("version", VERSION)`
264
265	`std_symbol("pi", PI)`
266	`std_symbol("a", SYMBOL_A)`
267	`std_symbol("b", SYMBOL_B)`
268	`std_symbol("c", SYMBOL_C)`
269	`std_symbol("d", SYMBOL_D)`
270	`std_symbol("i", SYMBOL_I)`
271	`std_symbol("j", SYMBOL_J)`
272	`std_symbol("n", SYMBOL_N)`
273	`std_symbol("r", SYMBOL_R)`
274	`std_symbol("s", SYMBOL_S)`
275	`std_symbol("t", SYMBOL_T)`
276	`std_symbol("x", SYMBOL_X)`
277	`std_symbol("y", SYMBOL_Y)`
278	`std_symbol("z", SYMBOL_Z)`
279	`std_symbol("I", SYMBOL_IDENTITY_MATRIX)`
280
281	`std_symbol("a_", SYMBOL_A_UNDERSCORE)`
282	`std_symbol("b_", SYMBOL_B_UNDERSCORE)`
283	`std_symbol("x_", SYMBOL_X_UNDERSCORE)`
284
285	`std_symbol("$C1", C1)`
286	`std_symbol("$C2", C2)`
287	`std_symbol("$C3", C3)`
288	`std_symbol("$C4", C4)`
289	`std_symbol("$C5", C5)`
290	`std_symbol("$C6", C6)`
291
292	`defineSomeHandyConstants()`
293
294
295	`# don't add all these functions to the`
296	`# symbolsDependencies, clone the original`
297	`originalCodeGen = codeGen`
298	`codeGen = false`
299
300	`for defn_i in [0...defn_str.length]`
301	`definitionOfInterest = defn_str[defn_i]`
302	`scan(definitionOfInterest)`
303	`if DEBUG`
304	`console.log "... evaling " + definitionOfInterest`
305	`console.log("top of stack:")`
306	`console.log print_list(stack[tos-1])`
307	`Eval()`
308	`pop()`
309
310	`# restore the symbol dependencies as they were before.`
311	`codeGen = originalCodeGen`
312
313	`defineSomeHandyConstants = ->`
314	`push_integer(0)`
315	`zero = pop() # must be untagged in gc`
316
317	`push_integer(1)`
318	`one = pop() # must be untagged in gc`
319
320	`push_double(1.0)`
321	`one_as_double = pop()`
322
323	`# i is the square root of -1 i.e. -1 ^ 1/2`
324	`push_symbol(POWER)`
325	`if DEBUG then console.log print_list(stack[tos-1])`
326	`push_integer(-1)`
327	`if DEBUG then console.log print_list(stack[tos-1])`
328	`push_rational(1, 2)`
329	`if DEBUG then console.log print_list(stack[tos-1])`
330	`list(3)`
331	`if DEBUG then console.log print_list(stack[tos-1])`
332	`imaginaryunit = pop() # must be untagged in gc`