# If the number of args is odd then the last arg is the default result.
# Works like a switch statement. Could also be used for piecewise
# functions? TODO should probably be called "switch"?

Eval_test = ->
  orig = p1
  p1 = cdr(p1)
  while (iscons(p1))

    # odd number of parameters means that the
    # last argument becomes the default case
    # i.e. the one without a test.
    if (cdr(p1) == symbol(NIL))
      push(car(p1)); # default case
      Eval()
      return

    checkResult = isZeroLikeOrNonZeroLikeOrUndetermined car(p1)
    if !checkResult?
      # we couldn't determine the result
      # of a test. This means we can't conclude
      # anything about the result of the
      # overall test, so we must bail
      # with the unevalled test
      push orig
      return
    else if checkResult
      # test succesful, we found out output
      push(cadr(p1))
      Eval()
      return
    else
      # test unsuccessful, continue to the
      # next pair of test,value
      p1 = cddr(p1)


  # no test matched and there was no
  # catch-all case, so we return zero.
  push_integer 0

# we test A==B by first subtracting and checking if we symbolically
# get zero. If not, we evaluate to float and check if we get a zero.
# If we get another NUMBER then we know they are different.
# If we get something else, then we don't know and we return the
# unaveluated test, which is the same as saying "maybe".
Eval_testeq = ->
  # first try without simplifyng both sides
  orig = p1
  push(cadr(p1))
  Eval()
  push(caddr(p1))
  Eval()
  subtract()
  subtractionResult = pop()

  # OK so we are doing something tricky here
  # we are using isZeroLikeOrNonZeroLikeOrUndetermined to check if the result
  # is zero or not zero or unknown.
  # isZeroLikeOrNonZeroLikeOrUndetermined has some routines
  # to determine the zero-ness/non-zero-ness or
  # undeterminate-ness of things so we use
  # that here and down below.
  checkResult = isZeroLikeOrNonZeroLikeOrUndetermined subtractionResult
  if checkResult
    push_integer(0)
    return
  else if checkResult? and !checkResult
    push_integer(1)
    return

  # we didn't get a simple numeric result but
  # let's try again after doing
  # a simplification on both sides
  push(cadr(p1))
  Eval()
  simplify()
  push(caddr(p1))
  Eval()
  simplify()
  subtract()
  subtractionResult = pop()

  checkResult = isZeroLikeOrNonZeroLikeOrUndetermined subtractionResult
  if checkResult
    push_integer(0)
    return
  else if checkResult? and !checkResult
    push_integer(1)
    return

  # if we didn't get to a number then we
  # don't know whether the quantities are
  # different so do nothing
  push orig

# Relational operators expect a numeric result for operand difference.

Eval_testge = ->
  orig = p1
  comparison = cmp_args()

  if !comparison?
    push orig
    return

  if ( comparison >= 0)
    push_integer(1)
  else
    push_integer(0)

Eval_testgt = ->
  orig = p1
  comparison = cmp_args()

  if !comparison?
    push orig
    return

  if ( comparison > 0)
    push_integer(1)
  else
    push_integer(0)

Eval_testle = ->
  orig = p1
  comparison = cmp_args()

  if !comparison?
    push orig
    return

  if ( comparison <= 0)
    push_integer(1)
  else
    push_integer(0)

Eval_testlt = ->
  orig = p1
  comparison = cmp_args()

  if !comparison?
    push orig
    return

  if ( comparison < 0)
    push_integer(1)
  else
    push_integer(0)

# not definition
Eval_not = ->
  wholeAndExpression = p1
  checkResult = isZeroLikeOrNonZeroLikeOrUndetermined cadr(p1)
  if !checkResult?
    # inconclusive test on predicate
    push wholeAndExpression
  else if checkResult
    # true -> false
    push_integer(0)
  else
    # false -> true
    push_integer(1)

### and =====================================================================

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

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

General description
-------------------
Logical-and of predicate expressions.

###

# and definition
Eval_and = ->
  wholeAndExpression = p1
  andPredicates = cdr(wholeAndExpression)
  somePredicateUnknown = false
  while (iscons(andPredicates))
    # eval each predicate
    checkResult = isZeroLikeOrNonZeroLikeOrUndetermined car(andPredicates)

    if !checkResult?
      # here we have stuff that is not reconducible to any
      # numeric value (or tensor with numeric values) e.g.
      # 'a+b', so it just means that we just don't know the
      # truth value of this particular predicate.
      # We'll track the fact that we found an unknown
      # predicate and we continue with the other predicates.
      # (note that in case some subsequent predicate will be false,
      # it won't matter that we found some unknowns and
      # the whole test will be immediately zero).
      somePredicateUnknown = true
      andPredicates = cdr(andPredicates)

    else if checkResult
      # found a true, move on to the next predicate
      andPredicates = cdr(andPredicates)

    else if !checkResult
      # found a false, enough to falsify everything and return
      push_integer(0)
      return

    # We checked all the predicates and none of them
    # was false. So they were all either true or unknown.
    # Now, if even just one was unknown, we'll have to call this
    # test as inconclusive and return the whole test expression.
    # If all the predicates were known, then we can conclude
    # that the test returns true.
  if somePredicateUnknown
    push wholeAndExpression
  else
    push_integer(1)

# or definition
Eval_or = ->
  wholeOrExpression = p1
  orPredicates = cdr(wholeOrExpression)
  somePredicateUnknown = false
  while (iscons(orPredicates))
    # eval each predicate
    checkResult = isZeroLikeOrNonZeroLikeOrUndetermined car(orPredicates)

    if !checkResult?
      # here we have stuff that is not reconducible to any
      # numeric value (or tensor with numeric values) e.g.
      # 'a+b', so it just means that we just don't know the
      # truth value of this particular predicate.
      # We'll track the fact that we found an unknown
      # predicate and we continue with the other predicates.
      # (note that in case some subsequent predicate will be false,
      # it won't matter that we found some unknowns and
      # the whole test will be immediately zero).
      somePredicateUnknown = true
      orPredicates = cdr(orPredicates)

    else if checkResult
      # found a true, enough to return true
      push_integer(1)
      return

    else if !checkResult
      # found a false, move on to the next predicate
      orPredicates = cdr(orPredicates)

    # We checked all the predicates and none of them
    # was true. So they were all either false or unknown.
    # Now, if even just one was unknown, we'll have to call this
    # test as inconclusive and return the whole test expression.
    # If all the predicates were known, then we can conclude
    # that the test returns false.
  if somePredicateUnknown
    push wholeOrExpression
  else
    push_integer(0)

# use subtract for cases like A < A + 1

# TODO you could be smarter here and
# simplify both sides only in the case
# of "relational operator: cannot determine..."
# a bit like we do in Eval_testeq
cmp_args = ->
  t = 0

  push(cadr(p1))
  Eval()
  simplify()
  push(caddr(p1))
  Eval()
  simplify()
  subtract()
  p1 = pop()

  # try floating point if necessary

  if (p1.k != NUM && p1.k != DOUBLE)
    push(p1)
    yyfloat()
    Eval()
    p1 = pop()

  #console.log "comparison: " + p1.toString()

  if (isZeroAtomOrTensor(p1))
    #console.log "comparison isZero "
    return 0

  switch (p1.k)
    when NUM
      if (MSIGN(p1.q.a) == -1)
        t = -1
      else
        t = 1
    when DOUBLE
      #console.log "comparison p1.d: " + p1.d
      if (p1.d < 0.0)
        t = -1
      else
        t = 1
    else
      #console.log "comparison is null"
      t = null

  return t