eval.coffee

# Evaluate an expression, for example...
#
#	push(p1)
#	Eval()
#	p2 = pop()



Eval = ->
	check_esc_flag()
	save()
	p1 = pop()
	if !p1?
		debugger

	if !evaluatingAsFloats and isfloating(p1)
		willEvaluateAsFloats = true
		evaluatingAsFloats++

	switch (p1.k)
		when CONS
			Eval_cons()
		when NUM
			if evaluatingAsFloats
				push_double(convert_rational_to_double(p1))
			else
				push(p1)
		when DOUBLE, STR
			push(p1)
		when TENSOR
			Eval_tensor()
		when SYM
			Eval_sym()
		else
			stop("atom?")

	if willEvaluateAsFloats
		evaluatingAsFloats--

	restore()

Eval_sym = ->

	# note that function calls are not processed here
	# because, since they have an argument (at least an empty one)
	# they are actually CONs, which is a branch of the
	# switch before the one that calls this function

	# bare keyword?
	# If it's a keyword, then we don't look
	# at the binding array, because keywords
	# are not redefinable. 
	if (iskeyword(p1))
		push(p1)
		push(symbol(LAST))
		list(2)
		Eval()
		return
	else if (p1 == symbol(PI) and evaluatingAsFloats)
		push_double(Math.PI)
		return

	# Evaluate symbol's binding
	p2 = get_binding(p1)
	if DEBUG then console.log "looked up: " + p1 + " which contains: " + p2

	push(p2)


	# differently from standard Lisp,
	# here the evaluation is not
	# one-step only, rather it keeps evaluating
	# "all the way" until a symbol is
	# defined as itself.
	# Uncomment these two lines to get Lisp
	# behaviour (and break most tests)
	if (p1 != p2)

		# detect recursive lookup of symbols, which would otherwise
		# cause a stack overflow.
		# Note that recursive functions will still work because
		# as mentioned at the top, this method doesn't look
		# up and evaluate function calls.
		positionIfSymbolAlreadyBeingEvaluated = chainOfUserSymbolsNotFunctionsBeingEvaluated.indexOf(p1)
		if  positionIfSymbolAlreadyBeingEvaluated != -1
			cycleString = ""
			for i in [positionIfSymbolAlreadyBeingEvaluated...chainOfUserSymbolsNotFunctionsBeingEvaluated.length]
				cycleString += chainOfUserSymbolsNotFunctionsBeingEvaluated[i].printname + " -> "
			cycleString += p1.printname

			stop("recursive evaluation of symbols: " + cycleString)
			return

		chainOfUserSymbolsNotFunctionsBeingEvaluated.push(p1)


		Eval()

		chainOfUserSymbolsNotFunctionsBeingEvaluated.pop()

Eval_cons = ->
	
	cons_head = car(p1)

	# normally the cons_head is a symbol,
	# but sometimes in the case of
	# functions we don't have a symbol,
	# we have to evaluate something to get to the
	# symbol. For example if a function is inside
	# a tensor, then we need to evaluate an index
	# access first to get to the function.
	# In those cases, we find an EVAL here,
	# so we proceed to EVAL
	if car(cons_head) == symbol(EVAL)
		Eval_user_function()
		return

	# If we didn't fall in the EVAL case above
	# then at this point we must have a symbol.
	if (!issymbol(cons_head))
		stop("cons?")

	switch (symnum(cons_head))
		when ABS then Eval_abs()
		when ADD then Eval_add()
		when ADJ then Eval_adj()
		when AND then Eval_and()
		when ARCCOS then Eval_arccos()
		when ARCCOSH then Eval_arccosh()
		when ARCSIN then Eval_arcsin()
		when ARCSINH then Eval_arcsinh()
		when ARCTAN then Eval_arctan()
		when ARCTANH then Eval_arctanh()
		when ARG then Eval_arg()
		when ATOMIZE then Eval_atomize()
		when BESSELJ then Eval_besselj()
		when BESSELY then Eval_bessely()
		when BINDING then Eval_binding()
		when BINOMIAL then Eval_binomial()
		when CEILING then Eval_ceiling()
		when CHECK then Eval_check()
		when CHOOSE then Eval_choose()
		when CIRCEXP then Eval_circexp()
		when CLEAR then Eval_clear()
		when CLEARALL then Eval_clearall()
		when CLEARPATTERNS then Eval_clearpatterns()
		when CLOCK then Eval_clock()
		when COEFF then Eval_coeff()
		when COFACTOR then Eval_cofactor()
		when CONDENSE then Eval_condense()
		when CONJ then Eval_conj()
		when CONTRACT then Eval_contract()
		when COS then Eval_cos()
		when COSH then Eval_cosh()
		when DECOMP then Eval_decomp()
		when DEGREE then Eval_degree()
		when DEFINT then Eval_defint()
		when DENOMINATOR then Eval_denominator()
		when DERIVATIVE then Eval_derivative()
		when DET then Eval_det()
		when DIM then Eval_dim()
		when DIRAC then Eval_dirac()
		when DIVISORS then Eval_divisors()
		when DO then Eval_do()
		when DOT then Eval_inner()
		when DRAW then Eval_draw()
		when DSOLVE then Eval_dsolve()
		when EIGEN then Eval_eigen()
		when EIGENVAL then Eval_eigenval()
		when EIGENVEC then Eval_eigenvec()
		when ERF then Eval_erf()
		when ERFC then Eval_erfc()
		when EVAL then Eval_Eval()
		when EXP then Eval_exp()
		when EXPAND then Eval_expand()
		when EXPCOS then Eval_expcos()
		when EXPSIN then Eval_expsin()
		when FACTOR then Eval_factor()
		when FACTORIAL then Eval_factorial()
		when FACTORPOLY then Eval_factorpoly()
		when FILTER then Eval_filter()
		when FLOATF then Eval_float()
		when APPROXRATIO then Eval_approxratio()
		when FLOOR then Eval_floor()
		when FOR then Eval_for()
		# this is invoked only when we
		# evaluate a function that is NOT being called
		# e.g. when f is a function as we do
		#  g = f
		when FUNCTION then Eval_function_reference()
		when GAMMA then Eval_gamma()
		when GCD then Eval_gcd()
		when HERMITE then Eval_hermite()
		when HILBERT then Eval_hilbert()
		when IMAG then Eval_imag()
		when INDEX then Eval_index()
		when INNER then Eval_inner()
		when INTEGRAL then Eval_integral()
		when INV then Eval_inv()
		when INVG then Eval_invg()
		when ISINTEGER then Eval_isinteger()
		when ISPRIME then Eval_isprime()
		when LAGUERRE then Eval_laguerre()
		#	when LAPLACE then Eval_laplace()
		when LCM then Eval_lcm()
		when LEADING then Eval_leading()
		when LEGENDRE then Eval_legendre()
		when LOG then Eval_log()
		when LOOKUP then Eval_lookup()
		when MOD then Eval_mod()
		when MULTIPLY then Eval_multiply()
		when NOT then Eval_not()
		when NROOTS then Eval_nroots()
		when NUMBER then Eval_number()
		when NUMERATOR then Eval_numerator()
		when OPERATOR then Eval_operator()
		when OR then Eval_or()
		when OUTER then Eval_outer()
		when PATTERN then Eval_pattern()
		when PATTERNSINFO then Eval_patternsinfo()
		when POLAR then Eval_polar()
		when POWER then Eval_power()
		when PRIME then Eval_prime()
		when PRINT then Eval_print()
		when PRINT2DASCII then Eval_print2dascii()
		when PRINTFULL then Eval_printcomputer()
		when PRINTLATEX then Eval_printlatex()
		when PRINTLIST then Eval_printlist()
		when PRINTPLAIN then Eval_printhuman()
		when PRODUCT then Eval_product()
		when QUOTE then Eval_quote()
		when QUOTIENT then Eval_quotient()
		when RANK then Eval_rank()
		when RATIONALIZE then Eval_rationalize()
		when REAL then Eval_real()
		when ROUND then Eval_round()
		when YYRECT then Eval_rect()
		when ROOTS then Eval_roots()
		when SETQ then Eval_setq()
		when SGN then Eval_sgn()
		when SILENTPATTERN then Eval_silentpattern()
		when SIMPLIFY then Eval_simplify()
		when SIN then Eval_sin()
		when SINH then Eval_sinh()
		when SHAPE then Eval_shape()
		when SQRT then Eval_sqrt()
		when STOP then Eval_stop()
		when SUBST then Eval_subst()
		when SUM then Eval_sum()
		when SYMBOLSINFO then Eval_symbolsinfo()
		when TAN then Eval_tan()
		when TANH then Eval_tanh()
		when TAYLOR then Eval_taylor()
		when TEST then Eval_test()
		when TESTEQ then Eval_testeq()
		when TESTGE then Eval_testge()
		when TESTGT then Eval_testgt()
		when TESTLE then Eval_testle()
		when TESTLT then Eval_testlt()
		when TRANSPOSE then Eval_transpose()
		when UNIT then Eval_unit()
		when ZERO then Eval_zero()
		else
			Eval_user_function()

Eval_binding = ->
	push(get_binding(cadr(p1)))

### check =====================================================================

Tags
----
scripting, JS, internal, treenode, general concept

Parameters
----------
p

General description
-------------------
Returns whether the predicate p is true/false or unknown:
0 if false, 1 if true or remains unevaluated if unknown.
Note that if "check" is passed an assignment, it turns it into a test,
i.e. check(a = b) is turned into check(a==b) 
so "a" is not assigned anything.
Like in many programming languages, "check" also gives truthyness/falsyness
for numeric values. In which case, "true" is returned for non-zero values.
Potential improvements: "check" can't evaluate strings yet.

###

Eval_check = ->
	# check the argument
	checkResult = isZeroLikeOrNonZeroLikeOrUndetermined cadr(p1)

	if !checkResult?
		# returned null: unknown result
		# leave the whole check unevalled
		push p1
	else
		# returned 1 or 0
		push_integer(checkResult)


Eval_det = ->
	push(cadr(p1))
	Eval()
	det()


### dim =====================================================================

Tags
----
scripting, JS, internal, treenode, general concept

Parameters
----------
m,n

General description
-------------------
Returns the cardinality of the nth index of tensor "m".

###

Eval_dim = ->
	#int n
	push(cadr(p1))
	Eval()
	p2 = pop()
	if (iscons(cddr(p1)))
		push(caddr(p1))
		Eval()
		n = pop_integer()
	else
		n = 1
	if (!istensor(p2))
		push_integer(1) # dim of scalar is 1
	else if (n < 1 || n > p2.tensor.ndim)
		push(p1)
	else
		push_integer(p2.tensor.dim[n - 1])

Eval_divisors = ->
	push(cadr(p1))
	Eval()
	divisors()

### do =====================================================================

Tags
----
scripting, JS, internal, treenode, general concept

Parameters
----------
a,b,...

General description
-------------------
Evaluates each argument from left to right. Returns the result of the last argument.

###

Eval_do = ->
	push(car(p1))
	p1 = cdr(p1)
	while (iscons(p1))
		pop()
		push(car(p1))
		Eval()
		p1 = cdr(p1)

Eval_dsolve = ->
	push(cadr(p1))
	Eval()
	push(caddr(p1))
	Eval()
	push(cadddr(p1))
	Eval()
	dsolve()

# for example, Eval(f,x,2)

Eval_Eval = ->
	push(cadr(p1))
	Eval()
	p1 = cddr(p1)
	while (iscons(p1))
		push(car(p1))
		Eval()
		push(cadr(p1))
		Eval()
		subst()
		p1 = cddr(p1)
	Eval()

# exp evaluation: it replaces itself with
# a POWER(E,something) node and evals that one
Eval_exp = ->
	push(cadr(p1))
	Eval()
	exponential()

Eval_factorial = ->
	push(cadr(p1))
	Eval()
	factorial()

Eval_factorpoly = ->
	p1 = cdr(p1)
	push(car(p1))
	Eval()
	p1 = cdr(p1)
	push(car(p1))
	Eval()
	factorpoly()
	p1 = cdr(p1)
	while (iscons(p1))
		push(car(p1))
		Eval()
		factorpoly()
		p1 = cdr(p1)

Eval_hermite = ->
	push(cadr(p1))
	Eval()
	push(caddr(p1))
	Eval()
	hermite()

Eval_hilbert = ->
	push(cadr(p1))
	Eval()
	hilbert()

Eval_index = ->
	h = tos
	orig = p1
	
	# look into the head of the list,
	# when evaluated it should be a tensor
	p1 = cdr(p1)
	push car(p1)
	Eval()
	theTensor = stack[tos-1]

	if isNumericAtom(theTensor)
		stop("trying to access a scalar as a tensor")

	if !istensor(theTensor)
		# the tensor is not allocated yet, so
		# leaving the expression unevalled
		moveTos h
		push orig
		return

	# we examined the head of the list which
	# was the tensor, now look into
	# the indexes
	p1 = cdr(p1)
	while (iscons(p1))
		push(car(p1))
		Eval()
		if !isintegerorintegerfloat(stack[tos-1])
			# index with something other than
			# an integer
			moveTos h
			push orig
			return
		p1 = cdr(p1)
	index_function(tos - h)

Eval_inv = ->
	push(cadr(p1))
	Eval()
	inv()

Eval_invg = ->
	push(cadr(p1))
	Eval()
	invg()

Eval_isinteger = ->
	push(cadr(p1))
	Eval()
	p1 = pop()
	if (isrational(p1))
		if (isinteger(p1))
			push(one)
		else
			push(zero)
		return
	if (isdouble(p1))
		n = Math.floor(p1.d)
		if (n == p1.d)
			push(one)
		else
			push(zero)
		return
	push_symbol(ISINTEGER)
	push(p1)
	list(2)

Eval_number = ->
	push(cadr(p1))
	Eval()
	p1 = pop()
	if (p1.k == NUM || p1.k == DOUBLE)
		push_integer(1)
	else
		push_integer(0)

Eval_operator = ->
	h = tos
	push_symbol(OPERATOR)
	p1 = cdr(p1)
	while (iscons(p1))
		push(car(p1))
		Eval()
		p1 = cdr(p1)
	list(tos - h)

# quote definition
Eval_quote = ->
	push(cadr(p1))

# rank definition
Eval_rank = ->
	push(cadr(p1))
	Eval()
	p1 = pop()
	if (istensor(p1))
		push_integer(p1.tensor.ndim)
	else
		push(zero)

# Evaluates the right side and assigns the
# result of the evaluation to the left side.
# It's called setq because it stands for "set quoted" from Lisp,
# see:
#   http://stackoverflow.com/questions/869529/difference-between-set-setq-and-setf-in-common-lisp
# Note that this also takes case of assigning to a tensor
# element, which is something that setq wouldn't do
# in list, see comments further down below.

# Example:
#   f = x
#   // f evaluates to x, so x is assigned to g really
#   // rather than actually f being assigned to g
#   g = f
#   f = y
#   g
#   > x

Eval_setq = ->
	# case of tensor
	if (caadr(p1) == symbol(INDEX))
		setq_indexed()
		return

	# case of function definition
	if (iscons(cadr(p1)))
		define_user_function()
		return

	if (!issymbol(cadr(p1)))
		stop("symbol assignment: error in symbol")

	push(caddr(p1))
	Eval()
	p2 = pop()
	set_binding(cadr(p1), p2)

	# An assignment returns nothing.
	# This is unlike most programming languages
	# where an assignment does return the
	# assigned value.
	# TODO Could be changed.
	push(symbol(NIL))

# Here "setq" is a misnomer because
# setq wouldn't work in Lisp to set array elements
# since setq stands for "set quoted" and you wouldn't
# quote an array element access.
# You'd rather use setf, which is a macro that can
# assign a value to anything.
#   (setf (aref YourArray 2) "blue")
# see
#   http://stackoverflow.com/questions/18062016/common-lisp-how-to-set-an-element-in-a-2d-array
#-----------------------------------------------------------------------------
#
#	Example: a[1] = b
#
#	p1	*-------*-----------------------*
#		|	|			|
#		setq	*-------*-------*	b
#			|	|	|
#			index	a	1
#
#	cadadr(p1) -> a
#
#-----------------------------------------------------------------------------

setq_indexed = ->
	p4 = cadadr(p1)
	console.log "p4: " + p4
	if (!issymbol(p4))
		# this is likely to happen when one tries to
		# do assignments like these
		#   1[2] = 3
		# or
		#   f(x)[1] = 2
		# or
		#   [[1,2],[3,4]][5] = 6
		#
		# In other words, one can only do
		# a straight assignment like
		#   existingMatrix[index] = something
		stop("indexed assignment: expected a symbol name")
	h = tos
	push(caddr(p1))
	Eval()
	p2 = cdadr(p1)
	while (iscons(p2))
		push(car(p2))
		Eval()
		p2 = cdr(p2)
	set_component(tos - h)
	p3 = pop()
	set_binding(p4, p3)
	push(symbol(NIL))


Eval_sqrt = ->
	push(cadr(p1))
	Eval()
	push_rational(1, 2)
	power()

Eval_stop = ->
	stop("user stop")

Eval_subst = ->
	push(cadddr(p1))
	Eval()
	push(caddr(p1))
	Eval()
	push(cadr(p1))
	Eval()
	subst()
	Eval() # normalize

# always returns a matrix with rank 2
# i.e. two dimensions,
# the passed parameter is the size
Eval_unit = ->
	i = 0
	n = 0
	push(cadr(p1))
	Eval()
	n = pop_integer()

	if isNaN(n)
		push(p1)
		return

	if (n < 1)
		push(p1)
		return

	p1 = alloc_tensor(n * n)
	p1.tensor.ndim = 2
	p1.tensor.dim[0] = n
	p1.tensor.dim[1] = n
	for i in [0...n]
		p1.tensor.elem[n * i + i] = one
	check_tensor_dimensions p1
	push(p1)

Eval_noexpand = ->
	prev_expanding = expanding
	expanding = 0
	Eval()
	expanding = prev_expanding

# like Eval() except "=" (assignment) is treated
# as "==" (equality test)
# This is because
#  * this allows users to be lazy and just
#    use "=" instead of "==" as per more common
#    mathematical notation
#  * in many places we don't expect an assignment
#    e.g. we don't expect to test the zero-ness
#    of an assignment or the truth value of
#    an assignment
# Note that these are questionable assumptions
# as for example in most programming languages one
# can indeed test the value of an assignment (the
# value is just the evaluation of the right side)

Eval_predicate = ->
	save()
	p1 = top()
	if (car(p1) == symbol(SETQ))
		# replace the assignment in the
		# head with an equality test
		pop()
		push_symbol(TESTEQ)
		push cadr(p1)
		push caddr(p1)
		list 3

	Eval()
	restore()