/*
Copyright (C) 2014 Michigan State University Board of Trustees
The JavaScript code in this page is free software: you can
redistribute it and/or modify it under the terms of the GNU
General Public License (GNU GPL) as published by the Free Software
Foundation, either version 3 of the License, or (at your option)
any later version. The code is distributed WITHOUT ANY WARRANTY;
without even the implied warranty of MERCHANTABILITY or FITNESS
FOR A PARTICULAR PURPOSE. See the GNU GPL for more details.
As additional permission under GNU GPL version 3 section 7, you
may distribute non-source (e.g., minimized or compacted) forms of
that code without the copy of the GNU GPL normally required by
section 4, provided you include this license notice and a URL
through which recipients can access the Corresponding Source.
*/
"use strict";
/**
* Parsed tree node. ENode.toMathML() contains the code for the transformation into MathML.
* @constructor
* @param {number} type - ENode.UNKNOWN | NAME | NUMBER | OPERATOR | FUNCTION | VECTOR | INTERVAL | SET | SUBSCRIPT
* @param {Operator} op - The operator
* @param {string} value - Node value as a string, null for type VECTOR
* @param {Array.<ENode>} children - The children nodes, only for types OPERATOR, FUNCTION, VECTOR, INTERVAL, SET, SUBSCRIPT
* @param {number} [interval_type] - ENode.NOT_AN_INTERVAL | OPEN_OPEN | OPEN_CLOSED | CLOSED_OPEN | CLOSED_CLOSED
*/
function ENode(type, op, value, children, interval_type) {
this.type = type;
this.op = op;
this.value = value;
this.children = children;
if (typeof interval_type == "undefined")
this.interval_type = ENode.NOT_AN_INTERVAL;
else
this.interval_type = interval_type;
}
ENode.UNKNOWN = 0;
ENode.NAME = 1;
ENode.NUMBER = 2;
ENode.OPERATOR = 3;
ENode.FUNCTION = 4;
ENode.VECTOR = 5;
ENode.INTERVAL = 6;
ENode.SET = 7;
ENode.SUBSCRIPT = 8;
ENode.COLORS = ["#E01010", "#0010FF", "#009000", "#FF00FF", "#00B0B0", "#F09000",
"#800080", "#F080A0", "#6090F0", "#902000", "#70A050", "#A07060",
"#5000FF", "#E06050", "#008080", "#808000"];
ENode.NOT_AN_INTERVAL = 0;
ENode.OPEN_OPEN = 1;
ENode.OPEN_CLOSED = 2;
ENode.CLOSED_OPEN = 3;
ENode.CLOSED_CLOSED = 4;
/**
* Returns the node as a string, for debug
* @returns {string}
*/
ENode.prototype.toString = function() {
var s = '(';
switch (this.type) {
case ENode.UNKNOWN:
s += 'UNKNOWN';
break;
case ENode.NAME:
s += 'NAME';
break;
case ENode.NUMBER:
s += 'NUMBER';
break;
case ENode.OPERATOR:
s += 'OPERATOR';
break;
case ENode.FUNCTION:
s += 'FUNCTION';
break;
case ENode.VECTOR:
s += 'VECTOR';
break;
case ENode.INTERVAL:
s += 'INTERVAL';
break;
case ENode.SET:
s += 'SET';
break;
case ENode.SUBSCRIPT:
s += 'SUBSCRIPT';
break;
}
if (this.op)
s += " '" + this.op.id + "'";
if (this.value)
s += " '" + this.value + "'";
if (this.children) {
s += ' [';
for (var i = 0; i < this.children.length; i++) {
s += this.children[i].toString();
if (i != this.children.length - 1)
s += ',';
}
s += ']';
}
if (this.interval_type) {
s += " " + this.interval_type;
}
s+= ')';
return s;
};
/**
* Returns the color for an identifier.
* @param {string} name
* @param {Object.<string, string>} hcolors - hash identifier->color
* @returns {string}
*/
ENode.prototype.getColorForIdentifier = function(name, context) {
var res = context.hcolors[name];
if (!res) {
var colors;
if (context.colors)
colors = context.colors;
else
colors = ENode.COLORS;
res = colors[Object.keys(context.hcolors).length % colors.length];
context.hcolors[name] = res;
}
return res;
}
/**
* Transforms this ENode into a MathML HTML DOM element.
* @param {Array.<string>} [colors] - optional override for ENode.COLORS
* @returns {Element}
*/
ENode.prototype.toMathML = function(colors) {
var context = { hcolors: {}, depth: 0 , colors: colors};
return(this._toMathML(context));
}
/**
* Transforms this ENode into a MathML HTML DOM element (internal function).
* @param {Object} context - display context
* @param {Object.<string, string>} context.hcolors - hash identifier->color
* @param {number} context.depth - Depth in parenthesis, used for coloring
* @param {Array.<string>} context.colors - optional override for ENode.COLORS
* @returns {Element}
*/
ENode.prototype._toMathML = function(context) {
var c0, c1, c2, c3, c4, i, j, el, par, mrow, mo, mtable, mfrac, msub, msup, mrow2;
if (this.children != null && this.children.length > 0)
c0 = this.children[0];
else
c0 = null;
if (this.children != null && this.children.length > 1)
c1 = this.children[1];
else
c1 = null;
if (this.children != null && this.children.length > 2)
c2 = this.children[2];
else
c2 = null;
if (this.children != null && this.children.length > 3)
c3 = this.children[3];
else
c3 = null;
if (this.children != null && this.children.length > 4)
c4 = this.children[4];
else
c4 = null;
switch (this.type) {
case ENode.UNKNOWN:
el = document.createElement('mtext');
el.appendChild(document.createTextNode("???"));
return(el);
case ENode.NAME:
if (this.value.search(/^[a-zA-Z]+[0-9]+$/) >= 0) {
var ind = this.value.search(/[0-9]/);
msub = document.createElement('msub');
msub.appendChild(this.mi(this.value.substring(0,ind)));
msub.appendChild(this.mn(this.value.substring(ind)));
el = msub;
} else {
el = this.mi(this.value)
}
el.setAttribute("mathcolor", this.getColorForIdentifier(this.value, context));
if (this.value.indexOf('$') === 0)
el.setAttribute("fontfamily", "monospace");
return(el);
case ENode.NUMBER:
if (this.value.indexOf('e') != -1 || this.value.indexOf('E') != -1) {
var index = this.value.indexOf('e');
if (index == -1)
index = this.value.indexOf('E');
mrow = document.createElement('mrow');
mrow.appendChild(this.mn(this.value.substring(0, index)));
mrow.appendChild(this.mo("\u22C5"));
msup = document.createElement('msup');
msup.appendChild(this.mn(10));
msup.appendChild(this.mn(this.value.substring(index + 1)));
mrow.appendChild(msup);
return(mrow);
}
return(this.mn(this.value));
case ENode.OPERATOR:
if (this.value == "/") {
mfrac = document.createElement('mfrac');
mfrac.appendChild(c0._toMathML(context));
mfrac.appendChild(c1._toMathML(context));
el = mfrac;
} else if (this.value == "^") {
if (c0.type == ENode.FUNCTION) {
if (c0.value == "sqrt" || c0.value == "abs" || c0.value == "matrix" ||
c0.value == "diff")
par = false;
else
par = true;
} else if (c0.type == ENode.OPERATOR) {
par = true;
} else
par = false;
el = document.createElement('msup');
if (par)
el.appendChild(this.addP(c0, context));
else
el.appendChild(c0._toMathML(context));
el.appendChild(c1._toMathML(context));
} else if (this.value == "*") {
mrow = document.createElement('mrow');
if (c0.type == ENode.OPERATOR && (c0.value == "+" || c0.value == "-"))
mrow.appendChild(this.addP(c0, context));
else
mrow.appendChild(c0._toMathML(context));
// should the x operator be visible ? We need to check if there is a number to the left of c1
var firstinc1 = c1;
while (firstinc1.type == ENode.OPERATOR) {
firstinc1 = firstinc1.children[0];
}
// ... and if it's an operation between vectors/matrices, the * operator should be displayed
// (it is ambiguous otherwise)
// note: this will not work if the matrix is calculated, for instance with 2[1;2]*[3;4]
if (c0.type == ENode.VECTOR && c1.type == ENode.VECTOR)
mrow.appendChild(this.mo("*"));
else if (firstinc1.type == ENode.NUMBER)
mrow.appendChild(this.mo("\u22C5"));
else if (context.units)
mrow.appendChild(this.mo("\u22C5"));
else
mrow.appendChild(this.mo("\u2062")); // invisible multiplication
if (c1.type == ENode.OPERATOR && (c1.value == "+" || c1.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
el = mrow;
} else if (this.value == "-") {
mrow = document.createElement('mrow');
if (this.children.length == 1) {
mrow.appendChild(this.mo("-"));
mrow.appendChild(c0._toMathML(context));
} else {
mrow.appendChild(c0._toMathML(context));
mrow.appendChild(this.mo("-"));
if (c1.type == ENode.OPERATOR && (c1.value == "+" || c1.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
}
el = mrow;
} else if (this.value == "!") {
mrow = document.createElement('mrow');
mo = this.mo(this.value);
if (c0.type == ENode.OPERATOR && (c0.value == "+" || c0.value == "-"))
mrow.appendChild(this.addP(c0, context));
else
mrow.appendChild(c0._toMathML(context));
mrow.appendChild(mo);
el = mrow;
} else if (this.value == "+") {
mrow = document.createElement('mrow');
mo = this.mo(this.value);
mrow.appendChild(c0._toMathML(context));
mrow.appendChild(mo);
// should we add parenthesis ? We need to check if there is a '-' to the left of c1
par = false;
var first = c1;
while (first.type == ENode.OPERATOR) {
if (first.value == "-" && first.children.length == 1) {
par = true;
break;
} else if (first.value == "+" || first.value == "-" || first.value == "*") {
first = first.children[0];
} else {
break;
}
}
if (par)
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
el = mrow;
} else if (this.value == ".") {
mrow = document.createElement('mrow');
if (c0.type == ENode.OPERATOR && (c0.value == "+" || c0.value == "-"))
mrow.appendChild(this.addP(c0, context));
else
mrow.appendChild(c0._toMathML(context));
mrow.appendChild(this.mo("\u22C5"));
if (c1.type == ENode.OPERATOR && (c1.value == "+" || c1.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
el = mrow;
} else if (this.value == "`") {
mrow = document.createElement('mrow');
if (c0.type == ENode.OPERATOR && (c0.value == "+" || c0.value == "-"))
mrow.appendChild(this.addP(c0, context));
else
mrow.appendChild(c0._toMathML(context));
// the units should not be in italics
// unit multiplication should not be displayed with an invisible operator
var mstyle = document.createElement("mstyle");
mstyle.setAttribute("fontstyle", "normal");
var units_context = {};
for (var prop in context) {
if (context.hasOwnProperty(prop)) {
units_context[prop] = context[prop];
}
}
units_context.units = true;
if (c1.type == ENode.OPERATOR && (c1.value == "+" || c1.value == "-"))
mstyle.appendChild(this.addP(c1, units_context));
else
mstyle.appendChild(c1._toMathML(units_context));
mrow.appendChild(mstyle);
el = mrow;
} else {
// relational operators
mrow = document.createElement('mrow');
mo = this.mo(this.value);
mrow.appendChild(c0._toMathML(context));
mrow.appendChild(mo);
mrow.appendChild(c1._toMathML(context));
el = mrow;
}
return(el);
case ENode.FUNCTION: /* TODO: throw exceptions if wrong nb of args ? */
// c0 contains the function name
if (c0.value == "sqrt" && c1 != null) {
el = document.createElement('msqrt');
el.appendChild(c1._toMathML(context));
} else if (c0.value == "abs" && c1 != null) {
mrow = document.createElement('mrow');
mrow.appendChild(this.mo("|"));
mrow.appendChild(c1._toMathML(context));
mrow.appendChild(this.mo("|"));
el = mrow;
} else if (c0.value == "exp" && c1 != null) {
el = document.createElement('msup');
el.appendChild(this.mi("e"));
el.appendChild(c1._toMathML(context));
} else if (c0.value == "factorial") {
mrow = document.createElement('mrow');
mo = this.mo("!");
if (c1.type == ENode.OPERATOR && (c1.value == "+" || c1.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
mrow.appendChild(mo);
el = mrow;
} else if (c0.value == "diff" && this.children != null && this.children.length == 3) {
mrow = document.createElement('mrow');
mfrac = document.createElement('mfrac');
mfrac.appendChild(this.mi("d"));
var f2 = document.createElement('mrow');
f2.appendChild(this.mi("d"));
f2.appendChild(this.mi(c2.value));
mfrac.appendChild(f2);
mrow.appendChild(mfrac);
if (c1.type == ENode.OPERATOR && (c1.value == "+" || c1.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
el = mrow;
} else if (c0.value == "diff" && this.children != null && this.children.length == 4) {
mrow = document.createElement('mrow');
mfrac = document.createElement('mfrac');
msup = document.createElement('msup');
msup.appendChild(this.mi("d"));
msup.appendChild(c3._toMathML(context));
mfrac.appendChild(msup);
var f2 = document.createElement('mrow');
f2.appendChild(this.mi("d"));
msup = document.createElement('msup');
msup.appendChild(c2._toMathML(context));
msup.appendChild(c3._toMathML(context));
f2.appendChild(msup);
mfrac.appendChild(f2);
mrow.appendChild(mfrac);
if (c1.type == ENode.OPERATOR && (c1.value == "+" || c1.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
el = mrow;
} else if (c0.value == "integrate" && this.children != null && this.children.length == 3) {
mrow = document.createElement('mrow');
var mo = this.mo("\u222B");
mo.setAttribute("stretchy", "true"); // doesn't work with MathJax
mrow.appendChild(mo);
if (c2.type == ENode.OPERATOR && (c2.value == "+" || c2.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
mrow.appendChild(this.mi("d"));
mrow.appendChild(c2._toMathML(context));
el = mrow;
} else if (c0.value == "integrate" && this.children != null && this.children.length == 5) {
mrow = document.createElement('mrow');
var msubsup = document.createElement('msubsup');
var mo = this.mo("\u222B");
mo.setAttribute("stretchy", "true"); // doesn't work with MathJax
msubsup.appendChild(mo);
msubsup.appendChild(c3._toMathML(context));
msubsup.appendChild(c4._toMathML(context));
mrow.appendChild(msubsup);
if (c2.type == ENode.OPERATOR && (c2.value == "+" || c2.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
mrow.appendChild(this.mi("d"));
mrow.appendChild(c2._toMathML(context));
el = mrow;
} else if (c0.value == "sum" && this.children != null && this.children.length == 5) {
mrow = document.createElement('mrow');
var munderover = document.createElement('munderover');
var mo = this.mo("\u2211");
mo.setAttribute("stretchy", "true"); // doesn't work with MathJax
munderover.appendChild(mo);
mrow2 = document.createElement('mrow');
mrow2.appendChild(c2._toMathML(context));
mrow2.appendChild(this.mo("="));
mrow2.appendChild(c3._toMathML(context));
munderover.appendChild(mrow2);
munderover.appendChild(c4._toMathML(context));
mrow.appendChild(munderover);
if (c2.type == ENode.OPERATOR && (c2.value == "+" || c2.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
el = mrow;
} else if (c0.value == "product" && this.children != null && this.children.length == 5) {
mrow = document.createElement('mrow');
var munderover = document.createElement('munderover');
var mo = this.mo("\u220F");
mo.setAttribute("stretchy", "true"); // doesn't work with MathJax
munderover.appendChild(mo);
mrow2 = document.createElement('mrow');
mrow2.appendChild(c2._toMathML(context));
mrow2.appendChild(this.mo("="));
mrow2.appendChild(c3._toMathML(context));
munderover.appendChild(mrow2);
munderover.appendChild(c4._toMathML(context));
mrow.appendChild(munderover);
if (c2.type == ENode.OPERATOR && (c2.value == "+" || c2.value == "-"))
mrow.appendChild(this.addP(c1, context));
else
mrow.appendChild(c1._toMathML(context));
el = mrow;
} else if (c0.value == "limit") {
mrow = document.createElement('mrow');
if (this.children.length < 4) {
mrow.appendChild(this.mo("lim"));
} else {
var munder = document.createElement('munder');
munder.appendChild(this.mo("lim"));
var mrowunder = document.createElement('mrow');
mrowunder.appendChild(c2._toMathML(context));
mrowunder.appendChild(this.mo("\u2192"));
mrowunder.appendChild(c3._toMathML(context));
if (c4 != null) {
if (c4.value == "plus")
mrowunder.appendChild(this.mo("+"));
else if (c4.value == "minus")
mrowunder.appendChild(this.mo("-"));
}
munder.appendChild(mrowunder);
mrow.appendChild(munder);
}
mrow.appendChild(c1._toMathML(context));
el = mrow;
} else if (c0.value == "binomial") {
// displayed like a vector
mrow = document.createElement('mrow');
mrow.appendChild(this.mo("("));
mtable = document.createElement('mtable');
for (i=1; i<this.children.length; i++) {
var mtr = document.createElement('mtr');
mtr.appendChild(this.children[i]._toMathML(context));
mtable.appendChild(mtr);
}
mrow.appendChild(mtable);
mrow.appendChild(this.mo(")"));
el = mrow;
} else if (c0.value == "matrix") {
for (i=1; i<this.children.length; i++) {
// check that all children are vectors
if (this.children[i].type !== ENode.VECTOR) {
el = document.createElement('mtext');
el.appendChild(document.createTextNode("???")); // could throw here
return(el);
}
}
mrow = document.createElement('mrow');
mrow.appendChild(this.mo("("));
mtable = document.createElement('mtable');
for (i=1; i<this.children.length; i++) {
var mtr = document.createElement('mtr');
for (j=0; j<this.children[i].children.length; j++) {
mtr.appendChild(this.children[i].children[j]._toMathML(context));
}
mtable.appendChild(mtr);
}
mrow.appendChild(mtable);
mrow.appendChild(this.mo(")"));
el = mrow;
} else if (c0.value == "union" && this.children.length == 3) {
for (i=1; i<this.children.length; i++) {
// check that all children are intervals or sets
if (this.children[i].type !== ENode.INTERVAL && this.children[i].type !== ENode.SET) {
el = document.createElement('mtext');
el.appendChild(document.createTextNode("???"));
return(el);
}
}
mrow = document.createElement('mrow');
mrow.appendChild(c1._toMathML(context));
mrow.appendChild(this.mo("\u222A"));
mrow.appendChild(c2._toMathML(context));
el = mrow;
} else if (c0.value == "intersection" && this.children.length == 3) {
for (i=1; i<this.children.length; i++) {
// check that all children are intervals or sets
if (this.children[i].type !== ENode.INTERVAL && this.children[i].type !== ENode.SET) {
el = document.createElement('mtext');
el.appendChild(document.createTextNode("???"));
return(el);
}
}
mrow = document.createElement('mrow');
mrow.appendChild(c1._toMathML(context));
mrow.appendChild(this.mo("\u2229"));
mrow.appendChild(c2._toMathML(context));
el = mrow;
} else {
// default display for a function
mrow = document.createElement('mrow');
mrow.appendChild(c0._toMathML(context));
mrow.appendChild(this.mo("("));
for (i=1; i<this.children.length; i++) {
mrow.appendChild(this.children[i]._toMathML(context));
if (i < this.children.length - 1)
mrow.appendChild(this.mo(Definitions.ARG_SEPARATOR));
}
mrow.appendChild(this.mo(")"));
el = mrow;
}
return(el);
case ENode.VECTOR:
var is_matrix = true;
for (i=0; i<this.children.length; i++) {
if (this.children[i].type !== ENode.VECTOR)
is_matrix = false;
}
mrow = document.createElement('mrow');
mrow.appendChild(this.mo("("));
mtable = document.createElement('mtable');
for (i=0; i<this.children.length; i++) {
var mtr = document.createElement('mtr');
if (is_matrix) {
for (j=0; j<this.children[i].children.length; j++) {
mtr.appendChild(this.children[i].children[j]._toMathML(context));
}
} else {
mtr.appendChild(this.children[i]._toMathML(context));
}
mtable.appendChild(mtr);
}
mrow.appendChild(mtable);
mrow.appendChild(this.mo(")"));
return(mrow);
case ENode.INTERVAL:
mrow = document.createElement('mrow');
if (this.interval_type == ENode.OPEN_OPEN || this.interval_type == ENode.OPEN_CLOSED) {
mo = this.mo("(");
} else {
mo = this.mo("[");
}
mrow.appendChild(mo);
mrow2 = document.createElement('mrow');
mrow2.appendChild(this.children[0]._toMathML(context));
mrow2.appendChild(this.mo(":"));
mrow2.appendChild(this.children[1]._toMathML(context));
mrow.appendChild(mrow2);
if (this.interval_type == ENode.OPEN_OPEN || this.interval_type == ENode.CLOSED_OPEN) {
mo = this.mo(")");
} else {
mo = this.mo("]");
}
mrow.appendChild(mo);
return(mrow);
case ENode.SET:
mrow = document.createElement('mrow');
mrow.appendChild(this.mo("{"));
mrow2 = document.createElement('mrow');
for (i=0; i<this.children.length; i++) {
if (i > 0)
mrow2.appendChild(this.mo(Definitions.ARG_SEPARATOR));
mrow2.appendChild(this.children[i]._toMathML(context));
}
mrow.appendChild(mrow2);
mrow.appendChild(this.mo("}"));
return(mrow);
case ENode.SUBSCRIPT:
msub = document.createElement('msub');
msub.appendChild(c0._toMathML(context));
if (this.children.length > 2) {
mrow = document.createElement('mrow');
for (i=1; i<this.children.length; i++) {
mrow.appendChild(this.children[i]._toMathML(context));
if (i < this.children.length - 1)
mrow.appendChild(this.mo(Definitions.ARG_SEPARATOR));
}
msub.appendChild(mrow);
} else {
msub.appendChild(c1._toMathML(context));
}
return(msub);
}
};
/**
* Creates a MathML mi element with the given name
* @param {string} name
* @returns {Element}
*/
ENode.prototype.mi = function(name) {
var mi = document.createElement('mi');
if (ENode.symbols[name])
name = ENode.symbols[name];
mi.appendChild(document.createTextNode(name));
return mi;
};
/**
* Creates a MathML mn element with the given number or string
* @param {string} n
* @returns {Element}
*/
ENode.prototype.mn = function(n) {
var mn = document.createElement('mn');
mn.appendChild(document.createTextNode(n));
return mn;
};
/**
* Creates a MathML mo element with the given name
* @param {string} name
* @returns {Element}
*/
ENode.prototype.mo = function(name) {
var mo = document.createElement('mo');
if (ENode.symbols[name])
name = ENode.symbols[name];
mo.appendChild(document.createTextNode(name));
return mo;
};
/**
* Add parenthesis and returns a MathML element
* @param {ENode} en
* @param {Object} [context] - display context (not needed for the root element)
* @param {Object.<string, string>} context.hcolors - hash identifier->color
* @param {number} context.depth - Depth in parenthesis, used for coloring
* @returns {Element}
*/
ENode.prototype.addP = function(en, context) {
var mrow, mo;
mrow = document.createElement('mrow');
mo = this.mo("(");
var colors;
if (context.colors)
colors = context.colors;
else
colors = ENode.COLORS;
mo.setAttribute("mathcolor", colors[context.depth % colors.length]);
mrow.appendChild(mo);
context.depth++;
mrow.appendChild(en._toMathML(context));
context.depth--;
mo = this.mo(")");
mo.setAttribute("mathcolor", colors[context.depth % colors.length]);
mrow.appendChild(mo);
return mrow;
};
ENode.symbols = {
/* lowercase greek */
"alpha": "\u03B1", "beta": "\u03B2", "gamma": "\u03B3",
"delta": "\u03B4", "epsilon": "\u03B5", "zeta": "\u03B6",
"eta": "\u03B7", "theta": "\u03B8", "iota": "\u03B9",
"kappa": "\u03BA", "lambda": "\u03BB", "mu": "\u03BC",
"nu": "\u03BD", "xi": "\u03BE", "omicron": "\u03BF",
"pi": "\u03C0", "rho": "\u03C1", "sigma": "\u03C3",
"tau": "\u03C4", "upsilon": "\u03C5", "phi": "\u03C6",
"chi": "\u03C7", "psi": "\u03C8", "omega": "\u03C9",
/* uppercase greek */
"Alpha": "\u0391", "Beta": "\u0392", "Gamma": "\u0393",
"Delta": "\u0394", "Epsilon": "\u0395", "Zeta": "\u0396",
"Eta": "\u0397", "Theta": "\u0398", "Iota": "\u0399",
"Kappa": "\u039A", "Lambda": "\u039B", "Mu": "\u039C",
"Nu": "\u039D", "Xi": "\u039E", "Omicron": "\u039F",
"Pi": "\u03A0", "Rho": "\u03A1", "Sigma": "\u03A3",
"Tau": "\u03A4", "Upsilon": "\u03A5", "Phi": "\u03A6",
"Chi": "\u03A7", "Psi": "\u03A8", "Omega": "\u03A9",
/* operators */
"#": "\u2260",
">=": "\u2265",
"<=": "\u2264",
/* other */
"inf": "\u221E",
"minf": "-\u221E",
"hbar": "\u210F",
"G": "\uD835\uDCA2" // 1D4A2
};
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/back.gif){kind=icon}
Return to enode.js CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [LON-CAPA] / loncom / html / adm / LC_math_editor / src