algebrite/sources/print.coffee

Computer Algebra System in Coffeescript

power_str = "^"
codeGen = false

# this is only invoked when user invokes
# "print" explicitly
Eval_print = ->
  stringsEmittedByUserPrintouts += _print(cdr(p1), printMode)
  push(symbol(NIL));

# this is only invoked when user invokes
# "print2dascii" explicitly
Eval_print2dascii = ->
  stringsEmittedByUserPrintouts +=_print(cdr(p1),PRINTMODE_2DASCII)
  push(symbol(NIL));

# this is only invoked when user invokes
# "printcomputer" explicitly
Eval_printcomputer = ->
  stringsEmittedByUserPrintouts +=_print(cdr(p1),PRINTMODE_COMPUTER)
  push(symbol(NIL));

# this is only invoked when user invokes
# "printlatex" explicitly
Eval_printlatex = ->
  stringsEmittedByUserPrintouts +=_print(cdr(p1),PRINTMODE_LATEX)
  push(symbol(NIL));

# this is only invoked when user invokes
# "printhuman" explicitly
Eval_printhuman = ->
  # test flag needs to be suspended
  # because otherwise "printcomputer" mode
  # will happen.
  original_test_flag = test_flag
  test_flag = 0
  stringsEmittedByUserPrintouts +=_print(cdr(p1),PRINTMODE_HUMAN)
  test_flag = original_test_flag
  push(symbol(NIL));

# this is only invoked when user invokes
# "printlist" explicitly
Eval_printlist = ->  
  beenPrinted = _print(cdr(p1),PRINTMODE_LIST)
  stringsEmittedByUserPrintouts += beenPrinted
  push(symbol(NIL))  


_print = (p, passedPrintMode) ->
  accumulator = ""

  while (iscons(p))

    push(car(p));
    Eval();
    p2 = pop();

    # display single symbol as "symbol = result"

    # but don't display "symbol = symbol"

    ###
    if (issymbol(car(p)) && car(p) != p2)
      push_symbol(SETQ);
      push(car(p));
      push(p2);
      list(3);
      p2 = pop();
    ###

    origPrintMode = printMode
    if passedPrintMode == PRINTMODE_COMPUTER
      printMode = PRINTMODE_COMPUTER
      accumulator = printline(p2);
      rememberPrint(accumulator, LAST_FULL_PRINT)
    else if passedPrintMode == PRINTMODE_HUMAN
      printMode = PRINTMODE_HUMAN
      accumulator = printline(p2);
      rememberPrint(accumulator, LAST_PLAIN_PRINT)
    else if passedPrintMode == PRINTMODE_2DASCII
      printMode = PRINTMODE_2DASCII
      accumulator = print2dascii(p2);
      rememberPrint(accumulator, LAST_2DASCII_PRINT)
    else if passedPrintMode == PRINTMODE_LATEX
      printMode = PRINTMODE_LATEX
      accumulator = printline(p2);
      rememberPrint(accumulator, LAST_LATEX_PRINT)
    else if passedPrintMode == PRINTMODE_LIST
      printMode = PRINTMODE_LIST
      accumulator = print_list(p2);
      rememberPrint(accumulator, LAST_LIST_PRINT)
    printMode = origPrintMode


    p = cdr(p);

  if DEBUG then console.log "emttedString from display: " + stringsEmittedByUserPrintouts
  return accumulator

rememberPrint = (theString, theTypeOfPrint) ->
  scan('"' + theString + '"')
  parsedString = pop()
  set_binding(symbol(theTypeOfPrint), parsedString)

print_str = (s) ->
  if DEBUG then console.log "emttedString from print_str: " + stringsEmittedByUserPrintouts
  return s

print_char = (c) ->
  return c

collectLatexStringFromReturnValue = (p) ->
  origPrintMode = printMode
  printMode = PRINTMODE_LATEX
  originalCodeGen = codeGen
  codeGen = false
  returnedString = print_expr(p)
  # some variables might contain underscores, escape those
  returnedString = returnedString.replace(/_/g, "\\_");
  printMode = origPrintMode
  codeGen = originalCodeGen
  if DEBUG then console.log "emttedString from collectLatexStringFromReturnValue: " + stringsEmittedByUserPrintouts
  return returnedString

printline = (p) ->
  accumulator = ""
  accumulator += print_expr(p)
  return accumulator


print_base_of_denom = (p1) ->
  accumulator = ""
  if (isfraction(p1) || car(p1) == symbol(ADD) || car(p1) == symbol(MULTIPLY) || car(p1) == symbol(POWER) || lessp(p1, zero)) # p1 is BASE
      accumulator += print_char('(')
      accumulator += print_expr(p1); # p1 is BASE
      accumulator += print_char(')')
  else
    accumulator += print_expr(p1); # p1 is BASE
  return accumulator

print_expo_of_denom = (p2) ->
  accumulator = ""
  if (isfraction(p2) || car(p2) == symbol(ADD) || car(p2) == symbol(MULTIPLY) || car(p2) == symbol(POWER)) # p2 is EXPO
    accumulator += print_char('(')
    accumulator += print_expr(p2); # p2 is EXPO
    accumulator += print_char(')')
  else
    accumulator += print_expr(p2); # p2 is EXPO
  return accumulator

# prints stuff after the divide symbol "/"

# d is the number of denominators

#define BASE p1
#define EXPO p2

print_denom = (p, d) ->
  accumulator = ""
  save()

  p1 = cadr(p); # p1 is BASE
  p2 = caddr(p); # p2 is EXPO

  # i.e. 1 / (2^(1/3))

  # get the cases like BASE^(-1) out of
  # the way, they just become 1/BASE
  if (isminusone(p2)) # p2 is EXPO
    accumulator += print_base_of_denom p1
    restore()
    return accumulator

  if (d == 1) # p2 is EXPO
    accumulator += print_char('(')

  # prepare the exponent
  # (needs to be negated)
  # before printing it out
  push(p2); # p2 is EXPO
  negate()
  p2 = pop(); # p2 is EXPO
  accumulator += print_power(p1,p2)
  if (d == 1)
    accumulator += print_char(')')
  restore()
  return accumulator


#define A p3
#define B p4

print_a_over_b = (p) ->
  accumulator = ""
  flag = 0
  n = 0
  d = 0

  save()

  # count numerators and denominators

  n = 0
  d = 0

  p1 = cdr(p)
  p2 = car(p1)

  if (isrational(p2))
    push(p2)
    mp_numerator()
    absval()
    p3 = pop(); # p3 is A
    push(p2)
    mp_denominator()
    p4 = pop(); # p4 is B
    if (!isplusone(p3)) # p3 is A
      n++
    if (!isplusone(p4)) # p4 is B
      d++
    p1 = cdr(p1)
  else
    p3 = one; # p3 is A
    p4 = one; # p4 is B

  while (iscons(p1))
    p2 = car(p1)
    if (is_denominator(p2))
      d++
    else
      n++
    p1 = cdr(p1)

  #debugger
  if printMode == PRINTMODE_LATEX
    accumulator += print_str('\\frac{')

  if (n == 0)
    accumulator += print_char('1')
  else
    flag = 0
    p1 = cdr(p)
    if (isrational(car(p1)))
      p1 = cdr(p1)
    if (!isplusone(p3)) # p3 is A
      accumulator += print_factor(p3); # p3 is A
      flag = 1
    while (iscons(p1))
      p2 = car(p1)
      if (is_denominator(p2))
        doNothing = 1
      else
        if (flag)
          accumulator += print_multiply_sign()
        accumulator += print_factor(p2)
        flag = 1
      p1 = cdr(p1)

  if printMode == PRINTMODE_LATEX
    accumulator += print_str('}{')
  else if printMode == PRINTMODE_HUMAN and !test_flag
    accumulator += print_str(" / ")
  else
    accumulator += print_str("/")

  if (d > 1 and printMode != PRINTMODE_LATEX)
    accumulator += print_char('(')


  flag = 0
  p1 = cdr(p)

  if (isrational(car(p1)))
    p1 = cdr(p1)

  if (!isplusone(p4)) # p4 is B
    accumulator += print_factor(p4); # p4 is B
    flag = 1

  while (iscons(p1))
    p2 = car(p1)
    if (is_denominator(p2))
      if (flag)
        accumulator += print_multiply_sign()
      accumulator += print_denom(p2, d)
      flag = 1
    p1 = cdr(p1)

  if (d > 1 and printMode != PRINTMODE_LATEX)
    accumulator += print_char(')')

  if printMode == PRINTMODE_LATEX
    accumulator += print_str('}')

  restore()
  return accumulator


print_expr = (p) ->
  accumulator = ""
  if (isadd(p))
    p = cdr(p)
    if (sign_of_term(car(p)) == '-')
      accumulator += print_str("-")
    accumulator += print_term(car(p))
    p = cdr(p)
    while (iscons(p))
      if (sign_of_term(car(p)) == '+')
        if printMode == PRINTMODE_HUMAN and !test_flag
          accumulator += print_str(" + ")
        else
          accumulator += print_str("+")
      else
        if printMode == PRINTMODE_HUMAN and !test_flag
          accumulator += print_str(" - ")
        else
          accumulator += print_str("-")
      accumulator += print_term(car(p))
      p = cdr(p)
  else
    if (sign_of_term(p) == '-')
      accumulator += print_str("-")
    accumulator += print_term(p)
  return accumulator

sign_of_term = (p) ->
  accumulator = ""
  if (car(p) == symbol(MULTIPLY) && isNumericAtom(cadr(p)) && lessp(cadr(p), zero))
    accumulator += '-'
  else if (isNumericAtom(p) && lessp(p, zero))
    accumulator += '-'
  else
    accumulator += '+'
  return accumulator

print_term = (p) ->
  accumulator = ""
  if (car(p) == symbol(MULTIPLY) && any_denominators(p))
    accumulator += print_a_over_b(p)
    return accumulator

  if (car(p) == symbol(MULTIPLY))
    p = cdr(p)

    # coeff -1?

    if (isminusone(car(p)))
      #      print_char('-')
      p = cdr(p)


    previousFactorWasANumber = false

    # print the first factor ------------
    if isNumericAtom(car(p))
      previousFactorWasANumber = true

    # this numberOneOverSomething thing is so that
    # we show things of the form
    #   numericFractionOfForm1/something * somethingElse
    # as
    #   somethingElse / something
    # so for example 1/2 * sqrt(2) is rendered as
    #   sqrt(2)/2
    # rather than the first form, which looks confusing.
    # NOTE that you might want to avoid this
    # when printing polynomials, as it could be nicer
    # to show the numeric coefficients well separated from
    # the variable, but we'll see when we'll
    # come to it if it's an issue.
    numberOneOverSomething = false
    if printMode == PRINTMODE_LATEX and iscons(cdr(p)) and isNumberOneOverSomething(car(p))
      numberOneOverSomething = true
      denom = car(p).q.b.toString()


    if numberOneOverSomething
      origAccumulator = accumulator
      accumulator = ""
    else
      accumulator += print_factor(car(p))

    p = cdr(p)

    # print all the other factors -------
    while (iscons(p))
      # check if we end up having a case where two numbers
      # are next to each other. In those cases, latex needs
      # to insert a \cdot otherwise they end up
      # right next to each other and read like one big number
      if printMode == PRINTMODE_LATEX
        if previousFactorWasANumber
          # if what comes next is a power and the base
          # is a number, then we are in the case
          # of consecutive numbers.
          # Note that sqrt() i.e when exponent is 1/2
          # doesn't count because the radical gives
          # a nice graphical separation already.
          if caar(p) == symbol(POWER)
            if isNumericAtom(car(cdr(car(p))))
              # rule out square root
              if !isfraction(car(cdr(cdr(car(p)))))
                accumulator += " \\cdot "
      accumulator += print_multiply_sign()
      accumulator += print_factor(car(p),false,true)

      previousFactorWasANumber = false
      if isNumericAtom(car(p))
        previousFactorWasANumber = true

      p = cdr(p)

    if numberOneOverSomething
      accumulator = origAccumulator + "\\frac{" + accumulator + "}{" + denom + "}"

  else
    accumulator += print_factor(p)
  return accumulator

print_subexpr = (p) ->
  accumulator = ""
  accumulator += print_char('(')
  accumulator += print_expr(p)
  accumulator += print_char(')')
  return accumulator

print_factorial_function = (p) ->
  accumulator = ""
  p = cadr(p)
  if (isfraction(p) || car(p) == symbol(ADD) || car(p) == symbol(MULTIPLY) || car(p) == symbol(POWER) || car(p) == symbol(FACTORIAL))
    accumulator += print_subexpr(p)
  else
    accumulator += print_expr(p)
  accumulator += print_char('!')
  return accumulator

print_ABS_latex = (p) ->
  accumulator = ""
  accumulator += print_str("\\left |")
  accumulator += print_expr(cadr(p))
  accumulator += print_str(" \\right |")
  return accumulator

print_BINOMIAL_latex = (p) ->
  accumulator = ""
  accumulator += print_str("\\binom{")
  accumulator += print_expr(cadr(p))
  accumulator += print_str("}{")
  accumulator += print_expr(caddr(p))
  accumulator += print_str("} ")
  return accumulator
  
print_DOT_latex = (p) ->
  accumulator = ""
  accumulator += print_expr(cadr(p))
  accumulator += print_str(" \\cdot ")
  accumulator += print_expr(caddr(p))
  return accumulator

print_DOT_codegen = (p) ->
  accumulator = "dot("
  accumulator += print_expr(cadr(p))
  accumulator += ", "
  accumulator += print_expr(caddr(p))
  accumulator += ")"
  return accumulator

print_SIN_codegen = (p) ->
  accumulator = "Math.sin("
  accumulator += print_expr(cadr(p))
  accumulator += ")"
  return accumulator

print_COS_codegen = (p) ->
  accumulator = "Math.cos("
  accumulator += print_expr(cadr(p))
  accumulator += ")"
  return accumulator

print_TAN_codegen = (p) ->
  accumulator = "Math.tan("
  accumulator += print_expr(cadr(p))
  accumulator += ")"
  return accumulator

print_ARCSIN_codegen = (p) ->
  accumulator = "Math.asin("
  accumulator += print_expr(cadr(p))
  accumulator += ")"
  return accumulator

print_ARCCOS_codegen = (p) ->
  accumulator = "Math.acos("
  accumulator += print_expr(cadr(p))
  accumulator += ")"
  return accumulator

print_ARCTAN_codegen = (p) ->
  accumulator = "Math.atan("
  accumulator += print_expr(cadr(p))
  accumulator += ")"
  return accumulator

print_SQRT_latex = (p) ->
  accumulator = ""
  accumulator += print_str("\\sqrt{")
  accumulator += print_expr(cadr(p))
  accumulator += print_str("} ")
  return accumulator
  
print_TRANSPOSE_latex = (p) ->
  accumulator = ""
  accumulator += print_str("{")
  if iscons(cadr(p))
    accumulator += print_str('(')
  accumulator += print_expr(cadr(p))
  if iscons(cadr(p))
    accumulator += print_str(')')
  accumulator += print_str("}")
  accumulator += print_str("^T")
  return accumulator

print_TRANSPOSE_codegen = (p) ->
  accumulator = ""
  accumulator += print_str("transpose(")
  accumulator += print_expr(cadr(p))
  accumulator += print_str(')')
  return accumulator

print_UNIT_codegen = (p) ->
  accumulator = ""
  accumulator += print_str("identity(")
  accumulator += print_expr(cadr(p))
  accumulator += print_str(')')
  return accumulator

print_INV_latex = (p) ->
  accumulator = ""
  accumulator += print_str("{")
  if iscons(cadr(p))
    accumulator += print_str('(')
  accumulator += print_expr(cadr(p))
  if iscons(cadr(p))
    accumulator += print_str(')')
  accumulator += print_str("}")
  accumulator += print_str("^{-1}")
  return accumulator

print_INV_codegen = (p) ->
  accumulator = ""
  accumulator += print_str("inv(")
  accumulator += print_expr(cadr(p))
  accumulator += print_str(')')
  return accumulator

print_DEFINT_latex = (p) ->
  accumulator = ""
  functionBody = car(cdr(p))

  p = cdr(p)
  originalIntegral = p
  numberOfIntegrals = 0

  while iscons(cdr(cdr(p)))
    numberOfIntegrals++
    theIntegral = cdr(cdr(p))

    accumulator += print_str("\\int^{")
    accumulator += print_expr(car(cdr(theIntegral)))
    accumulator += print_str("}_{")
    accumulator += print_expr(car(theIntegral))
    accumulator += print_str("} \\! ")
    p = cdr(theIntegral)

  accumulator += print_expr(functionBody)
  accumulator += print_str(" \\,")
  
  p = originalIntegral

  for i in [1..numberOfIntegrals]
    theVariable = cdr(p)
    accumulator += print_str(" \\mathrm{d} ")
    accumulator += print_expr(car(theVariable))
    if i < numberOfIntegrals
      accumulator += print_str(" \\, ")
    p = cdr(cdr(theVariable))
  return accumulator



print_tensor = (p) ->
  accumulator = ""
  accumulator += print_tensor_inner(p, 0, 0)[1]
  return accumulator

# j scans the dimensions
# k is an increment for all the printed elements
#   since they are all together in sequence in one array
print_tensor_inner = (p, j, k) ->
  accumulator = ""

  accumulator += print_str("[")

  # only the last dimension prints the actual elements
  # e.g. in a matrix, the first dimension contains
  # vectors, not elements, and the second dimension
  # actually contains the elements
  
  # if not the last dimension, we are just printing wrappers
  # and recursing down i.e. we print the next dimension
  if (j < p.tensor.ndim - 1)
    for i in [0...p.tensor.dim[j]]
      [k, retString] = print_tensor_inner(p, j + 1, k)
      accumulator += retString
      # add separator between elements dimensions
      # "above" the inner-most dimension
      if i != p.tensor.dim[j] - 1
        accumulator += print_str(",")
  # if we reached the last dimension, we print the actual
  # elements
  else
    for i in [0...p.tensor.dim[j]]
      accumulator += print_expr(p.tensor.elem[k])
      # add separator between elements in the
      # inner-most dimension
      if i != p.tensor.dim[j] - 1
        accumulator += print_str(",")
      k++

  accumulator += print_str("]")
  return [k, accumulator]

print_tensor_latex = (p) ->
  accumulator = ""
  if p.tensor.ndim <= 2
    accumulator += print_tensor_inner_latex(true, p, 0, 0)[1]
  return accumulator

# firstLevel is needed because printing a matrix
# is not exactly an elegant recursive procedure:
# the vector on the first level prints the latex
# "wrap", while the vectors that make up the
# rows don't. so it's a bit asymmetric and this
# flag helps.
# j scans the dimensions
# k is an increment for all the printed elements
#   since they are all together in sequence in one array
print_tensor_inner_latex = (firstLevel, p, j, k) ->
  accumulator = ""

  # open the outer latex wrap
  if firstLevel
    accumulator += "\\begin{bmatrix} "

  # only the last dimension prints the actual elements
  # e.g. in a matrix, the first dimension contains
  # vectors, not elements, and the second dimension
  # actually contains the elements
  
  # if not the last dimension, we are just printing wrappers
  # and recursing down i.e. we print the next dimension
  if (j < p.tensor.ndim - 1)
    for i in [0...p.tensor.dim[j]]
      [k, retString] = print_tensor_inner_latex(0, p, j + 1, k)
      accumulator += retString
      if i != p.tensor.dim[j] - 1
        # add separator between rows
        accumulator += print_str(" \\\\ ")
  # if we reached the last dimension, we print the actual
  # elements
  else
    for i in [0...p.tensor.dim[j]]
      accumulator += print_expr(p.tensor.elem[k])
      # separator between elements in each row
      if i != p.tensor.dim[j] - 1
        accumulator += print_str(" & ")
      k++


  # close the outer latex wrap
  if firstLevel
    accumulator += " \\end{bmatrix}"

  return [k, accumulator]

print_SUM_latex = (p) ->
  accumulator = "\\sum_{"
  accumulator += print_expr(caddr(p))
  accumulator += "="
  accumulator += print_expr(cadddr(p))
  accumulator += "}^{"
  accumulator += print_expr(caddddr(p))
  accumulator += "}{"
  accumulator += print_expr(cadr(p))
  accumulator += "}"
  return accumulator

print_SUM_codegen = (p) ->

  body =  cadr(p)
  variable = caddr(p)
  lowerlimit = cadddr(p)
  upperlimit = caddddr(p)

  accumulator =
    "(function(){" +
    " var " + variable + "; " +
    " var holderSum = 0; " +
    " var lowerlimit = " + print_expr(lowerlimit) + "; " +
    " var upperlimit = " + print_expr(upperlimit) + "; " +
    " for (" + variable + " = lowerlimit; " + variable + " < upperlimit; " + variable + "++) { " +
    "   holderSum += " + print_expr(body) + ";" +
    " } "+
    " return holderSum;" +
    "})()"

  return accumulator

print_TEST_latex = (p) ->
  accumulator = "\\left\\{ \\begin{array}{ll}"

  p = cdr(p)
  while (iscons(p))

    # odd number of parameters means that the
    # last argument becomes the default case
    # i.e. the one without a test.
    if (cdr(p) == symbol(NIL))
      accumulator += "{"
      accumulator += print_expr(car(p))
      accumulator += "} & otherwise "
      accumulator += " \\\\\\\\"
      break

    accumulator += "{"
    accumulator += print_expr(cadr(p))
    accumulator += "} & if & "
    accumulator += print_expr(car(p))
    accumulator += " \\\\\\\\"

    # test unsuccessful, continue to the
    # next pair of test,value
    p = cddr(p)
  accumulator = accumulator.substring(0, accumulator.length - 4);
  accumulator += "\\end{array} \\right."

print_TEST_codegen = (p) ->

  accumulator = "(function(){"

  p = cdr(p)
  howManyIfs = 0
  while (iscons(p))

    # odd number of parameters means that the
    # last argument becomes the default case
    # i.e. the one without a test.
    if (cdr(p) == symbol(NIL))
      accumulator += "else {"
      accumulator += "return (" + print_expr(car(p)) + ");"
      accumulator += "}"
      break

    if howManyIfs
      accumulator += " else "

    accumulator += "if (" + print_expr(car(p)) + "){"
    accumulator += "return (" + print_expr(cadr(p)) + ");"
    accumulator += "}"

    # test unsuccessful, continue to the
    # next pair of test,value
    howManyIfs++
    p = cddr(p)

  accumulator += "})()"

  return accumulator


print_TESTLT_latex = (p) ->
  accumulator = "{"
  accumulator += print_expr(cadr(p))
  accumulator += "}"
  accumulator += " < "
  accumulator += "{"
  accumulator += print_expr(caddr(p))
  accumulator += "}"

print_TESTLE_latex = (p) ->
  accumulator = "{"
  accumulator += print_expr(cadr(p))
  accumulator += "}"
  accumulator += " \\leq "
  accumulator += "{"
  accumulator += print_expr(caddr(p))
  accumulator += "}"

print_TESTGT_latex = (p) ->
  accumulator = "{"
  accumulator += print_expr(cadr(p))
  accumulator += "}"
  accumulator += " > "
  accumulator += "{"
  accumulator += print_expr(caddr(p))
  accumulator += "}"

print_TESTGE_latex = (p) ->
  accumulator = "{"
  accumulator += print_expr(cadr(p))
  accumulator += "}"
  accumulator += " \\geq "
  accumulator += "{"
  accumulator += print_expr(caddr(p))
  accumulator += "}"

print_TESTEQ_latex = (p) ->
  accumulator = "{"
  accumulator += print_expr(cadr(p))
  accumulator += "}"
  accumulator += " = "
  accumulator += "{"
  accumulator += print_expr(caddr(p))
  accumulator += "}"

print_FOR_codegen = (p) ->
  body =  cadr(p)
  variable = caddr(p)
  lowerlimit = cadddr(p)
  upperlimit = caddddr(p)

  accumulator =
    "(function(){" +
    " var " + variable + "; " +
    " var lowerlimit = " + print_expr(lowerlimit) + "; " +
    " var upperlimit = " + print_expr(upperlimit) + "; " +
    " for (" + variable + " = lowerlimit; " + variable + " < upperlimit; " + variable + "++) { " +
    "   " + print_expr(body) +
    " } "+
    "})()"

  return accumulator

print_DO_codegen = (p) ->
  accumulator = ""

  p = cdr(p)
  while iscons(p)
    accumulator += print_expr(car(p))
    p = cdr(p)

  return accumulator

print_SETQ_codegen = (p) ->
  accumulator = ""
  accumulator += print_expr(cadr(p))
  accumulator += " = "
  accumulator += print_expr(caddr(p))
  accumulator += "; "
  return accumulator
  

print_PRODUCT_latex = (p) ->
  accumulator = "\\prod_{"
  accumulator += print_expr(caddr(p))
  accumulator += "="
  accumulator += print_expr(cadddr(p))
  accumulator += "}^{"
  accumulator += print_expr(caddddr(p))
  accumulator += "}{"
  accumulator += print_expr(cadr(p))
  accumulator += "}"
  return accumulator

print_PRODUCT_codegen = (p) ->

  body =  cadr(p)
  variable = caddr(p)
  lowerlimit = cadddr(p)
  upperlimit = caddddr(p)

  accumulator =
    "(function(){" +
    " var " + variable + "; " +
    " var holderProduct = 1; " +
    " var lowerlimit = " + print_expr(lowerlimit) + "; " +
    " var upperlimit = " + print_expr(upperlimit) + "; " +
    " for (" + variable + " = lowerlimit; " + variable + " < upperlimit; " + variable + "++) { " +
    "   holderProduct *= " + print_expr(body) + ";" +
    " } "+
    " return holderProduct;" +
    "})()"

  return accumulator


print_base = (p) ->
  accumulator = ""
  if (isadd(cadr(p)) || caadr(p) == symbol(MULTIPLY) || caadr(p) == symbol(POWER) || isnegativenumber(cadr(p)))
    accumulator += print_str('(')
    accumulator += print_expr(cadr(p))
    accumulator += print_str(')')
  else if (isNumericAtom(cadr(p)) && (lessp(cadr(p), zero) || isfraction(cadr(p))))
    accumulator += print_str('(')
    accumulator += print_factor(cadr(p))
    accumulator += print_str(')')
  else
    accumulator += print_factor(cadr(p))
  return accumulator

print_exponent = (p) ->
  accumulator = ""
  if (iscons(caddr(p)) || isfraction(caddr(p)) || (isNumericAtom(caddr(p)) && lessp(caddr(p), zero)))
    accumulator += print_str('(')
    accumulator += print_expr(caddr(p))
    accumulator += print_str(')')
  else
    accumulator += print_factor(caddr(p))
  return accumulator

print_power = (base, exponent) ->
  accumulator = ""

  #debugger
  if DEBUG then console.log "power base: " + base + " " + " exponent: " + exponent

  # quick check is this is actually a square root.
  if isoneovertwo(exponent)
    if equaln(base, 2)
      if codeGen
        accumulator += print_str("Math.SQRT2")
        return accumulator
    else
      if printMode == PRINTMODE_LATEX
        accumulator += print_str("\\sqrt{")
        accumulator += print_expr(base)
        accumulator += print_str("}")
        return accumulator
      else if codeGen
        accumulator += print_str("Math.sqrt(")
        accumulator += print_expr(base)
        accumulator += print_str(')')
        return accumulator


  if ((equaln(get_binding(symbol(PRINT_LEAVE_E_ALONE)), 1)) and base == symbol(E))
    if codeGen
      accumulator += print_str("Math.exp(")
      accumulator += print_expo_of_denom exponent
      accumulator += print_str(')')
      return accumulator

    if printMode == PRINTMODE_LATEX
      accumulator += print_str("e^{")
      accumulator += print_expr(exponent)
      accumulator += print_str("}")
    else
      accumulator += print_str("exp(")
      accumulator += print_expr(exponent)
      accumulator += print_str(')')
    return accumulator

  if codeGen
    accumulator += print_str("Math.pow(")
    accumulator += print_base_of_denom base
    accumulator += print_str(", ")
    accumulator += print_expo_of_denom exponent
    accumulator += print_str(')')
    return accumulator

  
  if ((equaln(get_binding(symbol(PRINT_LEAVE_X_ALONE)), 0)) or base.printname != "x")
    # if the exponent is negative then
    # we invert the base BUT we don't do
    # that if the base is "e", because for
    # example when trigonometric functions are
    # expressed in terms of exponential functions
    # that would be really confusing, one wants to
    # keep "e" as the base and the negative exponent
    if (base != symbol(E))
      if (isminusone(exponent))
        if printMode == PRINTMODE_LATEX
          accumulator += print_str("\\frac{1}{")
        else if printMode == PRINTMODE_HUMAN and !test_flag
          accumulator += print_str("1 / ")
        else
          accumulator += print_str("1/")

        if (iscons(base) and printMode != PRINTMODE_LATEX)
          accumulator += print_str('(')
          accumulator += print_expr(base)
          accumulator += print_str(')')
        else
          accumulator += print_expr(base)

        if printMode == PRINTMODE_LATEX
          accumulator += print_str("}")

        return accumulator

      if (isnegativeterm(exponent))
        if printMode == PRINTMODE_LATEX
          accumulator += print_str("\\frac{1}{")
        else if printMode == PRINTMODE_HUMAN and !test_flag
          accumulator += print_str("1 / ")
        else
          accumulator += print_str("1/")

        push(exponent)
        push_integer(-1)
        multiply()
        newExponent = pop()

        if (iscons(base) and printMode != PRINTMODE_LATEX)
          accumulator += print_str('(')
          accumulator += print_power(base, newExponent)
          accumulator += print_str(')')
        else
          accumulator += print_power(base, newExponent)


        if printMode == PRINTMODE_LATEX
          accumulator += print_str("}")

        return accumulator


    if (isfraction(exponent) and printMode == PRINTMODE_LATEX)
        accumulator += print_str("\\sqrt")
        push(exponent)
        denominator()
        denomExponent = pop()
        # we omit the "2" on the radical
        if !isplustwo(denomExponent)
          accumulator += print_str("[")
          accumulator += print_expr(denomExponent)
          accumulator += print_str("]")
        accumulator += print_str("{")
        push(exponent)
        numerator()
        numExponent = pop()
        exponent = numExponent
        accumulator += print_power(base, exponent)
        accumulator += print_str("}")
        return accumulator

  if printMode == PRINTMODE_LATEX and isplusone(exponent)
    # if we are in latex mode we turn many
    # radicals into a radix sign with a power
    # underneath, and the power is often one
    # (e.g. square root turns into a radical
    # with a power one underneath) so handle
    # this case simply here, just print the base
    accumulator += print_expr(base)
  else
    # print the base,
    # determining if it needs to be
    # wrapped in parentheses or not
    if (isadd(base) || isnegativenumber(base))
      accumulator += print_str('(')
      accumulator += print_expr(base)
      accumulator += print_str(')')
    else if ( car(base) == symbol(MULTIPLY) || car(base) == symbol(POWER))
      if printMode != PRINTMODE_LATEX then accumulator += print_str('(')
      accumulator += print_factor(base, true)
      if printMode != PRINTMODE_LATEX then accumulator += print_str(')')
    else if (isNumericAtom(base) && (lessp(base, zero) || isfraction(base)))
      accumulator += print_str('(')
      accumulator += print_factor(base)
      accumulator += print_str(')')
    else
      accumulator += print_factor(base)

    # print the power symbol
    #debugger
    if printMode == PRINTMODE_HUMAN and !test_flag
      #print_str(" ^ ")
      accumulator += print_str(power_str)
    else
      accumulator += print_str("^")

    # print the exponent
    if printMode == PRINTMODE_LATEX
      # in latex mode, one can omit the curly braces
      # wrapping the exponent if the exponent is only
      # one character long
      if print_expr(exponent).length > 1
        accumulator += print_str("{")
        accumulator += print_expr(exponent)
        accumulator += print_str("}")
      else
        accumulator += print_expr(exponent)
    else if (iscons(exponent) || isfraction(exponent) || (isNumericAtom(exponent) && lessp(exponent, zero)))
      accumulator += print_str('(')
      accumulator += print_expr(exponent)
      accumulator += print_str(')')
    else
      accumulator += print_factor(exponent)
  return accumulator

print_index_function = (p) ->
  accumulator = ""
  p = cdr(p);
  if (caar(p) == symbol(ADD) || caar(p) == symbol(MULTIPLY) || caar(p) == symbol(POWER) || caar(p) == symbol(FACTORIAL))
    accumulator += print_subexpr(car(p));
  else
    accumulator += print_expr(car(p));
  accumulator += print_str('[');
  p = cdr(p);
  if (iscons(p))
    accumulator += print_expr(car(p));
    p = cdr(p);
    while(iscons(p))
      accumulator += print_str(',');
      accumulator += print_expr(car(p));
      p = cdr(p);
  accumulator += print_str(']');
  return accumulator


print_factor = (p, omitParens, pastFirstFactor) ->
  # debugger
  accumulator = ""
  if (isNumericAtom(p))
    # in an evaluated term, all the numeric parts
    # are at the beginning of the term.
    # When printing the EXPRESSION,
    # we peek into the first factor of the term and we
    # look at whether it's a number less then zero.
    # if it is, we print the "-" as the "leading" part of the
    # print of the EXPRESSION, and then we proceed printint the factors
    # of the term. This means that when we come here, we must
    # skip printing the minus if the number is negative,
    # because it's already been printed.
    if pastFirstFactor and lessp(p, zero)
      accumulator += '('
    accumulator += print_number(p, pastFirstFactor)
    if pastFirstFactor and lessp(p, zero)
      accumulator += ')'
    return accumulator

  if (isstr(p))
    accumulator += print_str("\"")
    accumulator += print_str(p.str)
    accumulator += print_str("\"")
    return accumulator

  if (istensor(p))
    if printMode == PRINTMODE_LATEX
      accumulator += print_tensor_latex(p)
    else
      accumulator += print_tensor(p)
    return accumulator

  if (car(p) == symbol(MULTIPLY))
    if !omitParens
      if (sign_of_term(p) == '-' or printMode != PRINTMODE_LATEX)
        if printMode == PRINTMODE_LATEX
          accumulator += print_str(" \\left (")
        else
          accumulator += print_str('(')
    accumulator += print_expr(p)
    if !omitParens
      if (sign_of_term(p) == '-' or printMode != PRINTMODE_LATEX)
        if printMode == PRINTMODE_LATEX
          accumulator += print_str(" \\right ) ")
        else
          accumulator += print_str(')')
    return accumulator
  else if (isadd(p))
    if !omitParens then accumulator += print_str('(')
    accumulator += print_expr(p)
    if !omitParens then accumulator += print_str(')')
    return accumulator

  if (car(p) == symbol(POWER))
    base = cadr(p)
    exponent = caddr(p)
    accumulator += print_power(base, exponent)
    return accumulator

  #  if (car(p) == _list) {
  #    print_str("{")
  #    p = cdr(p)
  #    if (iscons(p)) {
  #      print_expr(car(p))
  #      p = cdr(p)
  #    }
  #    while (iscons(p)) {
  #      print_str(",")
  #      print_expr(car(p))
  #      p = cdr(p)
  #    }
  #    print_str("}")
  #    return
  #  }

  if (car(p) == symbol(FUNCTION))
    fbody = cadr(p)
    
    if !codeGen
      parameters = caddr(p)
      accumulator += print_str "function "
      if DEBUG then console.log "emittedString from print_factor " + stringsEmittedByUserPrintouts
      returned = print_list parameters
      accumulator += returned
      accumulator += print_str " -> "
    accumulator += print_expr fbody
    return accumulator

  if (car(p) == symbol(PATTERN))

    accumulator += print_expr(caadr(p))
    if printMode == PRINTMODE_LATEX
      accumulator += print_str(" \\rightarrow ")
    else
      if printMode == PRINTMODE_HUMAN and !test_flag
        accumulator += print_str(" -> ")
      else
        accumulator += print_str("->")

    accumulator += print_expr car(cdr(cadr(p)))
    return accumulator


  if (car(p) == symbol(INDEX) && issymbol(cadr(p)))
    accumulator += print_index_function(p)
    return accumulator

  if (car(p) == symbol(FACTORIAL))
    accumulator += print_factorial_function(p)
    return accumulator
  else if (car(p) == symbol(ABS) && printMode == PRINTMODE_LATEX)
    accumulator += print_ABS_latex(p)
    return accumulator
  else if (car(p) == symbol(SQRT) && printMode == PRINTMODE_LATEX)
    #debugger
    accumulator += print_SQRT_latex(p)
    return accumulator
  else if car(p) == symbol(TRANSPOSE)
    if printMode == PRINTMODE_LATEX
      accumulator += print_TRANSPOSE_latex(p)
      return accumulator
    else if codeGen
      accumulator += print_TRANSPOSE_codegen(p)
      return accumulator
  else if car(p) == symbol(UNIT)
    if codeGen
      accumulator += print_UNIT_codegen(p)
      return accumulator
  else if car(p) == symbol(INV)
    if printMode == PRINTMODE_LATEX
      accumulator += print_INV_latex(p)
      return accumulator
    else if codeGen
      accumulator += print_INV_codegen(p)
      return accumulator
  else if (car(p) == symbol(BINOMIAL) && printMode == PRINTMODE_LATEX)
    accumulator += print_BINOMIAL_latex(p)
    return accumulator
  else if (car(p) == symbol(DEFINT) && printMode == PRINTMODE_LATEX)
    accumulator += print_DEFINT_latex(p)
    return accumulator
  else if isinnerordot(p)
    if printMode == PRINTMODE_LATEX
      accumulator += print_DOT_latex(p)
      return accumulator
    else if codeGen
      accumulator += print_DOT_codegen(p)
      return accumulator
  else if car(p) == symbol(SIN)
    if codeGen
      accumulator += print_SIN_codegen(p)
      return accumulator
  else if car(p) == symbol(COS)
    if codeGen
      accumulator += print_COS_codegen(p)
      return accumulator
  else if car(p) == symbol(TAN)
    if codeGen
      accumulator += print_TAN_codegen(p)
      return accumulator
  else if car(p) == symbol(ARCSIN)
    if codeGen
      accumulator += print_ARCSIN_codegen(p)
      return accumulator
  else if car(p) == symbol(ARCCOS)
    if codeGen
      accumulator += print_ARCCOS_codegen(p)
      return accumulator
  else if car(p) == symbol(ARCTAN)
    if codeGen
      accumulator += print_ARCTAN_codegen(p)
      return accumulator
  else if car(p) == symbol(SUM)
    if printMode == PRINTMODE_LATEX
      accumulator += print_SUM_latex(p)
      return accumulator
    else if codeGen
      accumulator += print_SUM_codegen(p)
      return accumulator
  #else if car(p) == symbol(QUOTE)
  #  if printMode == PRINTMODE_LATEX
  #    print_expr(cadr(p))
  #    return accumulator
  else if car(p) == symbol(PRODUCT)
    if printMode == PRINTMODE_LATEX
      accumulator += print_PRODUCT_latex(p)
      return accumulator
    else if codeGen
      accumulator += print_PRODUCT_codegen(p)
      return accumulator
  else if car(p) == symbol(FOR)
    if codeGen
      accumulator += print_FOR_codegen(p)
      return accumulator
  else if car(p) == symbol(DO)
    if codeGen
      accumulator += print_DO_codegen(p)
      return accumulator
  else if car(p) == symbol(TEST)
    if codeGen
      accumulator += print_TEST_codegen(p)
      return accumulator
    if printMode == PRINTMODE_LATEX
      accumulator += print_TEST_latex(p)
      return accumulator
  else if car(p) == symbol(TESTLT)
    if codeGen
      accumulator += "(("+print_expr(cadr(p))+") < ("+print_expr(caddr(p))+"))"
      return accumulator
    if printMode == PRINTMODE_LATEX
      accumulator += print_TESTLT_latex(p)
      return accumulator
  else if car(p) == symbol(TESTLE)
    if codeGen
      accumulator += "(("+print_expr(cadr(p))+") <= ("+print_expr(caddr(p))+"))"
      return accumulator
    if printMode == PRINTMODE_LATEX
      accumulator += print_TESTLE_latex(p)
      return accumulator
  else if car(p) == symbol(TESTGT)
    if codeGen
      accumulator += "(("+print_expr(cadr(p))+") > ("+print_expr(caddr(p))+"))"
      return accumulator
    if printMode == PRINTMODE_LATEX
      accumulator += print_TESTGT_latex(p)
      return accumulator
  else if car(p) == symbol(TESTGE)
    if codeGen
      accumulator += "(("+print_expr(cadr(p))+") >= ("+print_expr(caddr(p))+"))"
      return accumulator
    if printMode == PRINTMODE_LATEX
      accumulator += print_TESTGE_latex(p)
      return accumulator
  else if car(p) == symbol(TESTEQ)
    if codeGen
      accumulator += "(("+print_expr(cadr(p))+") === ("+print_expr(caddr(p))+"))"
      return accumulator
    if printMode == PRINTMODE_LATEX
      accumulator += print_TESTEQ_latex(p)
      return accumulator
  else if car(p) == symbol(FLOOR)
    if codeGen
      accumulator += "Math.floor("+print_expr(cadr(p))+")"
      return accumulator
    if printMode == PRINTMODE_LATEX
      accumulator += " \\lfloor {" + print_expr(cadr(p)) + "} \\rfloor "
      return accumulator
  else if car(p) == symbol(CEILING)
    if codeGen
      accumulator += "Math.ceiling("+print_expr(cadr(p))+")"
      return accumulator
    if printMode == PRINTMODE_LATEX
      accumulator += " \\lceil {" + print_expr(cadr(p)) + "} \\rceil "
      return accumulator
  else if car(p) == symbol(ROUND)
    if codeGen
      accumulator += "Math.round("+print_expr(cadr(p))+")"
      return accumulator
  else if car(p) == symbol(SETQ)
    if codeGen
      accumulator += print_SETQ_codegen(p)
      return accumulator
    else
      accumulator += print_expr cadr p
      accumulator += print_str("=")
      accumulator += print_expr caddr p
      return accumulator


  if (iscons(p))
    #if (car(p) == symbol(FORMAL) && cadr(p)->k == SYM) {
    #  print_str(((struct symbol *) cadr(p))->name)
    #  return
    #}
    accumulator += print_factor(car(p))
    p = cdr(p)
    if !omitParens then accumulator += print_str('(')
    if (iscons(p))
      accumulator += print_expr(car(p))
      p = cdr(p)
      while (iscons(p))
        accumulator += print_str(",")
        accumulator += print_expr(car(p))
        p = cdr(p)
    if !omitParens then accumulator += print_str(')')
    return accumulator

  if (p == symbol(DERIVATIVE))
    accumulator += print_char('d')
  else if (p == symbol(E))
    if codeGen
      accumulator += print_str("Math.E")
    else
      accumulator += print_str("e")
  else if (p == symbol(PI))
    if printMode == PRINTMODE_LATEX
      accumulator += print_str("\\pi")
    else
      accumulator += print_str("pi")
  else
    accumulator += print_str(get_printname(p))
  return accumulator


print_list = (p) ->
  accumulator = ""
  switch (p.k)
    when CONS
      accumulator += ('(')
      accumulator += print_list(car(p))
      if p == cdr(p) and p != symbol(NIL)
        console.log "oh no recursive!"
        debugger
      p = cdr(p)
      while (iscons(p))
        accumulator += (" ")
        accumulator += print_list(car(p))
        p = cdr(p)
        if p == cdr(p) and p != symbol(NIL)
          console.log "oh no recursive!"
          debugger
      if (p != symbol(NIL))
        accumulator += (" . ")
        accumulator += print_list(p)
      accumulator += (')')
    when STR
      #print_str("\"")
      accumulator += (p.str)
      #print_str("\"")
    when NUM, DOUBLE
      accumulator += print_number(p, true)
    when SYM
      accumulator += get_printname(p)
    else
      accumulator += ("<tensor>")
  return accumulator

print_multiply_sign = ->
  accumulator = ""
  if printMode == PRINTMODE_LATEX
    if printMode == PRINTMODE_HUMAN and !test_flag
      accumulator += print_str(" ")
    else
      return accumulator

  if printMode == PRINTMODE_HUMAN and !test_flag and !codeGen
    accumulator += print_str(" ")
  else
    accumulator += print_str("*")
  return accumulator

is_denominator = (p) ->
  if (car(p) == symbol(POWER) && cadr(p) != symbol(E) && isnegativeterm(caddr(p)))
    return 1
  else
    return 0

# don't consider the leading fraction
# we want 2/3*a*b*c instead of 2*a*b*c/3

any_denominators = (p) ->
  p = cdr(p)
  #  if (isfraction(car(p)))
  #    return 1
  while (iscons(p))
    q = car(p)
    if (is_denominator(q))
      return 1
    p = cdr(p)
  return 0