| 1 |
/* -*- Mode: Javascript; indent-tabs-mode:nil; js-indent-level: 2 -*- */ |
| 2 |
/* vim: set ts=2 et sw=2 tw=80: */ |
| 3 |
|
| 4 |
/************************************************************* |
| 5 |
* |
| 6 |
* MathJax/jax/input/MathML/jax.js |
| 7 |
* |
| 8 |
* Implements the MathML InputJax that reads mathematics in |
| 9 |
* MathML format and converts it to the MML ElementJax |
| 10 |
* internal format. |
| 11 |
* |
| 12 |
* --------------------------------------------------------------------- |
| 13 |
* |
| 14 |
* Copyright (c) 2010-2020 The MathJax Consortium |
| 15 |
* |
| 16 |
* Licensed under the Apache License, Version 2.0 (the "License"); |
| 17 |
* you may not use this file except in compliance with the License. |
| 18 |
* You may obtain a copy of the License at |
| 19 |
* |
| 20 |
* http://www.apache.org/licenses/LICENSE-2.0 |
| 21 |
* |
| 22 |
* Unless required by applicable law or agreed to in writing, software |
| 23 |
* distributed under the License is distributed on an "AS IS" BASIS, |
| 24 |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 25 |
* See the License for the specific language governing permissions and |
| 26 |
* limitations under the License. |
| 27 |
*/ |
| 28 |
|
| 29 |
(function (MATHML,BROWSER) { |
| 30 |
var MML; |
| 31 |
|
| 32 |
var _ = function (id) { |
| 33 |
return MathJax.Localization._.apply(MathJax.Localization, |
| 34 |
[["MathML",id]].concat([].slice.call(arguments,1))) |
| 35 |
}; |
| 36 |
|
| 37 |
MATHML.Parse = MathJax.Object.Subclass({ |
| 38 |
|
| 39 |
Init: function (string,script) {this.Parse(string,script)}, |
| 40 |
|
| 41 |
// |
| 42 |
// Parse the MathML and check for errors |
| 43 |
// |
| 44 |
Parse: function (math,script) { |
| 45 |
var doc; |
| 46 |
if (typeof math !== "string") {doc = math.parentNode} else { |
| 47 |
doc = MATHML.ParseXML(this.preProcessMath.call(this,math)); |
| 48 |
if (doc == null) {MATHML.Error(["ErrorParsingMathML","Error parsing MathML"])} |
| 49 |
} |
| 50 |
var err = doc.getElementsByTagName("parsererror")[0]; |
| 51 |
if (err) MATHML.Error(["ParsingError","Error parsing MathML: %1", |
| 52 |
err.textContent.replace(/This page.*?errors:|XML Parsing Error: |Below is a rendering of the page.*/g,"")]); |
| 53 |
if (doc.childNodes.length !== 1) |
| 54 |
{MATHML.Error(["MathMLSingleElement","MathML must be formed by a single element"])} |
| 55 |
if (doc.firstChild.nodeName.toLowerCase() === "html") { |
| 56 |
var h1 = doc.getElementsByTagName("h1")[0]; |
| 57 |
if (h1 && h1.textContent === "XML parsing error" && h1.nextSibling) |
| 58 |
MATHML.Error(["ParsingError","Error parsing MathML: %1", |
| 59 |
String(h1.nextSibling.nodeValue).replace(/fatal parsing error: /,"")]); |
| 60 |
} |
| 61 |
if (doc.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") !== "math") { |
| 62 |
MATHML.Error(["MathMLRootElement", |
| 63 |
"MathML must be formed by a <math> element, not %1", |
| 64 |
"<"+doc.firstChild.nodeName+">"]); |
| 65 |
} |
| 66 |
var data = {math:doc.firstChild, script:script}; |
| 67 |
MATHML.DOMfilterHooks.Execute(data); |
| 68 |
this.mml = this.MakeMML(data.math); |
| 69 |
}, |
| 70 |
|
| 71 |
// |
| 72 |
// Convert the MathML structure to the MathJax Element jax structure |
| 73 |
// |
| 74 |
MakeMML: function (node) { |
| 75 |
var CLASS = String(node.getAttribute("class")||""); // make sure CLASS is a string |
| 76 |
var mml, type = node.nodeName.toLowerCase().replace(/^[a-z]+:/,""); |
| 77 |
var match = (CLASS.match(/(^| )MJX-TeXAtom-([^ ]*)/)); |
| 78 |
if (match) { |
| 79 |
mml = this.TeXAtom(match[2],match[2] === "OP" && !CLASS.match(/MJX-fixedlimits/)); |
| 80 |
} else if (!(MML[type] && MML[type].isa && MML[type].isa(MML.mbase))) { |
| 81 |
MathJax.Hub.signal.Post(["MathML Jax - unknown node type",type]); |
| 82 |
return MML.Error(_("UnknownNodeType","Unknown node type: %1",type)); |
| 83 |
} else { |
| 84 |
mml = MML[type](); |
| 85 |
} |
| 86 |
this.AddAttributes(mml,node); this.CheckClass(mml,mml["class"]); |
| 87 |
this.AddChildren(mml,node); |
| 88 |
if (MATHML.config.useMathMLspacing) {mml.useMMLspacing = 0x08} |
| 89 |
return mml; |
| 90 |
}, |
| 91 |
TeXAtom: function (mclass,movablelimits) { |
| 92 |
var mml = MML.TeXAtom().With({texClass:MML.TEXCLASS[mclass]}); |
| 93 |
if (movablelimits) {mml.movesupsub = mml.movablelimits = true} |
| 94 |
return mml; |
| 95 |
}, |
| 96 |
CheckClass: function (mml,CLASS) { |
| 97 |
CLASS = (CLASS||"").split(/ /); var NCLASS = []; |
| 98 |
for (var i = 0, m = CLASS.length; i < m; i++) { |
| 99 |
if (CLASS[i].substr(0,4) === "MJX-") { |
| 100 |
if (CLASS[i] === "MJX-arrow") { |
| 101 |
// This class was used in former versions of MathJax to attach an |
| 102 |
// arrow to the updiagonalstrike notation. For backward |
| 103 |
// compatibility, let's continue to accept this case. See issue 481. |
| 104 |
if (!mml.notation.match("/"+MML.NOTATION.UPDIAGONALARROW+"/")) |
| 105 |
mml.notation += " "+MML.NOTATION.UPDIAGONALARROW; |
| 106 |
} else if (CLASS[i] === "MJX-variant") { |
| 107 |
mml.variantForm = true; |
| 108 |
// |
| 109 |
// Variant forms come from AMSsymbols, and it sets up the |
| 110 |
// character mappings, so load that if needed. |
| 111 |
// |
| 112 |
if (!MathJax.Extension["TeX/AMSsymbols"]) |
| 113 |
{MathJax.Hub.RestartAfter(MathJax.Ajax.Require("[MathJax]/extensions/TeX/AMSsymbols.js"))} |
| 114 |
} else if (CLASS[i].substr(0,11) !== "MJX-TeXAtom") { |
| 115 |
mml.mathvariant = CLASS[i].substr(3); |
| 116 |
// |
| 117 |
// Caligraphic and oldstyle bold are set up in the boldsymbol |
| 118 |
// extension, so load it if it isn't already loaded. |
| 119 |
// |
| 120 |
if (mml.mathvariant === "-tex-caligraphic-bold" || |
| 121 |
mml.mathvariant === "-tex-oldstyle-bold") { |
| 122 |
if (!MathJax.Extension["TeX/boldsymbol"]) |
| 123 |
{MathJax.Hub.RestartAfter(MathJax.Ajax.Require("[MathJax]/extensions/TeX/boldsymbol.js"))} |
| 124 |
} |
| 125 |
} |
| 126 |
} else {NCLASS.push(CLASS[i])} |
| 127 |
} |
| 128 |
if (NCLASS.length) {mml["class"] = NCLASS.join(" ")} else {delete mml["class"]} |
| 129 |
}, |
| 130 |
|
| 131 |
// |
| 132 |
// Add the attributes to the mml node |
| 133 |
// |
| 134 |
AddAttributes: function (mml,node) { |
| 135 |
mml.attr = {}; mml.attrNames = []; |
| 136 |
for (var i = 0, m = node.attributes.length; i < m; i++) { |
| 137 |
var name = node.attributes[i].name; |
| 138 |
if (name == "xlink:href") {name = "href"} |
| 139 |
if (name.match(/:/)) continue; |
| 140 |
if (name.match(/^_moz-math-((column|row)(align|line)|font-style)$/)) continue; |
| 141 |
var value = node.attributes[i].value; |
| 142 |
value = this.filterAttribute(name,value); |
| 143 |
var defaults = (mml.type === "mstyle" ? MML.math.prototype.defaults : mml.defaults); |
| 144 |
if (value != null) { |
| 145 |
var val = value.toLowerCase(); |
| 146 |
if (val === "true" || val === "false") { |
| 147 |
if (typeof (defaults[name]) === "boolean" || defaults[name] === MML.INHERIT || |
| 148 |
mml.type === "math" || mml.type === "mstyle" || |
| 149 |
(defaults[name] === MML.AUTO && |
| 150 |
(mml.defaultDef == null || typeof(mml.defaultDef[name]) === "boolean"))) { |
| 151 |
value = (val === "true"); |
| 152 |
} |
| 153 |
} |
| 154 |
if (defaults[name] != null || MML.copyAttributes[name]) |
| 155 |
{mml[name] = value} else {mml.attr[name] = value} |
| 156 |
mml.attrNames.push(name); |
| 157 |
} |
| 158 |
} |
| 159 |
}, |
| 160 |
filterAttribute: function (name,value) {return value}, // safe mode overrides this |
| 161 |
|
| 162 |
// |
| 163 |
// Create the children for the mml node |
| 164 |
// |
| 165 |
AddChildren: function (mml,node) { |
| 166 |
for (var i = 0, m = node.childNodes.length; i < m; i++) { |
| 167 |
var child = node.childNodes[i]; |
| 168 |
if (child.nodeName === "#comment") continue; |
| 169 |
if (child.nodeName === "#text") { |
| 170 |
if ((mml.isToken || mml.isChars) && !mml.mmlSelfClosing) { |
| 171 |
var text = child.nodeValue; |
| 172 |
if (mml.isToken) { |
| 173 |
text = text.replace(/&([a-z][a-z0-9]*);/ig,this.replaceEntity); |
| 174 |
text = this.trimSpace(text); |
| 175 |
} |
| 176 |
mml.Append(MML.chars(text)); |
| 177 |
} else if (child.nodeValue.match(/\S/)) { |
| 178 |
MATHML.Error(["UnexpectedTextNode", |
| 179 |
"Unexpected text node: %1","'"+child.nodeValue+"'"]); |
| 180 |
} |
| 181 |
} else if (mml.type === "annotation-xml") { |
| 182 |
mml.Append(MML.xml(child)); |
| 183 |
} else { |
| 184 |
var cmml = this.MakeMML(child); mml.Append(cmml); |
| 185 |
if (cmml.mmlSelfClosing && cmml.data.length) |
| 186 |
{mml.Append.apply(mml,cmml.data); cmml.data = []} |
| 187 |
} |
| 188 |
} |
| 189 |
if (mml.type === "mrow" && mml.data.length >= 2) { |
| 190 |
var first = mml.data[0], last = mml.data[mml.data.length-1]; |
| 191 |
if (first.type === "mo" && first.Get("fence") && |
| 192 |
last.type === "mo" && last.Get("fence")) { |
| 193 |
if (first.data[0]) {mml.open = first.data.join("")} |
| 194 |
if (last.data[0]) {mml.close = last.data.join("")} |
| 195 |
} |
| 196 |
} |
| 197 |
}, |
| 198 |
|
| 199 |
// |
| 200 |
// Clean Up the <math> source to prepare for XML parsing |
| 201 |
// |
| 202 |
preProcessMath: function (math) { |
| 203 |
if (math.match(/^<[a-z]+:/i) && !math.match(/^<[^<>]* xmlns:/)) { |
| 204 |
math = math.replace(/^<([a-z]+)(:math)/i,'<$1$2 xmlns:$1="http://www.w3.org/1998/Math/MathML"') |
| 205 |
} |
| 206 |
// HTML5 removes xmlns: namespaces, so put them back for XML |
| 207 |
var match = math.match(/^(<math( ('.*?'|".*?"|[^>])+)>)/i); |
| 208 |
if (match && match[2].match(/ (?!xmlns=)[a-z]+=\"http:/i)) { |
| 209 |
math = match[1].replace(/ (?!xmlns=)([a-z]+=(['"])http:.*?\2)/ig," xmlns:$1 $1") + |
| 210 |
math.substr(match[0].length); |
| 211 |
} |
| 212 |
if (math.match(/^<math[ >]/i) && !math.match(/^<[^<>]* xmlns=/)) { |
| 213 |
// append the MathML namespace |
| 214 |
math = math.replace(/^<(math)/i,'<math xmlns="http://www.w3.org/1998/Math/MathML"') |
| 215 |
} |
| 216 |
math = math.replace(/^\s*(?:\/\/)?<!(--)?\[CDATA\[((.|\n)*)(\/\/)?\]\]\1>\s*$/,"$2"); |
| 217 |
return math.replace(/&([a-z][a-z0-9]*);/ig,this.replaceEntity); |
| 218 |
}, |
| 219 |
|
| 220 |
// |
| 221 |
// Remove attribute whitespace |
| 222 |
// |
| 223 |
trimSpace: function (string) { |
| 224 |
return string.replace(/[\t\n\r]/g," ") // whitespace to spaces |
| 225 |
.replace(/^ +/,"") // initial whitespace |
| 226 |
.replace(/ +$/,"") // trailing whitespace |
| 227 |
.replace(/ +/g," "); // internal multiple whitespace |
| 228 |
}, |
| 229 |
|
| 230 |
// |
| 231 |
// Replace a named entity by its value |
| 232 |
// (look up from external files if necessary) |
| 233 |
// |
| 234 |
replaceEntity: function (match,entity) { |
| 235 |
if (entity.match(/^(lt|amp|quot)$/)) {return match} // these mess up attribute parsing |
| 236 |
if (MATHML.Parse.Entity[entity]) {return MATHML.Parse.Entity[entity]} |
| 237 |
var file = entity.charAt(0).toLowerCase(); |
| 238 |
var font = entity.match(/^[a-zA-Z](fr|scr|opf)$/); |
| 239 |
if (font) {file = font[1]} |
| 240 |
if (!MATHML.Parse.loaded[file]) { |
| 241 |
MATHML.Parse.loaded[file] = true; |
| 242 |
MathJax.Hub.RestartAfter(MathJax.Ajax.Require(MATHML.entityDir+"/"+file+".js")); |
| 243 |
} |
| 244 |
return match; |
| 245 |
} |
| 246 |
}, { |
| 247 |
loaded: [] // the entity files that are loaded |
| 248 |
}); |
| 249 |
|
| 250 |
/************************************************************************/ |
| 251 |
|
| 252 |
MATHML.Augment({ |
| 253 |
sourceMenuTitle: /*_(MathMenu)*/ ["OriginalMathML","Original MathML"], |
| 254 |
|
| 255 |
prefilterHooks: MathJax.Callback.Hooks(true), // hooks to run on MathML string before processing MathML |
| 256 |
DOMfilterHooks: MathJax.Callback.Hooks(true), // hooks to run on MathML DOM before processing |
| 257 |
postfilterHooks: MathJax.Callback.Hooks(true), // hooks to run on internal jax format after processing MathML |
| 258 |
|
| 259 |
Translate: function (script) { |
| 260 |
if (!this.ParseXML) {this.ParseXML = this.createParser()} |
| 261 |
var mml, math, data = {script:script}; |
| 262 |
if (script.firstChild && |
| 263 |
script.firstChild.nodeName.toLowerCase().replace(/^[a-z]+:/,"") === "math") { |
| 264 |
data.math = script.firstChild; |
| 265 |
} else { |
| 266 |
math = MathJax.HTML.getScript(script); |
| 267 |
if (BROWSER.isMSIE) {math = math.replace(/( )+$/,"")} |
| 268 |
data.math = math; |
| 269 |
} |
| 270 |
var callback = this.prefilterHooks.Execute(data); if (callback) return callback; |
| 271 |
math = data.math; |
| 272 |
try { |
| 273 |
mml = MATHML.Parse(math,script).mml; |
| 274 |
} catch(err) { |
| 275 |
if (!err.mathmlError) {throw err} |
| 276 |
mml = this.formatError(err,math,script); |
| 277 |
} |
| 278 |
data.math = MML(mml); |
| 279 |
return this.postfilterHooks.Execute(data) || data.math; |
| 280 |
}, |
| 281 |
prefilterMath: function (math,script) {return math}, |
| 282 |
prefilterMathML: function (math,script) {return math}, |
| 283 |
formatError: function (err,math,script) { |
| 284 |
var message = err.message.replace(/\n.*/,""); |
| 285 |
MathJax.Hub.signal.Post(["MathML Jax - parse error",message,math,script]); |
| 286 |
return MML.Error(message); |
| 287 |
}, |
| 288 |
Error: function (message) { |
| 289 |
// |
| 290 |
// Translate message if it is ["id","message",args] |
| 291 |
// |
| 292 |
if (MathJax.Object.isArray(message)) {message = _.apply(_,message)} |
| 293 |
throw MathJax.Hub.Insert(Error(message),{mathmlError: true}); |
| 294 |
}, |
| 295 |
// |
| 296 |
// Parsers for various forms (DOMParser, Windows ActiveX object, other) |
| 297 |
// |
| 298 |
parseDOM: function (string) {return this.parser.parseFromString(string,"text/xml")}, |
| 299 |
parseMS: function (string) {return (this.parser.loadXML(string) ? this.parser : null)}, |
| 300 |
parseDIV: function (string) { |
| 301 |
this.div.innerHTML = |
| 302 |
"<div>"+string.replace(/<([a-z]+)([^>]*)\/>/g,"<$1$2></$1>")+"</div>"; |
| 303 |
var doc = this.div.firstChild; |
| 304 |
this.div.innerHTML = ""; |
| 305 |
return doc; |
| 306 |
}, |
| 307 |
parseError: function (string) {return null}, |
| 308 |
createMSParser: function() { |
| 309 |
var parser = null; |
| 310 |
var xml = ["MSXML2.DOMDocument.6.0","MSXML2.DOMDocument.5.0", |
| 311 |
"MSXML2.DOMDocument.4.0","MSXML2.DOMDocument.3.0", |
| 312 |
"MSXML2.DOMDocument.2.0","Microsoft.XMLDOM"]; |
| 313 |
for (var i = 0, m = xml.length; i < m && !parser; i++) { |
| 314 |
try { |
| 315 |
parser = new ActiveXObject(xml[i]) |
| 316 |
} catch (err) {} |
| 317 |
} |
| 318 |
return parser; |
| 319 |
}, |
| 320 |
// |
| 321 |
// Create the parser using a DOMParser, or other fallback method |
| 322 |
// |
| 323 |
createParser: function () { |
| 324 |
if (window.DOMParser) { |
| 325 |
this.parser = new DOMParser(); |
| 326 |
return(this.parseDOM); |
| 327 |
} else if (window.ActiveXObject) { |
| 328 |
this.parser = this.createMSParser(); |
| 329 |
if (!this.parser) { |
| 330 |
MathJax.Localization.Try(this.parserCreationError); |
| 331 |
return(this.parseError); |
| 332 |
} |
| 333 |
this.parser.async = false; |
| 334 |
return(this.parseMS); |
| 335 |
} |
| 336 |
this.div = MathJax.Hub.Insert(document.createElement("div"),{ |
| 337 |
style:{visibility:"hidden", overflow:"hidden", height:"1px", |
| 338 |
position:"absolute", top:0} |
| 339 |
}); |
| 340 |
if (!document.body.firstChild) {document.body.appendChild(this.div)} |
| 341 |
else {document.body.insertBefore(this.div,document.body.firstChild)} |
| 342 |
return(this.parseDIV); |
| 343 |
}, |
| 344 |
parserCreationError: function () { |
| 345 |
alert(_("CantCreateXMLParser", |
| 346 |
"MathJax can't create an XML parser for MathML. Check that\n"+ |
| 347 |
"the 'Script ActiveX controls marked safe for scripting' security\n"+ |
| 348 |
"setting is enabled (use the Internet Options item in the Tools\n"+ |
| 349 |
"menu, and select the Security panel, then press the Custom Level\n"+ |
| 350 |
"button to check this).\n\n"+ |
| 351 |
"MathML equations will not be able to be processed by MathJax.")); |
| 352 |
}, |
| 353 |
// |
| 354 |
// Initialize the parser object (whichever type is used) |
| 355 |
// |
| 356 |
Startup: function () { |
| 357 |
MML = MathJax.ElementJax.mml; |
| 358 |
MML.mspace.Augment({mmlSelfClosing: true}); |
| 359 |
MML.none.Augment({mmlSelfClosing: true}); |
| 360 |
MML.mprescripts.Augment({mmlSelfClosing:true}); |
| 361 |
MML.maligngroup.Augment({mmlSelfClosing:true}); |
| 362 |
MML.malignmark.Augment({mmlSelfClosing:true}); |
| 363 |
} |
| 364 |
}); |
| 365 |
|
| 366 |
// |
| 367 |
// Add the default pre-filter (for backward compatibility) |
| 368 |
// |
| 369 |
MATHML.prefilterHooks.Add(function (data) { |
| 370 |
data.math = (typeof(data.math) === "string" ? |
| 371 |
MATHML.prefilterMath(data.math,data.script) : |
| 372 |
MATHML.prefilterMathML(data.math,data.script)); |
| 373 |
}); |
| 374 |
|
| 375 |
MATHML.Parse.Entity = { |
| 376 |
ApplyFunction: '\u2061', |
| 377 |
Backslash: '\u2216', |
| 378 |
Because: '\u2235', |
| 379 |
Breve: '\u02D8', |
| 380 |
Cap: '\u22D2', |
| 381 |
CenterDot: '\u00B7', |
| 382 |
CircleDot: '\u2299', |
| 383 |
CircleMinus: '\u2296', |
| 384 |
CirclePlus: '\u2295', |
| 385 |
CircleTimes: '\u2297', |
| 386 |
Congruent: '\u2261', |
| 387 |
ContourIntegral: '\u222E', |
| 388 |
Coproduct: '\u2210', |
| 389 |
Cross: '\u2A2F', |
| 390 |
Cup: '\u22D3', |
| 391 |
CupCap: '\u224D', |
| 392 |
Dagger: '\u2021', |
| 393 |
Del: '\u2207', |
| 394 |
Delta: '\u0394', |
| 395 |
Diamond: '\u22C4', |
| 396 |
DifferentialD: '\u2146', |
| 397 |
DotEqual: '\u2250', |
| 398 |
DoubleDot: '\u00A8', |
| 399 |
DoubleRightTee: '\u22A8', |
| 400 |
DoubleVerticalBar: '\u2225', |
| 401 |
DownArrow: '\u2193', |
| 402 |
DownLeftVector: '\u21BD', |
| 403 |
DownRightVector: '\u21C1', |
| 404 |
DownTee: '\u22A4', |
| 405 |
Downarrow: '\u21D3', |
| 406 |
Element: '\u2208', |
| 407 |
EqualTilde: '\u2242', |
| 408 |
Equilibrium: '\u21CC', |
| 409 |
Exists: '\u2203', |
| 410 |
ExponentialE: '\u2147', |
| 411 |
FilledVerySmallSquare: '\u25AA', |
| 412 |
ForAll: '\u2200', |
| 413 |
Gamma: '\u0393', |
| 414 |
Gg: '\u22D9', |
| 415 |
GreaterEqual: '\u2265', |
| 416 |
GreaterEqualLess: '\u22DB', |
| 417 |
GreaterFullEqual: '\u2267', |
| 418 |
GreaterLess: '\u2277', |
| 419 |
GreaterSlantEqual: '\u2A7E', |
| 420 |
GreaterTilde: '\u2273', |
| 421 |
Hacek: '\u02C7', |
| 422 |
Hat: '\u005E', |
| 423 |
HumpDownHump: '\u224E', |
| 424 |
HumpEqual: '\u224F', |
| 425 |
Im: '\u2111', |
| 426 |
ImaginaryI: '\u2148', |
| 427 |
Integral: '\u222B', |
| 428 |
Intersection: '\u22C2', |
| 429 |
InvisibleComma: '\u2063', |
| 430 |
InvisibleTimes: '\u2062', |
| 431 |
Lambda: '\u039B', |
| 432 |
Larr: '\u219E', |
| 433 |
LeftAngleBracket: '\u27E8', |
| 434 |
LeftArrow: '\u2190', |
| 435 |
LeftArrowRightArrow: '\u21C6', |
| 436 |
LeftCeiling: '\u2308', |
| 437 |
LeftDownVector: '\u21C3', |
| 438 |
LeftFloor: '\u230A', |
| 439 |
LeftRightArrow: '\u2194', |
| 440 |
LeftTee: '\u22A3', |
| 441 |
LeftTriangle: '\u22B2', |
| 442 |
LeftTriangleEqual: '\u22B4', |
| 443 |
LeftUpVector: '\u21BF', |
| 444 |
LeftVector: '\u21BC', |
| 445 |
Leftarrow: '\u21D0', |
| 446 |
Leftrightarrow: '\u21D4', |
| 447 |
LessEqualGreater: '\u22DA', |
| 448 |
LessFullEqual: '\u2266', |
| 449 |
LessGreater: '\u2276', |
| 450 |
LessSlantEqual: '\u2A7D', |
| 451 |
LessTilde: '\u2272', |
| 452 |
Ll: '\u22D8', |
| 453 |
Lleftarrow: '\u21DA', |
| 454 |
LongLeftArrow: '\u27F5', |
| 455 |
LongLeftRightArrow: '\u27F7', |
| 456 |
LongRightArrow: '\u27F6', |
| 457 |
Longleftarrow: '\u27F8', |
| 458 |
Longleftrightarrow: '\u27FA', |
| 459 |
Longrightarrow: '\u27F9', |
| 460 |
Lsh: '\u21B0', |
| 461 |
MinusPlus: '\u2213', |
| 462 |
NestedGreaterGreater: '\u226B', |
| 463 |
NestedLessLess: '\u226A', |
| 464 |
NotDoubleVerticalBar: '\u2226', |
| 465 |
NotElement: '\u2209', |
| 466 |
NotEqual: '\u2260', |
| 467 |
NotExists: '\u2204', |
| 468 |
NotGreater: '\u226F', |
| 469 |
NotGreaterEqual: '\u2271', |
| 470 |
NotLeftTriangle: '\u22EA', |
| 471 |
NotLeftTriangleEqual: '\u22EC', |
| 472 |
NotLess: '\u226E', |
| 473 |
NotLessEqual: '\u2270', |
| 474 |
NotPrecedes: '\u2280', |
| 475 |
NotPrecedesSlantEqual: '\u22E0', |
| 476 |
NotRightTriangle: '\u22EB', |
| 477 |
NotRightTriangleEqual: '\u22ED', |
| 478 |
NotSubsetEqual: '\u2288', |
| 479 |
NotSucceeds: '\u2281', |
| 480 |
NotSucceedsSlantEqual: '\u22E1', |
| 481 |
NotSupersetEqual: '\u2289', |
| 482 |
NotTilde: '\u2241', |
| 483 |
NotVerticalBar: '\u2224', |
| 484 |
Omega: '\u03A9', |
| 485 |
OverBar: '\u203E', |
| 486 |
OverBrace: '\u23DE', |
| 487 |
PartialD: '\u2202', |
| 488 |
Phi: '\u03A6', |
| 489 |
Pi: '\u03A0', |
| 490 |
PlusMinus: '\u00B1', |
| 491 |
Precedes: '\u227A', |
| 492 |
PrecedesEqual: '\u2AAF', |
| 493 |
PrecedesSlantEqual: '\u227C', |
| 494 |
PrecedesTilde: '\u227E', |
| 495 |
Product: '\u220F', |
| 496 |
Proportional: '\u221D', |
| 497 |
Psi: '\u03A8', |
| 498 |
Rarr: '\u21A0', |
| 499 |
Re: '\u211C', |
| 500 |
ReverseEquilibrium: '\u21CB', |
| 501 |
RightAngleBracket: '\u27E9', |
| 502 |
RightArrow: '\u2192', |
| 503 |
RightArrowLeftArrow: '\u21C4', |
| 504 |
RightCeiling: '\u2309', |
| 505 |
RightDownVector: '\u21C2', |
| 506 |
RightFloor: '\u230B', |
| 507 |
RightTee: '\u22A2', |
| 508 |
RightTeeArrow: '\u21A6', |
| 509 |
RightTriangle: '\u22B3', |
| 510 |
RightTriangleEqual: '\u22B5', |
| 511 |
RightUpVector: '\u21BE', |
| 512 |
RightVector: '\u21C0', |
| 513 |
Rightarrow: '\u21D2', |
| 514 |
Rrightarrow: '\u21DB', |
| 515 |
Rsh: '\u21B1', |
| 516 |
Sigma: '\u03A3', |
| 517 |
SmallCircle: '\u2218', |
| 518 |
Sqrt: '\u221A', |
| 519 |
Square: '\u25A1', |
| 520 |
SquareIntersection: '\u2293', |
| 521 |
SquareSubset: '\u228F', |
| 522 |
SquareSubsetEqual: '\u2291', |
| 523 |
SquareSuperset: '\u2290', |
| 524 |
SquareSupersetEqual: '\u2292', |
| 525 |
SquareUnion: '\u2294', |
| 526 |
Star: '\u22C6', |
| 527 |
Subset: '\u22D0', |
| 528 |
SubsetEqual: '\u2286', |
| 529 |
Succeeds: '\u227B', |
| 530 |
SucceedsEqual: '\u2AB0', |
| 531 |
SucceedsSlantEqual: '\u227D', |
| 532 |
SucceedsTilde: '\u227F', |
| 533 |
SuchThat: '\u220B', |
| 534 |
Sum: '\u2211', |
| 535 |
Superset: '\u2283', |
| 536 |
SupersetEqual: '\u2287', |
| 537 |
Supset: '\u22D1', |
| 538 |
Therefore: '\u2234', |
| 539 |
Theta: '\u0398', |
| 540 |
Tilde: '\u223C', |
| 541 |
TildeEqual: '\u2243', |
| 542 |
TildeFullEqual: '\u2245', |
| 543 |
TildeTilde: '\u2248', |
| 544 |
UnderBar: '\u005F', |
| 545 |
UnderBrace: '\u23DF', |
| 546 |
Union: '\u22C3', |
| 547 |
UnionPlus: '\u228E', |
| 548 |
UpArrow: '\u2191', |
| 549 |
UpDownArrow: '\u2195', |
| 550 |
UpTee: '\u22A5', |
| 551 |
Uparrow: '\u21D1', |
| 552 |
Updownarrow: '\u21D5', |
| 553 |
Upsilon: '\u03A5', |
| 554 |
Vdash: '\u22A9', |
| 555 |
Vee: '\u22C1', |
| 556 |
VerticalBar: '\u2223', |
| 557 |
VerticalTilde: '\u2240', |
| 558 |
Vvdash: '\u22AA', |
| 559 |
Wedge: '\u22C0', |
| 560 |
Xi: '\u039E', |
| 561 |
acute: '\u00B4', |
| 562 |
aleph: '\u2135', |
| 563 |
alpha: '\u03B1', |
| 564 |
amalg: '\u2A3F', |
| 565 |
and: '\u2227', |
| 566 |
ang: '\u2220', |
| 567 |
angmsd: '\u2221', |
| 568 |
angsph: '\u2222', |
| 569 |
ape: '\u224A', |
| 570 |
backprime: '\u2035', |
| 571 |
backsim: '\u223D', |
| 572 |
backsimeq: '\u22CD', |
| 573 |
beta: '\u03B2', |
| 574 |
beth: '\u2136', |
| 575 |
between: '\u226C', |
| 576 |
bigcirc: '\u25EF', |
| 577 |
bigodot: '\u2A00', |
| 578 |
bigoplus: '\u2A01', |
| 579 |
bigotimes: '\u2A02', |
| 580 |
bigsqcup: '\u2A06', |
| 581 |
bigstar: '\u2605', |
| 582 |
bigtriangledown: '\u25BD', |
| 583 |
bigtriangleup: '\u25B3', |
| 584 |
biguplus: '\u2A04', |
| 585 |
blacklozenge: '\u29EB', |
| 586 |
blacktriangle: '\u25B4', |
| 587 |
blacktriangledown: '\u25BE', |
| 588 |
blacktriangleleft: '\u25C2', |
| 589 |
bowtie: '\u22C8', |
| 590 |
boxdl: '\u2510', |
| 591 |
boxdr: '\u250C', |
| 592 |
boxminus: '\u229F', |
| 593 |
boxplus: '\u229E', |
| 594 |
boxtimes: '\u22A0', |
| 595 |
boxul: '\u2518', |
| 596 |
boxur: '\u2514', |
| 597 |
bsol: '\u005C', |
| 598 |
bull: '\u2022', |
| 599 |
cap: '\u2229', |
| 600 |
check: '\u2713', |
| 601 |
chi: '\u03C7', |
| 602 |
circ: '\u02C6', |
| 603 |
circeq: '\u2257', |
| 604 |
circlearrowleft: '\u21BA', |
| 605 |
circlearrowright: '\u21BB', |
| 606 |
circledR: '\u00AE', |
| 607 |
circledS: '\u24C8', |
| 608 |
circledast: '\u229B', |
| 609 |
circledcirc: '\u229A', |
| 610 |
circleddash: '\u229D', |
| 611 |
clubs: '\u2663', |
| 612 |
colon: '\u003A', |
| 613 |
comp: '\u2201', |
| 614 |
ctdot: '\u22EF', |
| 615 |
cuepr: '\u22DE', |
| 616 |
cuesc: '\u22DF', |
| 617 |
cularr: '\u21B6', |
| 618 |
cup: '\u222A', |
| 619 |
curarr: '\u21B7', |
| 620 |
curlyvee: '\u22CE', |
| 621 |
curlywedge: '\u22CF', |
| 622 |
dagger: '\u2020', |
| 623 |
daleth: '\u2138', |
| 624 |
ddarr: '\u21CA', |
| 625 |
deg: '\u00B0', |
| 626 |
delta: '\u03B4', |
| 627 |
digamma: '\u03DD', |
| 628 |
div: '\u00F7', |
| 629 |
divideontimes: '\u22C7', |
| 630 |
dot: '\u02D9', |
| 631 |
doteqdot: '\u2251', |
| 632 |
dotplus: '\u2214', |
| 633 |
dotsquare: '\u22A1', |
| 634 |
dtdot: '\u22F1', |
| 635 |
ecir: '\u2256', |
| 636 |
efDot: '\u2252', |
| 637 |
egs: '\u2A96', |
| 638 |
ell: '\u2113', |
| 639 |
els: '\u2A95', |
| 640 |
empty: '\u2205', |
| 641 |
epsi: '\u03B5', |
| 642 |
epsiv: '\u03F5', |
| 643 |
erDot: '\u2253', |
| 644 |
eta: '\u03B7', |
| 645 |
eth: '\u00F0', |
| 646 |
flat: '\u266D', |
| 647 |
fork: '\u22D4', |
| 648 |
frown: '\u2322', |
| 649 |
gEl: '\u2A8C', |
| 650 |
gamma: '\u03B3', |
| 651 |
gap: '\u2A86', |
| 652 |
gimel: '\u2137', |
| 653 |
gnE: '\u2269', |
| 654 |
gnap: '\u2A8A', |
| 655 |
gne: '\u2A88', |
| 656 |
gnsim: '\u22E7', |
| 657 |
gt: '\u003E', |
| 658 |
gtdot: '\u22D7', |
| 659 |
harrw: '\u21AD', |
| 660 |
hbar: '\u210F', |
| 661 |
hellip: '\u2026', |
| 662 |
hookleftarrow: '\u21A9', |
| 663 |
hookrightarrow: '\u21AA', |
| 664 |
imath: '\u0131', |
| 665 |
infin: '\u221E', |
| 666 |
intcal: '\u22BA', |
| 667 |
iota: '\u03B9', |
| 668 |
jmath: '\u0237', |
| 669 |
kappa: '\u03BA', |
| 670 |
kappav: '\u03F0', |
| 671 |
lEg: '\u2A8B', |
| 672 |
lambda: '\u03BB', |
| 673 |
lap: '\u2A85', |
| 674 |
larrlp: '\u21AB', |
| 675 |
larrtl: '\u21A2', |
| 676 |
lbrace: '\u007B', |
| 677 |
lbrack: '\u005B', |
| 678 |
le: '\u2264', |
| 679 |
leftleftarrows: '\u21C7', |
| 680 |
leftthreetimes: '\u22CB', |
| 681 |
lessdot: '\u22D6', |
| 682 |
lmoust: '\u23B0', |
| 683 |
lnE: '\u2268', |
| 684 |
lnap: '\u2A89', |
| 685 |
lne: '\u2A87', |
| 686 |
lnsim: '\u22E6', |
| 687 |
longmapsto: '\u27FC', |
| 688 |
looparrowright: '\u21AC', |
| 689 |
lowast: '\u2217', |
| 690 |
loz: '\u25CA', |
| 691 |
lt: '\u003C', |
| 692 |
ltimes: '\u22C9', |
| 693 |
ltri: '\u25C3', |
| 694 |
macr: '\u00AF', |
| 695 |
malt: '\u2720', |
| 696 |
mho: '\u2127', |
| 697 |
mu: '\u03BC', |
| 698 |
multimap: '\u22B8', |
| 699 |
nLeftarrow: '\u21CD', |
| 700 |
nLeftrightarrow: '\u21CE', |
| 701 |
nRightarrow: '\u21CF', |
| 702 |
nVDash: '\u22AF', |
| 703 |
nVdash: '\u22AE', |
| 704 |
natur: '\u266E', |
| 705 |
nearr: '\u2197', |
| 706 |
nharr: '\u21AE', |
| 707 |
nlarr: '\u219A', |
| 708 |
not: '\u00AC', |
| 709 |
nrarr: '\u219B', |
| 710 |
nu: '\u03BD', |
| 711 |
nvDash: '\u22AD', |
| 712 |
nvdash: '\u22AC', |
| 713 |
nwarr: '\u2196', |
| 714 |
omega: '\u03C9', |
| 715 |
omicron: '\u03BF', |
| 716 |
or: '\u2228', |
| 717 |
osol: '\u2298', |
| 718 |
period: '\u002E', |
| 719 |
phi: '\u03C6', |
| 720 |
phiv: '\u03D5', |
| 721 |
pi: '\u03C0', |
| 722 |
piv: '\u03D6', |
| 723 |
prap: '\u2AB7', |
| 724 |
precnapprox: '\u2AB9', |
| 725 |
precneqq: '\u2AB5', |
| 726 |
precnsim: '\u22E8', |
| 727 |
prime: '\u2032', |
| 728 |
psi: '\u03C8', |
| 729 |
rarrtl: '\u21A3', |
| 730 |
rbrace: '\u007D', |
| 731 |
rbrack: '\u005D', |
| 732 |
rho: '\u03C1', |
| 733 |
rhov: '\u03F1', |
| 734 |
rightrightarrows: '\u21C9', |
| 735 |
rightthreetimes: '\u22CC', |
| 736 |
ring: '\u02DA', |
| 737 |
rmoust: '\u23B1', |
| 738 |
rtimes: '\u22CA', |
| 739 |
rtri: '\u25B9', |
| 740 |
scap: '\u2AB8', |
| 741 |
scnE: '\u2AB6', |
| 742 |
scnap: '\u2ABA', |
| 743 |
scnsim: '\u22E9', |
| 744 |
sdot: '\u22C5', |
| 745 |
searr: '\u2198', |
| 746 |
sect: '\u00A7', |
| 747 |
sharp: '\u266F', |
| 748 |
sigma: '\u03C3', |
| 749 |
sigmav: '\u03C2', |
| 750 |
simne: '\u2246', |
| 751 |
smile: '\u2323', |
| 752 |
spades: '\u2660', |
| 753 |
sub: '\u2282', |
| 754 |
subE: '\u2AC5', |
| 755 |
subnE: '\u2ACB', |
| 756 |
subne: '\u228A', |
| 757 |
supE: '\u2AC6', |
| 758 |
supnE: '\u2ACC', |
| 759 |
supne: '\u228B', |
| 760 |
swarr: '\u2199', |
| 761 |
tau: '\u03C4', |
| 762 |
theta: '\u03B8', |
| 763 |
thetav: '\u03D1', |
| 764 |
tilde: '\u02DC', |
| 765 |
times: '\u00D7', |
| 766 |
triangle: '\u25B5', |
| 767 |
triangleq: '\u225C', |
| 768 |
upsi: '\u03C5', |
| 769 |
upuparrows: '\u21C8', |
| 770 |
veebar: '\u22BB', |
| 771 |
vellip: '\u22EE', |
| 772 |
weierp: '\u2118', |
| 773 |
xi: '\u03BE', |
| 774 |
yen: '\u00A5', |
| 775 |
zeta: '\u03B6', |
| 776 |
zigrarr: '\u21DD' |
| 777 |
}; |
| 778 |
|
| 779 |
MATHML.loadComplete("jax.js"); |
| 780 |
|
| 781 |
})(MathJax.InputJax.MathML,MathJax.Hub.Browser); |