| 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/extensions/MathML/content-mathml.js |
| 7 |
* |
| 8 |
* This file provides methods to convert Content-MathML to |
| 9 |
* Presentation MathML for processing by MathJax. The transform is |
| 10 |
* performed in a DOM filter for the MathML input jax, so that the |
| 11 |
* Show Math As menu will still show the Original MathML as Content MathML, |
| 12 |
* but the Presentation MathML can be obtained from the main MathML menu. |
| 13 |
* |
| 14 |
* To load it, include |
| 15 |
* |
| 16 |
* MathML: { |
| 17 |
* extensions: ["content-mathml.js"] |
| 18 |
* } |
| 19 |
* |
| 20 |
* in your configuration. |
| 21 |
* |
| 22 |
* A portion of this file is taken from ctop.js which is |
| 23 |
* Copyright (c) David Carlisle 2001, 2002, 2008, 2009, 2013, |
| 24 |
* and is used by permission of David Carlisle, who has agreed to allow us |
| 25 |
* to release it under the Apache2 license (see below). That portion is |
| 26 |
* indicated via comments. |
| 27 |
* |
| 28 |
* The remainder falls under the copyright that follows. |
| 29 |
* --------------------------------------------------------------------- |
| 30 |
* |
| 31 |
* Copyright (c) 2013-2020 The MathJax Consortium |
| 32 |
* |
| 33 |
* Licensed under the Apache License, Version 2.0 (the "License"); |
| 34 |
* you may not use this file except in compliance with the License. |
| 35 |
* You may obtain a copy of the License at |
| 36 |
* |
| 37 |
* http://www.apache.org/licenses/LICENSE-2.0 |
| 38 |
* |
| 39 |
* Unless required by applicable law or agreed to in writing, software |
| 40 |
* distributed under the License is distributed on an "AS IS" BASIS, |
| 41 |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 42 |
* See the License for the specific language governing permissions and |
| 43 |
* limitations under the License. |
| 44 |
*/ |
| 45 |
|
| 46 |
|
| 47 |
MathJax.Extension["MathML/content-mathml"] = (function(HUB) { |
| 48 |
/* |
| 49 |
* Content MathML to Presentation MathML conversion |
| 50 |
* |
| 51 |
* based on David Carlisle's ctop.js - https://web-xslt.googlecode.com/svn/trunk/ctop/ctop.js |
| 52 |
* |
| 53 |
*/ |
| 54 |
|
| 55 |
|
| 56 |
var isMSIE = HUB.Browser.isMSIE; |
| 57 |
|
| 58 |
if (isMSIE) { |
| 59 |
try {document.namespaces.add("m","http://www.w3.org/1998/Math/MathML")} catch (err) {} |
| 60 |
} |
| 61 |
|
| 62 |
var CONFIG = HUB.CombineConfig("MathML.content-mathml",{ |
| 63 |
// render `a+(-b)` as `a-b`? |
| 64 |
collapsePlusMinus: true, |
| 65 |
|
| 66 |
/* mathvariant to use with corresponding <ci> type attribute */ |
| 67 |
cistyles: { |
| 68 |
vector: 'bold-italic', |
| 69 |
matrix: 'bold-upright' |
| 70 |
}, |
| 71 |
|
| 72 |
/* Symbol names to translate to characters |
| 73 |
*/ |
| 74 |
symbols: { |
| 75 |
gamma: '\u03B3' |
| 76 |
} |
| 77 |
|
| 78 |
}); |
| 79 |
|
| 80 |
var CToP = { |
| 81 |
version: "2.7.9", |
| 82 |
settings: CONFIG, |
| 83 |
|
| 84 |
/* Transform the given <math> elements from Content MathML to Presentation MathML and replace the original elements |
| 85 |
*/ |
| 86 |
transformElements: function(elements) { |
| 87 |
for (var i = 0, l = elements.length; i<l; i++ ) { |
| 88 |
var mathNode = CToP.transformElement(elements[i]); |
| 89 |
elements[i].parentNode.replaceChild(mathNode,elements[i]); |
| 90 |
} |
| 91 |
}, |
| 92 |
|
| 93 |
/* Transform a Content MathML element into Presentation MathML, and return the new element |
| 94 |
*/ |
| 95 |
transformElement: function(element) { |
| 96 |
if (element.nodeName.indexOf(":") >= 0) element = CToP.cloneNode(element,true); // removes namespaces |
| 97 |
var mathNode = CToP.cloneNode(element); |
| 98 |
for (var j = 0, l = element.childNodes.length; j<l; j++ ) { |
| 99 |
CToP.applyTransform(mathNode,element.childNodes[j],0); |
| 100 |
} |
| 101 |
return mathNode; |
| 102 |
}, |
| 103 |
|
| 104 |
getTextContent: function(element) { |
| 105 |
return element.text !== undefined ? element.text : element.innerText !== undefined ? element.innerText : element.textContent; |
| 106 |
}, |
| 107 |
|
| 108 |
setTextContent: function(element,textContent) { |
| 109 |
for (var i = 0, l = element.childNodes.length; i<l; i++) { |
| 110 |
if (element.childNodes[i].nodeType === 3) { |
| 111 |
element.removeChild(element.childNodes[i]); |
| 112 |
i--; |
| 113 |
l--; |
| 114 |
} |
| 115 |
} |
| 116 |
element.appendChild(document.createTextNode(textContent)); |
| 117 |
}, |
| 118 |
|
| 119 |
cloneNode: function(element,deep) { |
| 120 |
var clone, i, l; |
| 121 |
if (element.nodeType === 1) { |
| 122 |
clone = CToP.createElement(element.nodeName); |
| 123 |
for (i = 0, l = element.attributes.length; i<l; i++ ) { |
| 124 |
clone.setAttribute(element.attributes[i].nodeName,element.attributes[i].nodeValue); |
| 125 |
} |
| 126 |
if (deep) { |
| 127 |
for (i = 0, l = element.childNodes.length; i<l; i++ ) { |
| 128 |
var clonedChild = CToP.cloneNode(element.childNodes[i],true); |
| 129 |
clone.appendChild(clonedChild); |
| 130 |
} |
| 131 |
} |
| 132 |
} else if (element.nodeType === 3) { |
| 133 |
clone = document.createTextNode(element.nodeValue); |
| 134 |
} |
| 135 |
return clone; |
| 136 |
}, |
| 137 |
|
| 138 |
/* Create an element with given name, belonging to the MathML namespace |
| 139 |
*/ |
| 140 |
createElement: function(name) { |
| 141 |
name = name.replace(/^.*:/,""); // remove namespace |
| 142 |
return (document.createElementNS ? |
| 143 |
document.createElementNS("http://www.w3.org/1998/Math/MathML",name) : |
| 144 |
document.createElement("m:"+name)); |
| 145 |
}, |
| 146 |
|
| 147 |
/* Get node's children |
| 148 |
*/ |
| 149 |
getChildren: function(node) { |
| 150 |
var children = []; |
| 151 |
for (var j = 0, l = node.childNodes.length; j<l; j++ ) { |
| 152 |
if (node.childNodes[j].nodeType === 1) { |
| 153 |
children.push(node.childNodes[j]); |
| 154 |
} |
| 155 |
} |
| 156 |
return children; |
| 157 |
}, |
| 158 |
|
| 159 |
/* Classify node's children as argumentss, variable bindings, or qualifiers |
| 160 |
*/ |
| 161 |
classifyChildren: function(contentMMLNode) { |
| 162 |
var args = [], bvars = [], qualifiers = []; |
| 163 |
for (var j = 0, l = contentMMLNode.childNodes.length; j<l; j++ ) { |
| 164 |
if (contentMMLNode.childNodes[j].nodeType === 1) { |
| 165 |
var childNode = contentMMLNode.childNodes[j], name = childNode.nodeName; |
| 166 |
if (name === 'bvar') { |
| 167 |
bvars.push(childNode); |
| 168 |
} else if (name === 'condition'|| |
| 169 |
name === 'degree'|| |
| 170 |
name === 'momentabout'|| |
| 171 |
name === 'logbase'|| |
| 172 |
name === 'lowlimit'|| |
| 173 |
name === 'uplimit'|| |
| 174 |
(name === 'interval' && args.length<2)|| |
| 175 |
name === 'domainofapplication') { |
| 176 |
qualifiers.push(childNode); |
| 177 |
} else { |
| 178 |
args.push(childNode); |
| 179 |
} |
| 180 |
} |
| 181 |
} |
| 182 |
return { |
| 183 |
args:args, |
| 184 |
bvars:bvars, |
| 185 |
qualifiers:qualifiers |
| 186 |
}; |
| 187 |
}, |
| 188 |
|
| 189 |
/* Add an element with given name and text content |
| 190 |
*/ |
| 191 |
appendToken: function(parentNode,name,textContent) { |
| 192 |
var element = CToP.createElement(name); |
| 193 |
textContent = textContent.replace(/^\s+/,"").replace(/\s+$/,""); |
| 194 |
if (name === 'mn' && textContent.substr(0,1) === "-") { |
| 195 |
// |
| 196 |
// use <mrow><mo>−</mo><mn>n</mn></mrow> instead of <mn>-n</mn> |
| 197 |
// |
| 198 |
element.appendChild(document.createTextNode(textContent.substr(1))); |
| 199 |
var mrow = CToP.createElement('mrow'); |
| 200 |
CToP.appendToken(mrow,'mo','\u2212'); |
| 201 |
mrow.appendChild(element); |
| 202 |
element = mrow; |
| 203 |
} else { |
| 204 |
element.appendChild(document.createTextNode(textContent)); |
| 205 |
} |
| 206 |
parentNode.appendChild(element); |
| 207 |
return element; |
| 208 |
}, |
| 209 |
|
| 210 |
/* Transform a Content MathML node to Presentation MathML node(s), and attach it to the parent |
| 211 |
*/ |
| 212 |
applyTransform: function(parentNode,contentMMLNode,precedence) { |
| 213 |
if (!contentMMLNode) { |
| 214 |
var merror = CToP.createElement('merror'); |
| 215 |
CToP.appendToken(merror,'mtext','Missing child node'); |
| 216 |
parentNode.appendChild(merror); |
| 217 |
return; |
| 218 |
} |
| 219 |
var nodeName = contentMMLNode.nodeName.replace(/.*:/,''); |
| 220 |
if (contentMMLNode.nodeType === 1) { |
| 221 |
if (CToP.tokens[nodeName]) { |
| 222 |
CToP.tokens[nodeName](parentNode,contentMMLNode,precedence); |
| 223 |
} else if (contentMMLNode.childNodes.length === 0) { |
| 224 |
var mml = CToP.MML[nodeName]; |
| 225 |
if (mml && mml.isa && mml.isa(CToP.mbase)) { |
| 226 |
parentNode.appendChild(CToP.cloneNode(contentMMLNode)); |
| 227 |
} else { |
| 228 |
CToP.appendToken(parentNode,'mi',nodeName); |
| 229 |
} |
| 230 |
} else { |
| 231 |
var clonedChild = CToP.cloneNode(contentMMLNode); |
| 232 |
parentNode.appendChild(clonedChild); |
| 233 |
for (var j = 0, l = contentMMLNode.childNodes.length; j<l; j++ ) { |
| 234 |
CToP.applyTransform(clonedChild,contentMMLNode.childNodes[j],precedence); |
| 235 |
} |
| 236 |
} |
| 237 |
} else if (contentMMLNode.nodeType === 3) { |
| 238 |
parentNode.appendChild(CToP.cloneNode(contentMMLNode)); |
| 239 |
} |
| 240 |
}, |
| 241 |
|
| 242 |
/* Make an mfenced environment |
| 243 |
*/ |
| 244 |
createmfenced: function(children,open,close) { |
| 245 |
var mf = CToP.createElement('mfenced'); |
| 246 |
mf.setAttribute('open',open); |
| 247 |
mf.setAttribute('close',close); |
| 248 |
for (var j = 0, l = children.length; j<l; j++ ) { |
| 249 |
CToP.applyTransform(mf,children[j],0); |
| 250 |
} |
| 251 |
return mf; |
| 252 |
}, |
| 253 |
|
| 254 |
transforms: { |
| 255 |
|
| 256 |
/* Transform an identifier symbol |
| 257 |
*/ |
| 258 |
identifier: function(textContent) { |
| 259 |
return function(parentNode,contentMMLNode,precedence) { |
| 260 |
CToP.appendToken(parentNode,'mi',textContent); |
| 261 |
} |
| 262 |
}, |
| 263 |
|
| 264 |
/* Transform a set or set-like notation |
| 265 |
*/ |
| 266 |
set: function(open,close) { |
| 267 |
var bindSet = CToP.transforms.bind('',',','|'); |
| 268 |
return function(parentNode,contentMMLNode) { |
| 269 |
var children = CToP.classifyChildren(contentMMLNode); |
| 270 |
|
| 271 |
var args = children.args, bvars = children.bvars, qualifiers = children.qualifiers; |
| 272 |
if (bvars.length) { |
| 273 |
var firstArg = children.args[0]; |
| 274 |
args = args.slice(1); |
| 275 |
var mfenced = CToP.createElement('mfenced'); |
| 276 |
mfenced.setAttribute('open',open); |
| 277 |
mfenced.setAttribute('close',close); |
| 278 |
bindSet(mfenced,contentMMLNode,firstArg,args,bvars,qualifiers,0); |
| 279 |
parentNode.appendChild(mfenced); |
| 280 |
} else { |
| 281 |
parentNode.appendChild(CToP.createmfenced(args,open,close)); |
| 282 |
} |
| 283 |
} |
| 284 |
}, |
| 285 |
|
| 286 |
/* Transform a content token to a presentation token |
| 287 |
* |
| 288 |
* (function factory) |
| 289 |
* @param {string} name - name of the corresponding presentation MML tag |
| 290 |
*/ |
| 291 |
token: function(name) { |
| 292 |
return function(parentNode,contentMMLNode) { |
| 293 |
if (contentMMLNode.childNodes.length === 1 && contentMMLNode.childNodes[0].nodeType === 3) { |
| 294 |
CToP.appendToken(parentNode,name,CToP.getTextContent(contentMMLNode)); |
| 295 |
} else { |
| 296 |
var mrow = CToP.createElement('mrow'); |
| 297 |
for (var j = 0, l = contentMMLNode.childNodes.length; j<l; j++ ) { |
| 298 |
if (contentMMLNode.childNodes[j].nodeType === 3) { |
| 299 |
CToP.appendToken(parentNode,name,CToP.getTextContent(contentMMLNode.childNodes[j])); |
| 300 |
}else{ |
| 301 |
CToP.applyTransform(mrow,contentMMLNode.childNodes[j],0); |
| 302 |
} |
| 303 |
} |
| 304 |
if (mrow.childNodes.length) { |
| 305 |
parentNode.appendChild(mrow); |
| 306 |
} |
| 307 |
} |
| 308 |
} |
| 309 |
}, |
| 310 |
|
| 311 |
/* Transform a binary operation |
| 312 |
* |
| 313 |
* (function factory) |
| 314 |
*/ |
| 315 |
binary: function(name,tokenPrecedence) { |
| 316 |
return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 317 |
var mrow = CToP.createElement('mrow'); |
| 318 |
var needsBrackets = tokenPrecedence<precedence || (tokenPrecedence == precedence && name === "-"); |
| 319 |
if (needsBrackets) { |
| 320 |
CToP.appendToken(mrow,'mo','('); |
| 321 |
} |
| 322 |
if (args.length>1) { |
| 323 |
CToP.applyTransform(mrow,args[0],tokenPrecedence); |
| 324 |
} |
| 325 |
CToP.appendToken(mrow,'mo',name); |
| 326 |
if (args.length>0) { |
| 327 |
var z = args[(args.length === 1)?0:1]; |
| 328 |
CToP.applyTransform(mrow,z,tokenPrecedence); |
| 329 |
} |
| 330 |
if (needsBrackets) { |
| 331 |
CToP.appendToken(mrow,'mo',')'); |
| 332 |
} |
| 333 |
parentNode.appendChild(mrow); |
| 334 |
} |
| 335 |
}, |
| 336 |
|
| 337 |
/* Transform an infix operator |
| 338 |
* |
| 339 |
* (function factory) |
| 340 |
*/ |
| 341 |
infix: function(name,tokenPrecedence) { |
| 342 |
return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 343 |
var mrow = CToP.createElement('mrow'); |
| 344 |
var needsBrackets = precedence>tokenPrecedence; |
| 345 |
if (needsBrackets) { |
| 346 |
CToP.appendToken(mrow,'mo','('); |
| 347 |
} |
| 348 |
for (var j = 0, l = args.length; j<l; j++ ) { |
| 349 |
if (j>0) { |
| 350 |
CToP.appendToken(mrow,'mo',name); |
| 351 |
} |
| 352 |
CToP.applyTransform(mrow,args[j],tokenPrecedence); |
| 353 |
} |
| 354 |
if (needsBrackets) { |
| 355 |
CToP.appendToken(mrow,'mo',')'); |
| 356 |
} |
| 357 |
parentNode.appendChild(mrow); |
| 358 |
} |
| 359 |
}, |
| 360 |
|
| 361 |
/* Transform an iterated operation, e.g. summation |
| 362 |
* |
| 363 |
* (function factory |
| 364 |
*/ |
| 365 |
iteration: function(name,limitSymbol) { |
| 366 |
return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 367 |
var mrow = CToP.createElement('mrow'); |
| 368 |
var mo = CToP.createElement('mo'); |
| 369 |
CToP.setTextContent(mo,name); |
| 370 |
var munderover = CToP.createElement('munderover'); |
| 371 |
munderover.appendChild(mo); |
| 372 |
var mrow1 = CToP.createElement('mrow'); |
| 373 |
var i, j, num_qualifiers, num_bvars, children, bvar, num_children, num_args; |
| 374 |
for (i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) { |
| 375 |
if (qualifiers[i].nodeName === 'lowlimit'|| |
| 376 |
qualifiers[i].nodeName === 'condition'|| |
| 377 |
qualifiers[i].nodeName === 'domainofapplication') |
| 378 |
{ |
| 379 |
if (qualifiers[i].nodeName === 'lowlimit') { |
| 380 |
for (j = 0, num_bvars = bvars.length; j<num_bvars; j++ ) { |
| 381 |
bvar = bvars[j]; |
| 382 |
children = CToP.getChildren(bvar); |
| 383 |
if (children.length) { |
| 384 |
CToP.applyTransform(mrow1,children[0],0); |
| 385 |
} |
| 386 |
} |
| 387 |
if (bvars.length) { |
| 388 |
CToP.appendToken(mrow1,"mo",limitSymbol); |
| 389 |
} |
| 390 |
} |
| 391 |
children = CToP.getChildren(qualifiers[i]); |
| 392 |
for (j = 0;j<children.length;j++) { |
| 393 |
CToP.applyTransform(mrow1,children[j],0); |
| 394 |
} |
| 395 |
} else { |
| 396 |
children = CToP.getChildren(qualifiers[i]); |
| 397 |
if (qualifiers[i].nodeName === 'interval' && children.length === 2) { |
| 398 |
for (j = 0, num_bvars = bvars.length; j<num_bvars; j++ ) { |
| 399 |
bvar = bvars[j]; |
| 400 |
children = CToP.getChildren(bvar); |
| 401 |
if (children.length) { |
| 402 |
CToP.applyTransform(mrow1,children[0],0); |
| 403 |
} |
| 404 |
} |
| 405 |
if (bvars.length) { |
| 406 |
CToP.appendToken(mrow1,"mo","="); |
| 407 |
} |
| 408 |
CToP.applyTransform(mrow1,CToP.getChildren(qualifiers[i])[0],0); |
| 409 |
} |
| 410 |
} |
| 411 |
} |
| 412 |
munderover.appendChild(mrow1); |
| 413 |
var mjrow = CToP.createElement('mrow'); |
| 414 |
for (i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) { |
| 415 |
if (qualifiers[i].nodeName === 'uplimit' ||qualifiers[i].nodeName === 'interval' ) |
| 416 |
{ |
| 417 |
children = CToP.getChildren(qualifiers[i]); |
| 418 |
for (j = 0, num_children = children.length; j<num_children; j++ ) { |
| 419 |
CToP.applyTransform(mjrow,children[j],0); |
| 420 |
} |
| 421 |
} |
| 422 |
} |
| 423 |
munderover.appendChild(mjrow); |
| 424 |
mrow.appendChild(munderover); |
| 425 |
|
| 426 |
for (i = 0, num_args = args.length; i<num_args; i++ ) { |
| 427 |
CToP.applyTransform(mrow,args[i],precedence); |
| 428 |
} |
| 429 |
|
| 430 |
parentNode.appendChild(mrow); |
| 431 |
} |
| 432 |
}, |
| 433 |
|
| 434 |
/* Transform something which binds a variable, e.g. forall or lambda |
| 435 |
* |
| 436 |
* (function factory) |
| 437 |
*/ |
| 438 |
bind: function(name,argSeparator,conditionSeparator) { |
| 439 |
return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 440 |
var mrow = CToP.createElement('mrow'); |
| 441 |
var children, i, j, l, num_qualifiers, num_children; |
| 442 |
if (name) { |
| 443 |
CToP.appendToken(mrow,'mo',name); |
| 444 |
} |
| 445 |
for (j = 0, l = bvars.length; j<l; j++ ) { |
| 446 |
var bvar = bvars[j]; |
| 447 |
if (j>0) { |
| 448 |
CToP.appendToken(mrow,'mo',','); |
| 449 |
} |
| 450 |
children = CToP.getChildren(bvar); |
| 451 |
if (children.length) { |
| 452 |
CToP.applyTransform(mrow,children[0],0); |
| 453 |
} |
| 454 |
} |
| 455 |
|
| 456 |
var conditions_mrow = CToP.createElement('mrow'); |
| 457 |
var conditions = false; |
| 458 |
for (i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) { |
| 459 |
if (qualifiers[i].nodeName === 'condition') { |
| 460 |
conditions = true; |
| 461 |
children = CToP.getChildren(qualifiers[i]); |
| 462 |
for (j = 0, num_children = children.length; j<num_children; j++ ) { |
| 463 |
CToP.applyTransform(conditions_mrow,children[j],0); |
| 464 |
} |
| 465 |
} |
| 466 |
} |
| 467 |
if (conditions) { |
| 468 |
CToP.appendToken(mrow,'mo',conditionSeparator); |
| 469 |
} |
| 470 |
mrow.appendChild(conditions_mrow); |
| 471 |
for (i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) { |
| 472 |
if (qualifiers[i].nodeName != 'condition') { |
| 473 |
CToP.appendToken(mrow,'mo','\u2208'); |
| 474 |
children = CToP.getChildren(qualifiers[i]); |
| 475 |
for (j = 0, num_children = children.length; j<num_children; j++ ) { |
| 476 |
CToP.applyTransform(mrow,children[j],0); |
| 477 |
} |
| 478 |
} |
| 479 |
} |
| 480 |
if (args.length && (bvars.length||children.length)) { |
| 481 |
CToP.appendToken(mrow,'mo',argSeparator); |
| 482 |
} |
| 483 |
for (i = 0, l = args.length; i<l; i++ ) { |
| 484 |
CToP.applyTransform(mrow,args[i],0); |
| 485 |
} |
| 486 |
parentNode.appendChild(mrow); |
| 487 |
} |
| 488 |
}, |
| 489 |
|
| 490 |
/** Transform a function application |
| 491 |
* |
| 492 |
* i.e. something which ends up looking like `f(x,y,z)`, where `f` is a string |
| 493 |
* |
| 494 |
* (function factory) |
| 495 |
*/ |
| 496 |
fn: function(name) { |
| 497 |
return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 498 |
var mrow = CToP.createElement('mrow'); |
| 499 |
if (firstArg.childNodes.length) { |
| 500 |
CToP.applyTransform(mrow,firstArg,1); |
| 501 |
} else { |
| 502 |
CToP.appendToken(mrow,'mi',name); |
| 503 |
} |
| 504 |
CToP.appendToken(mrow,'mo','\u2061'); |
| 505 |
mrow.appendChild(CToP.createmfenced(args,'(',')')); |
| 506 |
parentNode.appendChild(mrow); |
| 507 |
} |
| 508 |
}, |
| 509 |
|
| 510 |
/** Transform a min/max operation |
| 511 |
* |
| 512 |
* (function factory) |
| 513 |
*/ |
| 514 |
minmax: function(name) { |
| 515 |
return function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 516 |
var mrow = CToP.createElement('mrow'); |
| 517 |
CToP.appendToken(mrow,'mi',name); |
| 518 |
var mrow2 = CToP.createElement('mrow'); |
| 519 |
CToP.appendToken(mrow2,'mo','{'); |
| 520 |
for (var i = 0, l = args.length; i<l; i++ ) { |
| 521 |
if (i>0) { |
| 522 |
CToP.appendToken(mrow2,'mo',','); |
| 523 |
} |
| 524 |
CToP.applyTransform(mrow2,args[i],0); |
| 525 |
} |
| 526 |
if (qualifiers.length) { |
| 527 |
CToP.appendToken(mrow2,'mo','|'); |
| 528 |
for (i = 0, l = qualifiers.length; i<l; i++ ) { |
| 529 |
CToP.applyTransform(mrow2,qualifiers[i],0); |
| 530 |
} |
| 531 |
} |
| 532 |
CToP.appendToken(mrow2,'mo','}'); |
| 533 |
mrow.appendChild(mrow2); |
| 534 |
parentNode.appendChild(mrow); |
| 535 |
} |
| 536 |
} |
| 537 |
} |
| 538 |
} |
| 539 |
|
| 540 |
/* Functions to transform variable/atom tokens |
| 541 |
*/ |
| 542 |
CToP.tokens = { |
| 543 |
ci: function(parentNode,contentMMLNode,precedence) { |
| 544 |
if (contentMMLNode.childNodes.length === 1 && contentMMLNode.childNodes[0].nodeType === 3) { |
| 545 |
var mi = CToP.appendToken(parentNode,'mi',CToP.getTextContent(contentMMLNode)); |
| 546 |
var type = contentMMLNode.getAttribute('type'); |
| 547 |
if (type in CToP.settings.cistyles) { |
| 548 |
mi.setAttribute('mathvariant',CToP.settings.cistyles[type]); |
| 549 |
} |
| 550 |
} else { |
| 551 |
CToP.transforms.token('mi')(parentNode,contentMMLNode,precedence); |
| 552 |
} |
| 553 |
}, |
| 554 |
cs: CToP.transforms.token('ms'), |
| 555 |
|
| 556 |
csymbol: function(parentNode,contentMMLNode,precedence) { |
| 557 |
var cd = contentMMLNode.getAttribute('cd'); |
| 558 |
if (cd && CToP.contentDictionaries[cd]) { |
| 559 |
CToP.contentDictionaries[cd](parentNode,contentMMLNode,precedence); |
| 560 |
} else if (CToP.settings.symbols[name]) { |
| 561 |
CToP.appendToken(parentNode,'mi',CToP.settings.symbols[name]); |
| 562 |
} else { |
| 563 |
CToP.tokens.ci(parentNode,contentMMLNode); |
| 564 |
} |
| 565 |
}, |
| 566 |
fn: function(parentNode,contentMMLNode,precedence) { |
| 567 |
CToP.applyTransform(parentNode,CToP.getChildren(contentMMLNode)[0],precedence); |
| 568 |
}, |
| 569 |
|
| 570 |
naturalnumbers: CToP.transforms.identifier('\u2115'), |
| 571 |
integers: CToP.transforms.identifier('\u2124'), |
| 572 |
reals: CToP.transforms.identifier('\u211D'), |
| 573 |
rationals: CToP.transforms.identifier('\u211A'), |
| 574 |
complexes: CToP.transforms.identifier('\u2102'), |
| 575 |
primes: CToP.transforms.identifier('\u2119'), |
| 576 |
exponentiale: CToP.transforms.identifier('e'), |
| 577 |
imaginaryi: CToP.transforms.identifier('i'), |
| 578 |
notanumber: CToP.transforms.identifier('NaN'), |
| 579 |
eulergamma: CToP.transforms.identifier('\u03B3'), |
| 580 |
gamma: CToP.transforms.identifier('\u0263'), |
| 581 |
pi: CToP.transforms.identifier('\u03C0'), |
| 582 |
infinity: CToP.transforms.identifier('\u221E'), |
| 583 |
emptyset: CToP.transforms.identifier('\u2205'), |
| 584 |
"true": CToP.transforms.identifier('true'), |
| 585 |
"false": CToP.transforms.identifier('false'), |
| 586 |
set: CToP.transforms.set('{','}'), |
| 587 |
list: CToP.transforms.set('(',')'), |
| 588 |
|
| 589 |
interval: function(parentNode,contentMMLNode,precedence) { |
| 590 |
var closure = contentMMLNode.getAttribute('closure'); |
| 591 |
|
| 592 |
var open, close; |
| 593 |
switch(closure) { |
| 594 |
case 'open': |
| 595 |
open = '('; |
| 596 |
close = ')'; |
| 597 |
break; |
| 598 |
case 'open-closed': |
| 599 |
open = '('; |
| 600 |
close = ']'; |
| 601 |
break; |
| 602 |
case 'closed-open': |
| 603 |
open = '['; |
| 604 |
close = ')'; |
| 605 |
break; |
| 606 |
case 'closed': |
| 607 |
default: |
| 608 |
open = '['; |
| 609 |
close = ']'; |
| 610 |
} |
| 611 |
|
| 612 |
parentNode.appendChild(CToP.createmfenced(CToP.getChildren(contentMMLNode),open,close)); |
| 613 |
}, |
| 614 |
|
| 615 |
apply: function(parentNode,contentMMLNode,precedence) { |
| 616 |
var children = CToP.classifyChildren(contentMMLNode); |
| 617 |
|
| 618 |
var firstArg = children.args[0]; |
| 619 |
var args = children.args.slice(1), bvars = children.bvars, qualifiers = children.qualifiers; |
| 620 |
|
| 621 |
if (firstArg) { |
| 622 |
var name = firstArg.nodeName; |
| 623 |
name = (name === "csymbol") ? CToP.getTextContent(firstArg).toLowerCase() : name; |
| 624 |
if (CToP.applyTokens[name]) { |
| 625 |
CToP.applyTokens[name](parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 626 |
} else { |
| 627 |
CToP.transforms.fn(name)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 628 |
} |
| 629 |
} else { |
| 630 |
parentNode.appendChild(CToP.createElement('mrow')); |
| 631 |
} |
| 632 |
}, |
| 633 |
|
| 634 |
cn: function(parentNode,contentMMLNode,precedence) { |
| 635 |
var type = contentMMLNode.getAttribute("type"); |
| 636 |
var base = contentMMLNode.getAttribute("base"); |
| 637 |
if (type || base) { |
| 638 |
if (base) { |
| 639 |
type = 'based-integer'; |
| 640 |
} |
| 641 |
switch(type) { |
| 642 |
case 'integer': |
| 643 |
case 'real': |
| 644 |
case 'double': |
| 645 |
case 'constant': |
| 646 |
CToP.transforms.token('mn')(parentNode,contentMMLNode); |
| 647 |
break; |
| 648 |
case 'hexdouble': |
| 649 |
CToP.appendToken(parentNode,'mn','0x'+CToP.getTextContent(contentMMLNode)); |
| 650 |
break; |
| 651 |
default: |
| 652 |
var apply = CToP.createElement('apply'); |
| 653 |
var mrow = CToP.createElement('mrow'); |
| 654 |
var c = CToP.createElement(type); |
| 655 |
apply.appendChild(c); |
| 656 |
if (base) { |
| 657 |
CToP.appendToken(apply,'mn',base); |
| 658 |
} |
| 659 |
for (var j = 0, l = contentMMLNode.childNodes.length; j<l; j++ ) { |
| 660 |
if (contentMMLNode.childNodes[j].nodeType === 3) { |
| 661 |
CToP.appendToken(mrow,'cn',CToP.getTextContent(contentMMLNode.childNodes[j])); |
| 662 |
}else if (contentMMLNode.childNodes[j].nodeName === 'sep') { |
| 663 |
apply.appendChild(mrow); |
| 664 |
mrow = CToP.createElement('mrow'); |
| 665 |
} else { |
| 666 |
mrow.appendChild(CToP.cloneNode(contentMMLNode.childNodes[j],true)); |
| 667 |
} |
| 668 |
} |
| 669 |
apply.appendChild(mrow); |
| 670 |
CToP.applyTransform(parentNode,apply,0); |
| 671 |
} |
| 672 |
} else { |
| 673 |
CToP.transforms.token('mn')(parentNode,contentMMLNode); |
| 674 |
} |
| 675 |
}, |
| 676 |
|
| 677 |
vector: function(parentNode,contentMMLNode,precedence) { |
| 678 |
var mrow = CToP.createElement('mrow'); |
| 679 |
CToP.appendToken(mrow,'mo','('); |
| 680 |
|
| 681 |
var mtable = CToP.createElement('mtable'); |
| 682 |
var children = CToP.getChildren(contentMMLNode); |
| 683 |
for (var i = 0, l = children.length; i<l; i++ ) { |
| 684 |
var mtr = CToP.createElement('mtr'); |
| 685 |
var mtd = CToP.createElement('mtd'); |
| 686 |
CToP.applyTransform(mtd,children[i],0); |
| 687 |
mtr.appendChild(mtd); |
| 688 |
mtable.appendChild(mtr); |
| 689 |
} |
| 690 |
|
| 691 |
mrow.appendChild(mtable); |
| 692 |
CToP.appendToken(mrow,'mo',')'); |
| 693 |
parentNode.appendChild(mrow); |
| 694 |
}, |
| 695 |
|
| 696 |
piecewise: function(parentNode,contentMMLNode,precedence) { |
| 697 |
var mrow = CToP.createElement('mrow'); |
| 698 |
CToP.appendToken(mrow,'mo','{'); |
| 699 |
var mtable = CToP.createElement('mtable'); |
| 700 |
mrow.appendChild(mtable); |
| 701 |
var children = CToP.getChildren(contentMMLNode); |
| 702 |
for (var i = 0, l = children.length; i<l; i++ ) { |
| 703 |
CToP.applyTransform(mtable,children[i],0); |
| 704 |
} |
| 705 |
parentNode.appendChild(mrow); |
| 706 |
}, |
| 707 |
|
| 708 |
piece: function(parentNode,contentMMLNode,precedence) { |
| 709 |
var mtr = CToP.createElement('mtr'); |
| 710 |
var children = CToP.getChildren(contentMMLNode); |
| 711 |
for (var i = 0, l = children.length; i<l; i++ ) { |
| 712 |
var mtd = CToP.createElement('mtd'); |
| 713 |
mtr.appendChild(mtd); |
| 714 |
CToP.applyTransform(mtd,children[i],0); |
| 715 |
if (i === 0) { |
| 716 |
mtd = CToP.createElement('mtd'); |
| 717 |
CToP.appendToken(mtd,"mtext","\u00A0if\u00A0"); |
| 718 |
mtr.appendChild(mtd); |
| 719 |
} |
| 720 |
} |
| 721 |
parentNode.appendChild(mtr); |
| 722 |
}, |
| 723 |
|
| 724 |
otherwise: function(parentNode,contentMMLNode,precedence) { |
| 725 |
var mtr = CToP.createElement('mtr'); |
| 726 |
var children = CToP.getChildren(contentMMLNode); |
| 727 |
if (children.length) { |
| 728 |
var mtd = CToP.createElement('mtd'); |
| 729 |
mtr.appendChild(mtd); |
| 730 |
CToP.applyTransform(mtd,children[0],0); |
| 731 |
mtd = CToP.createElement('mtd'); |
| 732 |
mtd.setAttribute('columnspan','2'); |
| 733 |
CToP.appendToken(mtd,"mtext","\u00A0otherwise"); |
| 734 |
mtr.appendChild(mtd); |
| 735 |
} |
| 736 |
parentNode.appendChild(mtr); |
| 737 |
}, |
| 738 |
|
| 739 |
matrix: function(parentNode,contentMMLNode,precedence) { |
| 740 |
var children = CToP.classifyChildren(contentMMLNode); |
| 741 |
var args = children.args, bvars = children.bvars, qualifiers = children.qualifiers; |
| 742 |
|
| 743 |
if (bvars.length || qualifiers.length) { |
| 744 |
var mrow = CToP.createElement('mrow'); |
| 745 |
CToP.appendToken(mrow,"mo","["); |
| 746 |
var msub = CToP.createElement('msub'); |
| 747 |
CToP.appendToken(msub,'mi','m'); |
| 748 |
var mrow2 = CToP.createElement('mrow'); |
| 749 |
for (var i = 0, l = bvars.length; i<l; i++ ) { |
| 750 |
if (i != 0) { |
| 751 |
CToP.appendToken(mrow2,'mo',','); |
| 752 |
} |
| 753 |
CToP.applyTransform(mrow2,bvars[i].childNodes[0],0); |
| 754 |
} |
| 755 |
msub.appendChild(mrow2); |
| 756 |
mrow.appendChild(msub); |
| 757 |
var msub2 = CToP.cloneNode(msub,true); |
| 758 |
CToP.appendToken(mrow,'mo','|'); |
| 759 |
mrow.appendChild(msub2); |
| 760 |
CToP.appendToken(mrow,'mo','='); |
| 761 |
for (i = 0, l = args.length; i<l; i++ ) { |
| 762 |
if (i != 0) { |
| 763 |
CToP.appendToken(mrow,'mo',','); |
| 764 |
} |
| 765 |
CToP.applyTransform(mrow,args[i],0); |
| 766 |
} |
| 767 |
CToP.appendToken(mrow,'mo',';'); |
| 768 |
for (i = 0, l = qualifiers.length; i<l; i++) { |
| 769 |
if (i != 0) { |
| 770 |
CToP.appendToken(mrow,'mo',','); |
| 771 |
} |
| 772 |
CToP.applyTransform(mrow,qualifiers[i],0); |
| 773 |
} |
| 774 |
CToP.appendToken(mrow,'mo',']'); |
| 775 |
parentNode.appendChild(mrow); |
| 776 |
} else { |
| 777 |
var mfenced = CToP.createElement('mfenced'); |
| 778 |
var mtable = CToP.createElement('mtable'); |
| 779 |
for (i = 0, l = args.length; i<l; i++ ) { |
| 780 |
CToP.applyTransform(mtable,args[i],0); |
| 781 |
} |
| 782 |
mfenced.appendChild(mtable); |
| 783 |
parentNode.appendChild(mfenced); |
| 784 |
} |
| 785 |
}, |
| 786 |
|
| 787 |
matrixrow: function(parentNode,contentMMLNode,precedence) { |
| 788 |
var mtr = CToP.createElement('mtr'); |
| 789 |
var children = CToP.getChildren(contentMMLNode); |
| 790 |
for (var i = 0, l = children.length; i<l; i++ ) { |
| 791 |
var mtd = CToP.createElement('mtd'); |
| 792 |
CToP.applyTransform(mtd,children[i],0); |
| 793 |
mtr.appendChild(mtd); |
| 794 |
} |
| 795 |
parentNode.appendChild(mtr); |
| 796 |
}, |
| 797 |
|
| 798 |
condition: function(parentNode,contentMMLNode,precedence) { |
| 799 |
var mrow = CToP.createElement('mrow'); |
| 800 |
var children = CToP.getChildren(contentMMLNode); |
| 801 |
for (var i = 0, l = children.length; i<l; i++ ) { |
| 802 |
CToP.applyTransform(mrow,children[i],0); |
| 803 |
} |
| 804 |
parentNode.appendChild(mrow); |
| 805 |
}, |
| 806 |
|
| 807 |
lambda: function(parentNode,contentMMLNode,precedence) { |
| 808 |
var firstArg = CToP.createElement('lambda'); |
| 809 |
var children = CToP.classifyChildren(contentMMLNode); |
| 810 |
var args = children.args, bvars = children.bvars, qualifiers = children.qualifiers; |
| 811 |
var i, l, num_qualifiers; |
| 812 |
|
| 813 |
if (bvars.length) { |
| 814 |
CToP.applyTokens.lambda(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 815 |
} else { |
| 816 |
var mrow = CToP.createElement('mrow'); |
| 817 |
for (i = 0, l = args.length; i<l; i++ ) { |
| 818 |
CToP.applyTransform(mrow,args[i],0); |
| 819 |
} |
| 820 |
if (qualifiers.length) { |
| 821 |
var msub = CToP.createElement('msub'); |
| 822 |
CToP.appendToken(msub,'mo','|'); |
| 823 |
var mrow2 = CToP.createElement('mrow'); |
| 824 |
for (i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) { |
| 825 |
children = CToP.getChildren(qualifiers[i]); |
| 826 |
for (var j = 0, num_children = children.length; j<num_children; j++ ) { |
| 827 |
CToP.applyTransform(mrow2,children[j],0); |
| 828 |
} |
| 829 |
} |
| 830 |
msub.appendChild(mrow2); |
| 831 |
mrow.appendChild(msub); |
| 832 |
} |
| 833 |
parentNode.appendChild(mrow); |
| 834 |
} |
| 835 |
}, |
| 836 |
|
| 837 |
ident: function(parentNode,contentMMLNode,precedence) { |
| 838 |
CToP.appendToken(parentNode,"mi","id") |
| 839 |
}, |
| 840 |
|
| 841 |
domainofapplication: function(parentNode,contentMMLNode,precedence) { |
| 842 |
var merror = CToP.createElement('merror'); |
| 843 |
CToP.appendToken(merror,'mtext','unexpected domainofapplication'); |
| 844 |
parentNode.appendChild(merror); |
| 845 |
}, |
| 846 |
|
| 847 |
share: function(parentNode,contentMMLNode,precedence) { |
| 848 |
var mi = CToP.createElement('mi'); |
| 849 |
mi.setAttribute('href',contentMMLNode.getAttribute('href')); |
| 850 |
CToP.setTextContent(mi,"Share " + contentMMLNode.getAttribute('href')); |
| 851 |
parentNode.appendChild(mi); |
| 852 |
}, |
| 853 |
|
| 854 |
cerror: function(parentNode,contentMMLNode,precedence) { |
| 855 |
var merror = CToP.createElement('merror'); |
| 856 |
var children = CToP.getChildren(contentMMLNode); |
| 857 |
for (var i = 0, l = children.length; i<l; i++ ) { |
| 858 |
CToP.applyTransform(merror,children[i],0); |
| 859 |
} |
| 860 |
parentNode.appendChild(merror); |
| 861 |
}, |
| 862 |
|
| 863 |
semantics: function(parentNode,contentMMLNode,precedence) { |
| 864 |
var mrow = CToP.createElement('mrow'); |
| 865 |
var children = CToP.getChildren(contentMMLNode); |
| 866 |
if (children.length) { |
| 867 |
var z = children[0]; |
| 868 |
for (var i = 0, l = children.length; i<l; i++ ) { |
| 869 |
if (children[i].nodeName === 'annotation-xml' && children[i].getAttribute('encoding') === 'MathML-Presentation') { |
| 870 |
z = children[i]; |
| 871 |
break; |
| 872 |
} |
| 873 |
} |
| 874 |
CToP.applyTransform(mrow,z,0); |
| 875 |
} |
| 876 |
parentNode.appendChild(mrow); |
| 877 |
}, |
| 878 |
|
| 879 |
"annotation-xml": function(parentNode,contentMMLNode,precedence) { |
| 880 |
var mrow = CToP.createElement('mrow'); |
| 881 |
var children = CToP.getChildren(contentMMLNode); |
| 882 |
for (var i = 0, l = children.length; i<l; i++ ) { |
| 883 |
CToP.applyTransform(mrow,children[i],0); |
| 884 |
} |
| 885 |
parentNode.appendChild(mrow); |
| 886 |
} |
| 887 |
}; |
| 888 |
|
| 889 |
CToP.tokens.reln = CToP.tokens.bind = CToP.tokens.apply; |
| 890 |
|
| 891 |
CToP.contentDictionaries = { |
| 892 |
"setname1": function(parentNode,contentMMLNode,precedence) { |
| 893 |
var sets = { |
| 894 |
C: '\u2102', |
| 895 |
N: '\u2115', |
| 896 |
P: '\u2119', |
| 897 |
Q: '\u211A', |
| 898 |
R: '\u211D', |
| 899 |
Z: '\u2124' |
| 900 |
} |
| 901 |
var name = CToP.getTextContent(contentMMLNode); |
| 902 |
CToP.appendToken(parentNode,'mi',sets[name]); |
| 903 |
}, |
| 904 |
aritherror: function(parentNode,contentMMLNode,precedence) { |
| 905 |
var name = CToP.getTextContent(contentMMLNode); |
| 906 |
CToP.appendToken(parentNode,'mi',name+':'); |
| 907 |
} |
| 908 |
} |
| 909 |
|
| 910 |
/* Functions to transform function/operation application tokens |
| 911 |
*/ |
| 912 |
CToP.applyTokens = { |
| 913 |
rem: CToP.transforms.binary('mod',3), |
| 914 |
divide: CToP.transforms.binary('/',3), |
| 915 |
remainder: CToP.transforms.binary('mod',3), |
| 916 |
implies: CToP.transforms.binary('\u21D2',3), |
| 917 |
factorof: CToP.transforms.binary('|',3), |
| 918 |
"in": CToP.transforms.binary('\u2208',3), |
| 919 |
notin: CToP.transforms.binary('\u2209',3), |
| 920 |
notsubset: CToP.transforms.binary('\u2288',2), |
| 921 |
notprsubset: CToP.transforms.binary('\u2284',2), |
| 922 |
setdiff: CToP.transforms.binary('\u2216',2), |
| 923 |
eq: CToP.transforms.infix('=',1), |
| 924 |
compose: CToP.transforms.infix('\u2218',0), |
| 925 |
"left_compose": CToP.transforms.infix('\u2218',1), |
| 926 |
xor: CToP.transforms.infix('xor',3), |
| 927 |
neq: CToP.transforms.infix('\u2260',1), |
| 928 |
gt: CToP.transforms.infix('>',1), |
| 929 |
lt: CToP.transforms.infix('<',1), |
| 930 |
geq: CToP.transforms.infix('\u2265',1), |
| 931 |
leq: CToP.transforms.infix('\u2264',1), |
| 932 |
equivalent: CToP.transforms.infix('\u2261',1), |
| 933 |
approx: CToP.transforms.infix('\u2248',1), |
| 934 |
subset: CToP.transforms.infix('\u2286',2), |
| 935 |
prsubset: CToP.transforms.infix('\u2282',2), |
| 936 |
cartesianproduct: CToP.transforms.infix('\u00D7',2), |
| 937 |
"cartesian_product": CToP.transforms.infix('\u00D7',2), |
| 938 |
vectorproduct: CToP.transforms.infix('\u00D7',2), |
| 939 |
scalarproduct: CToP.transforms.infix('.',2), |
| 940 |
outerproduct: CToP.transforms.infix('\u2297',2), |
| 941 |
sum: CToP.transforms.iteration('\u2211','='), |
| 942 |
product: CToP.transforms.iteration('\u220F','='), |
| 943 |
forall: CToP.transforms.bind('\u2200','.',','), |
| 944 |
exists: CToP.transforms.bind('\u2203','.',','), |
| 945 |
lambda: CToP.transforms.bind('\u03BB','.',','), |
| 946 |
limit: CToP.transforms.iteration('lim','\u2192'), |
| 947 |
sdev: CToP.transforms.fn('\u03c3'), |
| 948 |
determinant: CToP.transforms.fn('det'), |
| 949 |
max: CToP.transforms.minmax('max'), |
| 950 |
min: CToP.transforms.minmax('min'), |
| 951 |
real: CToP.transforms.fn('\u211b'), |
| 952 |
imaginary: CToP.transforms.fn('\u2111'), |
| 953 |
set: CToP.transforms.set('{','}'), |
| 954 |
list: CToP.transforms.set('(',')'), |
| 955 |
|
| 956 |
exp: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 957 |
var msup = CToP.createElement('msup'); |
| 958 |
CToP.appendToken(msup,'mi','e'); |
| 959 |
CToP.applyTransform(msup,args[0],0); |
| 960 |
parentNode.appendChild(msup); |
| 961 |
}, |
| 962 |
|
| 963 |
union: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 964 |
if (bvars.length) { |
| 965 |
CToP.transforms.iteration('\u22C3','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 966 |
} else { |
| 967 |
CToP.transforms.infix('\u222A',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 968 |
} |
| 969 |
}, |
| 970 |
|
| 971 |
intersect: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 972 |
if (bvars.length) { |
| 973 |
CToP.transforms.iteration('\u22C2','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 974 |
} else { |
| 975 |
var mrow = CToP.createElement('mrow'); |
| 976 |
var needsBrackets = precedence>2; |
| 977 |
if (needsBrackets) { |
| 978 |
CToP.appendToken(mrow,'mo','('); |
| 979 |
} |
| 980 |
for (var j = 0, l = args.length; j<l; j++ ) { |
| 981 |
var argBrackets = false; |
| 982 |
if (j>0) { |
| 983 |
CToP.appendToken(mrow,'mo','\u2229'); |
| 984 |
if (args[j].nodeName === 'apply') { |
| 985 |
var child = CToP.getChildren(args[j])[0]; |
| 986 |
argBrackets = child.nodeName === 'union'; |
| 987 |
} |
| 988 |
} |
| 989 |
if (argBrackets) { |
| 990 |
CToP.appendToken(mrow,'mo','('); |
| 991 |
} |
| 992 |
CToP.applyTransform(mrow,args[j],2); |
| 993 |
if (argBrackets) { |
| 994 |
CToP.appendToken(mrow,'mo',')'); |
| 995 |
} |
| 996 |
} |
| 997 |
if (needsBrackets) { |
| 998 |
CToP.appendToken(mrow,'mo',')'); |
| 999 |
} |
| 1000 |
parentNode.appendChild(mrow); |
| 1001 |
} |
| 1002 |
}, |
| 1003 |
|
| 1004 |
floor: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1005 |
var mrow = CToP.createElement('mrow'); |
| 1006 |
CToP.appendToken(mrow,'mo','\u230a'); |
| 1007 |
CToP.applyTransform(mrow,args[0],0); |
| 1008 |
CToP.appendToken(mrow,'mo','\u230b'); |
| 1009 |
parentNode.appendChild(mrow); |
| 1010 |
}, |
| 1011 |
|
| 1012 |
conjugate: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1013 |
var mover = CToP.createElement('mover'); |
| 1014 |
CToP.applyTransform(mover,args[0],0); |
| 1015 |
CToP.appendToken(mover,'mo','\u00af'); |
| 1016 |
parentNode.appendChild(mover); |
| 1017 |
}, |
| 1018 |
|
| 1019 |
abs: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1020 |
var mrow = CToP.createElement('mrow'); |
| 1021 |
CToP.appendToken(mrow,'mo','|'); |
| 1022 |
CToP.applyTransform(mrow,args[0],0); |
| 1023 |
CToP.appendToken(mrow,'mo','|'); |
| 1024 |
parentNode.appendChild(mrow); |
| 1025 |
}, |
| 1026 |
|
| 1027 |
and: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1028 |
if (bvars.length || qualifiers.length) { |
| 1029 |
CToP.transforms.iteration('\u22c0','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,4); |
| 1030 |
} else { |
| 1031 |
CToP.transforms.infix('\u2227',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 1032 |
} |
| 1033 |
}, |
| 1034 |
|
| 1035 |
or: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1036 |
if (bvars.length || qualifiers.length) { |
| 1037 |
CToP.transforms.iteration('\u22c1','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,4); |
| 1038 |
} else { |
| 1039 |
CToP.transforms.infix('\u2228',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 1040 |
} |
| 1041 |
}, |
| 1042 |
|
| 1043 |
xor: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1044 |
if (bvars.length || qualifiers.length) { |
| 1045 |
CToP.transforms.iteration('xor','=')(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,4); |
| 1046 |
} else { |
| 1047 |
CToP.transforms.infix('xor',2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 1048 |
} |
| 1049 |
}, |
| 1050 |
|
| 1051 |
card: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1052 |
var mrow = CToP.createElement('mrow'); |
| 1053 |
CToP.appendToken(mrow,'mo','|'); |
| 1054 |
CToP.applyTransform(mrow,args[0],0); |
| 1055 |
CToP.appendToken(mrow,'mo','|'); |
| 1056 |
parentNode.appendChild(mrow); |
| 1057 |
}, |
| 1058 |
|
| 1059 |
mean: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1060 |
if (args.length === 1) { |
| 1061 |
var mover = CToP.createElement('mover'); |
| 1062 |
CToP.applyTransform(mover,args[0],0); |
| 1063 |
CToP.appendToken(mover,'mo','\u00af'); |
| 1064 |
parentNode.appendChild(mover); |
| 1065 |
} else { |
| 1066 |
parentNode.appendChild(CToP.createmfenced(args,'\u27e8','\u27e9')); |
| 1067 |
} |
| 1068 |
}, |
| 1069 |
|
| 1070 |
moment: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1071 |
var degree, momentabout, children, i, j, l; |
| 1072 |
|
| 1073 |
for (i = 0, l = qualifiers.length; i<l; i++ ) { |
| 1074 |
if (qualifiers[i].nodeName === 'degree') { |
| 1075 |
degree = qualifiers[i]; |
| 1076 |
} else if (qualifiers[i].nodeName === 'momentabout') { |
| 1077 |
momentabout = qualifiers[i]; |
| 1078 |
} |
| 1079 |
} |
| 1080 |
|
| 1081 |
var mrow = CToP.createElement('mrow'); |
| 1082 |
CToP.appendToken(mrow,'mo','\u27e8'); |
| 1083 |
var argrow = CToP.createElement('mrow'); |
| 1084 |
if (args.length>1) { |
| 1085 |
argrow.appendChild(CToP.createmfenced(args,'(',')')); |
| 1086 |
} else { |
| 1087 |
CToP.applyTransform(argrow,args[0],0); |
| 1088 |
} |
| 1089 |
if (degree) { |
| 1090 |
var msup = CToP.createElement('msup'); |
| 1091 |
msup.appendChild(argrow); |
| 1092 |
children = CToP.getChildren(degree); |
| 1093 |
for (j = 0, l = children.length; j<l; j++ ) { |
| 1094 |
CToP.applyTransform(msup,children[j],0); |
| 1095 |
} |
| 1096 |
mrow.appendChild(msup); |
| 1097 |
} else { |
| 1098 |
mrow.appendChild(argrow); |
| 1099 |
} |
| 1100 |
CToP.appendToken(mrow,'mo','\u27e9'); |
| 1101 |
|
| 1102 |
if (momentabout) { |
| 1103 |
var msub = CToP.createElement('msub'); |
| 1104 |
msub.appendChild(mrow); |
| 1105 |
children = CToP.getChildren(momentabout); |
| 1106 |
for (j = 0, l = children.length; j<l; j++ ) { |
| 1107 |
CToP.applyTransform(msub,children[j],0); |
| 1108 |
} |
| 1109 |
parentNode.appendChild(msub); |
| 1110 |
} else { |
| 1111 |
parentNode.appendChild(mrow); |
| 1112 |
} |
| 1113 |
}, |
| 1114 |
|
| 1115 |
variance: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1116 |
var mrow = CToP.createElement('mrow'); |
| 1117 |
var msup = CToP.createElement('msup'); |
| 1118 |
CToP.appendToken(msup,'mo','\u03c3'); |
| 1119 |
CToP.appendToken(msup,'mn','2'); |
| 1120 |
mrow.appendChild(msup); |
| 1121 |
CToP.appendToken(mrow,'mo','\u2061'); |
| 1122 |
mrow.appendChild(CToP.createmfenced(args,'(',')')); |
| 1123 |
parentNode.appendChild(mrow); |
| 1124 |
}, |
| 1125 |
|
| 1126 |
grad: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1127 |
var mrow = CToP.createElement('mrow'); |
| 1128 |
CToP.appendToken(mrow,'mo','\u2207'); |
| 1129 |
CToP.appendToken(mrow,'mo','\u2061'); |
| 1130 |
mrow.appendChild(CToP.createmfenced(args,'(',')')); |
| 1131 |
parentNode.appendChild(mrow); |
| 1132 |
}, |
| 1133 |
|
| 1134 |
laplacian: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1135 |
var mrow = CToP.createElement('mrow'); |
| 1136 |
var msup = CToP.createElement('msup'); |
| 1137 |
CToP.appendToken(msup,'mo','\u2207'); |
| 1138 |
CToP.appendToken(msup,'mn','2'); |
| 1139 |
mrow.appendChild(msup); |
| 1140 |
CToP.appendToken(mrow,'mo','\u2061'); |
| 1141 |
mrow.appendChild(CToP.createmfenced(args,'(',')')); |
| 1142 |
parentNode.appendChild(mrow); |
| 1143 |
}, |
| 1144 |
|
| 1145 |
curl: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1146 |
var mrow = CToP.createElement('mrow'); |
| 1147 |
CToP.appendToken(mrow,'mo','\u2207'); |
| 1148 |
CToP.appendToken(mrow,'mo','\u00d7'); |
| 1149 |
var needsBrackets = args[0].nodeName === 'apply'; |
| 1150 |
if (needsBrackets) { |
| 1151 |
mrow.appendChild(CToP.createmfenced(args,'(', ')')); |
| 1152 |
} |
| 1153 |
else { |
| 1154 |
CToP.applyTransform(mrow,args[0],precedence); |
| 1155 |
} |
| 1156 |
parentNode.appendChild(mrow); |
| 1157 |
}, |
| 1158 |
|
| 1159 |
divergence: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1160 |
var mrow = CToP.createElement('mrow'); |
| 1161 |
CToP.appendToken(mrow,'mo','\u2207'); |
| 1162 |
CToP.appendToken(mrow,'mo','\u22c5'); |
| 1163 |
var needsBrackets = args[0].nodeName === 'apply'; |
| 1164 |
if (needsBrackets) { |
| 1165 |
mrow.appendChild(CToP.createmfenced(args,'(', ')')); |
| 1166 |
} |
| 1167 |
else { |
| 1168 |
CToP.applyTransform(mrow,args[0],precedence); |
| 1169 |
} |
| 1170 |
parentNode.appendChild(mrow); |
| 1171 |
}, |
| 1172 |
|
| 1173 |
not: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1174 |
var mrow = CToP.createElement('mrow'); |
| 1175 |
CToP.appendToken(mrow,'mo','\u00ac'); |
| 1176 |
var needsBrackets = args[0].nodeName === 'apply' || args[0].nodeName === 'bind'; |
| 1177 |
if (needsBrackets) { |
| 1178 |
CToP.appendToken(mrow,'mo','('); |
| 1179 |
} |
| 1180 |
CToP.applyTransform(mrow,args[0],precedence); |
| 1181 |
if (needsBrackets) { |
| 1182 |
CToP.appendToken(mrow,'mo',')'); |
| 1183 |
} |
| 1184 |
parentNode.appendChild(mrow) |
| 1185 |
}, |
| 1186 |
|
| 1187 |
divide: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1188 |
var mfrac = CToP.createElement('mfrac'); |
| 1189 |
CToP.applyTransform(mfrac,args[0],0); |
| 1190 |
CToP.applyTransform(mfrac,args[1],0); |
| 1191 |
parentNode.appendChild(mfrac); |
| 1192 |
}, |
| 1193 |
|
| 1194 |
tendsto: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1195 |
var type; |
| 1196 |
if (firstArg.nodeName === 'tendsto') { |
| 1197 |
type = firstArg.getAttribute('type'); |
| 1198 |
} else { |
| 1199 |
type = CToP.getTextContent(args[0]); |
| 1200 |
args = args.slice(1); |
| 1201 |
} |
| 1202 |
var name = (type === 'above')? '\u2198' : |
| 1203 |
(type === 'below') ? '\u2197' : '\u2192' ; |
| 1204 |
CToP.transforms.binary(name,2)(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence); |
| 1205 |
}, |
| 1206 |
|
| 1207 |
minus: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1208 |
var tokenPrecedence = args.length === 1 ? 5 : 2; |
| 1209 |
|
| 1210 |
var mrow = CToP.createElement('mrow'); |
| 1211 |
var needsBrackets = tokenPrecedence<precedence; |
| 1212 |
if (needsBrackets) { |
| 1213 |
CToP.appendToken(mrow,'mo','('); |
| 1214 |
} |
| 1215 |
|
| 1216 |
if (args.length === 1) { |
| 1217 |
CToP.appendToken(mrow,'mo','-'); |
| 1218 |
CToP.applyTransform(mrow,args[0],tokenPrecedence); |
| 1219 |
} else { |
| 1220 |
CToP.applyTransform(mrow,args[0],tokenPrecedence); |
| 1221 |
CToP.appendToken(mrow,'mo','-'); |
| 1222 |
var bracketArg; |
| 1223 |
if (args[1].nodeName === 'apply') { |
| 1224 |
var argOp = CToP.getChildren(args[1])[0]; |
| 1225 |
bracketArg = argOp.nodeName === 'plus' || argOp.nodeName === 'minus'; |
| 1226 |
} |
| 1227 |
if (bracketArg) { |
| 1228 |
CToP.appendToken(mrow,'mo','('); |
| 1229 |
} |
| 1230 |
CToP.applyTransform(mrow,args[1],tokenPrecedence); |
| 1231 |
if (bracketArg) { |
| 1232 |
CToP.appendToken(mrow,'mo',')'); |
| 1233 |
} |
| 1234 |
} |
| 1235 |
|
| 1236 |
if (needsBrackets) { |
| 1237 |
CToP.appendToken(mrow,'mo',')'); |
| 1238 |
} |
| 1239 |
parentNode.appendChild(mrow); |
| 1240 |
}, |
| 1241 |
|
| 1242 |
"complex-cartesian": function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1243 |
var mrow = CToP.createElement('mrow'); |
| 1244 |
CToP.applyTransform(mrow,args[0],0); |
| 1245 |
CToP.appendToken(mrow,'mo','+'); |
| 1246 |
CToP.applyTransform(mrow,args[1],0); |
| 1247 |
CToP.appendToken(mrow,'mo','\u2062'); |
| 1248 |
CToP.appendToken(mrow,'mi','i'); |
| 1249 |
parentNode.appendChild(mrow); |
| 1250 |
}, |
| 1251 |
|
| 1252 |
"complex-polar": function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1253 |
var mrow = CToP.createElement('mrow'); |
| 1254 |
CToP.applyTransform(mrow,args[0],0); |
| 1255 |
CToP.appendToken(mrow,'mo','\u2062'); |
| 1256 |
var msup = CToP.createElement('msup'); |
| 1257 |
CToP.appendToken(msup,'mi','e'); |
| 1258 |
var exponent = CToP.createElement('mrow'); |
| 1259 |
CToP.applyTransform(exponent,args[1],0); |
| 1260 |
CToP.appendToken(exponent,'mo','\u2062'); |
| 1261 |
CToP.appendToken(exponent,'mi','i'); |
| 1262 |
msup.appendChild(exponent); |
| 1263 |
mrow.appendChild(msup); |
| 1264 |
parentNode.appendChild(mrow); |
| 1265 |
}, |
| 1266 |
|
| 1267 |
integer: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1268 |
CToP.applyTransform(parentNode,args[0],0); |
| 1269 |
}, |
| 1270 |
|
| 1271 |
"based-integer": function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1272 |
var msub = CToP.createElement('msub'); |
| 1273 |
CToP.applyTransform(msub,args[1],0); |
| 1274 |
CToP.applyTransform(msub,args[0],0); |
| 1275 |
parentNode.appendChild(msub); |
| 1276 |
}, |
| 1277 |
|
| 1278 |
rational: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1279 |
var mfrac = CToP.createElement('mfrac'); |
| 1280 |
CToP.applyTransform(mfrac,args[0],0); |
| 1281 |
CToP.applyTransform(mfrac,args[1],0); |
| 1282 |
parentNode.appendChild(mfrac); |
| 1283 |
}, |
| 1284 |
|
| 1285 |
times: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1286 |
var mrow = CToP.createElement('mrow'); |
| 1287 |
var needsBrackets = precedence>3; |
| 1288 |
if (needsBrackets) { |
| 1289 |
CToP.appendToken(mrow,'mo','('); |
| 1290 |
} |
| 1291 |
for (var j = 0, l = args.length; j<l; j++ ) { |
| 1292 |
if (j>0) { |
| 1293 |
CToP.appendToken(mrow,'mo',(args[j].nodeName === 'cn') ? "\u00D7" :"\u2062"); |
| 1294 |
} |
| 1295 |
CToP.applyTransform(mrow,args[j],3); |
| 1296 |
} |
| 1297 |
if (needsBrackets) { |
| 1298 |
CToP.appendToken(mrow,'mo',')'); |
| 1299 |
} |
| 1300 |
parentNode.appendChild(mrow); |
| 1301 |
}, |
| 1302 |
|
| 1303 |
plus: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1304 |
var mrow = CToP.createElement('mrow'); |
| 1305 |
var needsBrackets = precedence>2; |
| 1306 |
if (needsBrackets) { |
| 1307 |
CToP.appendToken(mrow,'mo','('); |
| 1308 |
} |
| 1309 |
for (var j = 0, l = args.length; j<l; j++ ) { |
| 1310 |
var arg = args[j]; |
| 1311 |
var children = CToP.getChildren(arg); |
| 1312 |
if (j>0) { |
| 1313 |
var n; |
| 1314 |
if (CToP.settings.collapsePlusMinus) { |
| 1315 |
if (arg.nodeName === 'cn' && !(children.length) && (n = Number(CToP.getTextContent(arg))) <0) { |
| 1316 |
CToP.appendToken(mrow,'mo','\u2212'); |
| 1317 |
CToP.appendToken(mrow,'mn', -n); |
| 1318 |
} else if (arg.nodeName === 'apply' && children.length === 2 && children[0].nodeName === 'minus') { |
| 1319 |
CToP.appendToken(mrow,'mo','\u2212'); |
| 1320 |
CToP.applyTransform(mrow,children[1],2); |
| 1321 |
} else if (arg.nodeName === 'apply' && children.length>2 && children[0].nodeName === 'times' && children[1].nodeName === 'cn' && (n = Number(CToP.getTextContent(children[1]))) < 0) { |
| 1322 |
CToP.appendToken(mrow,'mo','\u2212'); |
| 1323 |
children[1].textContent = -n; // OK to change MathML since it is being discarded afterward |
| 1324 |
CToP.applyTransform(mrow,arg,2); |
| 1325 |
} else{ |
| 1326 |
CToP.appendToken(mrow,'mo','+'); |
| 1327 |
CToP.applyTransform(mrow,arg,2); |
| 1328 |
} |
| 1329 |
} else { |
| 1330 |
CToP.appendToken(mrow,'mo','+'); |
| 1331 |
CToP.applyTransform(mrow,arg,2); |
| 1332 |
} |
| 1333 |
} else { |
| 1334 |
CToP.applyTransform(mrow,arg,2); |
| 1335 |
} |
| 1336 |
} |
| 1337 |
if (needsBrackets) { |
| 1338 |
CToP.appendToken(mrow,'mo',')'); |
| 1339 |
} |
| 1340 |
parentNode.appendChild(mrow); |
| 1341 |
}, |
| 1342 |
|
| 1343 |
transpose: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1344 |
var msup = CToP.createElement('msup'); |
| 1345 |
CToP.applyTransform(msup,args[0],precedence); |
| 1346 |
CToP.appendToken(msup,'mi','T'); |
| 1347 |
parentNode.appendChild(msup); |
| 1348 |
}, |
| 1349 |
|
| 1350 |
power: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1351 |
var msup = CToP.createElement('msup'); |
| 1352 |
CToP.applyTransform(msup,args[0],3); |
| 1353 |
CToP.applyTransform(msup,args[1],precedence); |
| 1354 |
parentNode.appendChild(msup); |
| 1355 |
}, |
| 1356 |
|
| 1357 |
selector: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1358 |
var msub = CToP.createElement('msub'); |
| 1359 |
var mrow = args ? args[0]: CToP.createElement('mrow'); |
| 1360 |
CToP.applyTransform(msub,mrow,0); |
| 1361 |
var mrow2 = CToP.createElement('mrow'); |
| 1362 |
for (var i = 1, l = args.length; i<l; i++ ) { |
| 1363 |
if (i != 1) { |
| 1364 |
CToP.appendToken(mrow2,'mo',','); |
| 1365 |
} |
| 1366 |
CToP.applyTransform(mrow2,args[i],0); |
| 1367 |
} |
| 1368 |
msub.appendChild(mrow2); |
| 1369 |
parentNode.appendChild(msub); |
| 1370 |
}, |
| 1371 |
|
| 1372 |
log: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1373 |
var mrow = CToP.createElement('mrow'); |
| 1374 |
var mi = CToP.createElement('mi'); |
| 1375 |
CToP.setTextContent(mi,'log'); |
| 1376 |
if (qualifiers.length && qualifiers[0].nodeName === 'logbase') { |
| 1377 |
var msub = CToP.createElement('msub'); |
| 1378 |
msub.appendChild(mi); |
| 1379 |
CToP.applyTransform(msub,CToP.getChildren(qualifiers[0])[0],0); |
| 1380 |
mrow.appendChild(msub); |
| 1381 |
} else { |
| 1382 |
mrow.appendChild(mi); |
| 1383 |
} |
| 1384 |
CToP.applyTransform(mrow,args[0],7); |
| 1385 |
parentNode.appendChild(mrow); |
| 1386 |
}, |
| 1387 |
|
| 1388 |
"int": function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1389 |
var mrow = CToP.createElement('mrow'); |
| 1390 |
var mo = CToP.createElement('mo'); |
| 1391 |
CToP.setTextContent(mo,'\u222B'); |
| 1392 |
var msubsup = CToP.createElement('msubsup'); |
| 1393 |
msubsup.appendChild(mo); |
| 1394 |
var mrow1 = CToP.createElement('mrow'); |
| 1395 |
var children, i, j, l, num_qualifiers, num_children; |
| 1396 |
for (i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) { |
| 1397 |
if (qualifiers[i].nodeName === 'lowlimit'|| |
| 1398 |
qualifiers[i].nodeName === 'condition'|| |
| 1399 |
qualifiers[i].nodeName === 'domainofapplication') |
| 1400 |
{ |
| 1401 |
children = CToP.getChildren(qualifiers[i]); |
| 1402 |
for (j = 0, num_children = children.length; j<num_children; j++ ) { |
| 1403 |
CToP.applyTransform(mrow1,children[j],0); |
| 1404 |
} |
| 1405 |
} else { |
| 1406 |
children = CToP.getChildren(qualifiers[i]); |
| 1407 |
if (qualifiers[i].nodeName === 'interval' && children.length === 2) { |
| 1408 |
CToP.applyTransform(mrow1,children[0],0); |
| 1409 |
} |
| 1410 |
} |
| 1411 |
} |
| 1412 |
msubsup.appendChild(mrow1); |
| 1413 |
var mrow2 = CToP.createElement('mrow'); |
| 1414 |
for (i = 0, num_qualifiers = qualifiers.length; i<num_qualifiers; i++ ) { |
| 1415 |
if (qualifiers[i].nodeName === 'uplimit') { |
| 1416 |
children = CToP.getChildren(qualifiers[i]); |
| 1417 |
for (j = 0, num_children = children.length; j<num_children; j++ ) { |
| 1418 |
CToP.applyTransform(mrow2,children[j],0); |
| 1419 |
} |
| 1420 |
break; |
| 1421 |
} else if (qualifiers[i].nodeName === 'interval' ) { |
| 1422 |
children = CToP.getChildren(qualifiers[i]); |
| 1423 |
CToP.applyTransform(mrow2,children[children.length-1],0); |
| 1424 |
break; |
| 1425 |
} |
| 1426 |
} |
| 1427 |
msubsup.appendChild(mrow2); |
| 1428 |
mrow.appendChild(msubsup); |
| 1429 |
for (i = 0, l = args.length; i<l; i++ ) { |
| 1430 |
CToP.applyTransform(mrow,args[i],0); |
| 1431 |
} |
| 1432 |
for (i = 0, l = bvars.length; i<l; i++ ) { |
| 1433 |
var bvar = bvars[i]; |
| 1434 |
children = CToP.getChildren(bvar); |
| 1435 |
if (children.length) { |
| 1436 |
var mrow3 = CToP.createElement("mrow"); |
| 1437 |
CToP.appendToken(mrow3,'mi','d'); |
| 1438 |
CToP.applyTransform(mrow3,children[0],0); |
| 1439 |
mrow.appendChild(mrow3); |
| 1440 |
} |
| 1441 |
} |
| 1442 |
parentNode.appendChild(mrow); |
| 1443 |
}, |
| 1444 |
|
| 1445 |
inverse: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1446 |
var msup = CToP.createElement('msup'); |
| 1447 |
var arg = (args.length) ? args[0] : CToP.createElement('mrow'); |
| 1448 |
CToP.applyTransform(msup,arg,precedence); |
| 1449 |
var mfenced = CToP.createElement('mfenced'); |
| 1450 |
CToP.appendToken(mfenced,'mn','-1'); |
| 1451 |
msup.appendChild(mfenced); |
| 1452 |
parentNode.appendChild(msup); |
| 1453 |
}, |
| 1454 |
|
| 1455 |
quotient: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1456 |
var mrow = CToP.createElement('mrow'); |
| 1457 |
CToP.appendToken(mrow,'mo','\u230A'); |
| 1458 |
if (args.length) { |
| 1459 |
CToP.applyTransform(mrow,args[0],0); |
| 1460 |
CToP.appendToken(mrow,'mo','/'); |
| 1461 |
if (args.length>1) { |
| 1462 |
CToP.applyTransform(mrow,args[1],0); |
| 1463 |
} |
| 1464 |
} |
| 1465 |
CToP.appendToken(mrow,'mo','\u230B'); |
| 1466 |
parentNode.appendChild(mrow); |
| 1467 |
}, |
| 1468 |
|
| 1469 |
factorial: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1470 |
var mrow = CToP.createElement('mrow'); |
| 1471 |
CToP.applyTransform(mrow,args[0],4); |
| 1472 |
CToP.appendToken(mrow,'mo','!'); |
| 1473 |
parentNode.appendChild(mrow); |
| 1474 |
}, |
| 1475 |
|
| 1476 |
root: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1477 |
var mr; |
| 1478 |
if (firstArg.nodeName === 'root' && (qualifiers.length === 0 || (qualifiers[0].nodeName === 'degree' && CToP.getTextContent(qualifiers[0]) === '2'))) { |
| 1479 |
mr = CToP.createElement('msqrt'); |
| 1480 |
for (var i = 0, l = args.length; i<l; i++ ) { |
| 1481 |
CToP.applyTransform(mr,args[i],0); |
| 1482 |
} |
| 1483 |
} else { |
| 1484 |
mr = CToP.createElement('mroot'); |
| 1485 |
CToP.applyTransform(mr,args[0],0); |
| 1486 |
var arg = (firstArg.nodeName === 'root') ? qualifiers[0].childNodes[0] : args[1]; |
| 1487 |
CToP.applyTransform(mr,arg,0); |
| 1488 |
} |
| 1489 |
parentNode.appendChild(mr); |
| 1490 |
}, |
| 1491 |
|
| 1492 |
diff: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1493 |
if (bvars.length) { // d/dx form |
| 1494 |
var outNode; |
| 1495 |
var mfrac = CToP.createElement('mfrac'); |
| 1496 |
var toprow = CToP.createElement('mrow'); |
| 1497 |
var bottomrow = CToP.createElement('mrow'); |
| 1498 |
mfrac.appendChild(toprow); |
| 1499 |
mfrac.appendChild(bottomrow); |
| 1500 |
|
| 1501 |
var bvar, degreeNode, msup, mrow; |
| 1502 |
|
| 1503 |
var d = CToP.createElement('mi'); |
| 1504 |
CToP.setTextContent(d,'d'); |
| 1505 |
|
| 1506 |
var children = CToP.getChildren(bvars[0]); |
| 1507 |
for (var j = 0, l = children.length; j<l; j++ ) { |
| 1508 |
if (children[j].nodeName === 'degree') { |
| 1509 |
var childNode = CToP.getChildren(children[j])[0]; |
| 1510 |
if (CToP.getTextContent(childNode) != '1') { |
| 1511 |
degreeNode = childNode; |
| 1512 |
msup = CToP.createElement('msup'); |
| 1513 |
msup.appendChild(d); |
| 1514 |
d = msup; |
| 1515 |
CToP.applyTransform(d,degreeNode,0); |
| 1516 |
} |
| 1517 |
} else { |
| 1518 |
bvar = children[j]; |
| 1519 |
} |
| 1520 |
} |
| 1521 |
toprow.appendChild(d); |
| 1522 |
|
| 1523 |
if (args.length) { |
| 1524 |
switch(args[0].nodeName) { |
| 1525 |
case 'apply': |
| 1526 |
case 'bind': |
| 1527 |
case 'reln': |
| 1528 |
mrow = CToP.createElement('mrow'); |
| 1529 |
mrow.appendChild(mfrac); |
| 1530 |
CToP.applyTransform(mrow,args[0],3); |
| 1531 |
outNode = mrow; |
| 1532 |
break; |
| 1533 |
default: |
| 1534 |
CToP.applyTransform(toprow,args[0],0); |
| 1535 |
outNode = mfrac; |
| 1536 |
} |
| 1537 |
} |
| 1538 |
|
| 1539 |
CToP.appendToken(bottomrow,'mi','d'); |
| 1540 |
|
| 1541 |
if (degreeNode) { |
| 1542 |
var msup2 = CToP.createElement('msup'); |
| 1543 |
CToP.applyTransform(msup2,bvar,0); |
| 1544 |
CToP.applyTransform(msup2,degreeNode,0); |
| 1545 |
bottomrow.appendChild(msup2); |
| 1546 |
} else { |
| 1547 |
CToP.applyTransform(bottomrow,bvar,0); |
| 1548 |
} |
| 1549 |
|
| 1550 |
|
| 1551 |
parentNode.appendChild(outNode); |
| 1552 |
} else { // f' form |
| 1553 |
msup = CToP.createElement('msup'); |
| 1554 |
mrow = CToP.createElement('mrow'); |
| 1555 |
msup.appendChild(mrow); |
| 1556 |
CToP.applyTransform(mrow,args[0],0); |
| 1557 |
CToP.appendToken(msup,'mo','\u2032'); // tick |
| 1558 |
parentNode.appendChild(msup); |
| 1559 |
} |
| 1560 |
}, |
| 1561 |
|
| 1562 |
partialdiff: function(parentNode,contentMMLNode,firstArg,args,bvars,qualifiers,precedence) { |
| 1563 |
var msup, msub, mrow; |
| 1564 |
|
| 1565 |
var mfrac = CToP.createElement('mfrac'); |
| 1566 |
var toprow = CToP.createElement('mrow'); |
| 1567 |
var bottomrow = CToP.createElement('mrow'); |
| 1568 |
mfrac.appendChild(toprow); |
| 1569 |
mfrac.appendChild(bottomrow); |
| 1570 |
|
| 1571 |
var differendNode, degree, children; |
| 1572 |
|
| 1573 |
if (bvars.length === 0 && args.length === 2 && args[0].nodeName === 'list') { |
| 1574 |
if (args[1].nodeName === 'lambda') { // `d^(n+m)/(dx^n dy^m) f` form, through a lambda |
| 1575 |
degree = CToP.getChildren(args[0]).length; |
| 1576 |
if (degree != 1) { |
| 1577 |
msup = CToP.createElement('msup'); |
| 1578 |
CToP.appendToken(msup,'mo','\u2202'); // curly d |
| 1579 |
CToP.appendToken(msup,'mn',degree); |
| 1580 |
toprow.appendChild(msup); |
| 1581 |
} else { |
| 1582 |
CToP.appendToken(toprow,'mo','\u2202'); |
| 1583 |
} |
| 1584 |
|
| 1585 |
children = CToP.getChildren(args[1]); |
| 1586 |
|
| 1587 |
differendNode = children[children.length - 1]; // thing being differentiated |
| 1588 |
|
| 1589 |
var bvarNames = []; |
| 1590 |
var lambdaChildren = CToP.getChildren(args[1]); // names of bound variables |
| 1591 |
var lambdaSequence = CToP.getChildren(args[0]); // indices of bound variable names, in order |
| 1592 |
for (var i = 0, l = lambdaChildren.length; i<l; i++ ) { |
| 1593 |
if (lambdaChildren[i].nodeName === 'bvar') { |
| 1594 |
bvarNames.push(CToP.getChildren(lambdaChildren[i])[0]); |
| 1595 |
} |
| 1596 |
} |
| 1597 |
|
| 1598 |
var lastN = null; |
| 1599 |
degree = 0; |
| 1600 |
function addDiff(n,degree) { |
| 1601 |
CToP.appendToken(bottomrow,'mo','\u2202'); |
| 1602 |
var bvar = bvarNames[n]; |
| 1603 |
if (degree>1) { |
| 1604 |
var msup = CToP.createElement('msup'); |
| 1605 |
CToP.applyTransform(msup,bvar,0); |
| 1606 |
CToP.appendToken(msup,'mn',degree); |
| 1607 |
bottomrow.appendChild(msup); |
| 1608 |
} else { |
| 1609 |
CToP.applyTransform(bottomrow,bvar,0); |
| 1610 |
} |
| 1611 |
} |
| 1612 |
for (i = 0, l = lambdaSequence.length; i<l; i++ ) { |
| 1613 |
var n = Number(CToP.getTextContent(lambdaSequence[i]))-1; |
| 1614 |
if (lastN !== null && n != lastN) { |
| 1615 |
addDiff(lastN,degree); |
| 1616 |
degree = 0; |
| 1617 |
} |
| 1618 |
lastN = n; |
| 1619 |
degree += 1; |
| 1620 |
} |
| 1621 |
if (lastN) { |
| 1622 |
addDiff(lastN,degree); |
| 1623 |
} |
| 1624 |
} else { // `D_i_j f` form |
| 1625 |
mrow = CToP.createElement('mrow'); |
| 1626 |
msub = CToP.createElement('msub'); |
| 1627 |
CToP.appendToken(msub,'mi','D'); |
| 1628 |
var bvar = CToP.getChildren(args[0]); |
| 1629 |
msub.appendChild(CToP.createmfenced(bvar,'','')); |
| 1630 |
mrow.appendChild(msub); |
| 1631 |
CToP.applyTransform(mrow,args[1],0); |
| 1632 |
parentNode.appendChild(mrow); |
| 1633 |
return; |
| 1634 |
} |
| 1635 |
} else { // `d^(n+m)/(dx^n dy^m) f` form, with bvars |
| 1636 |
msup = CToP.createElement('msup'); |
| 1637 |
toprow.appendChild(msup); |
| 1638 |
CToP.appendToken(msup,'mo','\u2202'); |
| 1639 |
|
| 1640 |
var degreeRow = CToP.createElement('mrow'); |
| 1641 |
msup.appendChild(degreeRow); |
| 1642 |
|
| 1643 |
var qualifier; |
| 1644 |
|
| 1645 |
if (qualifiers.length && qualifiers[0].nodeName === 'degree' && CToP.getChildren(qualifiers[0]).length) { |
| 1646 |
qualifier = CToP.getChildren(qualifiers[0])[0]; |
| 1647 |
CToP.applyTransform(degreeRow,qualifier,0); |
| 1648 |
} else { |
| 1649 |
degree = 0; |
| 1650 |
var hadFirst = false; |
| 1651 |
for (i = 0, l = bvars.length; i<l; i++ ) { |
| 1652 |
children = CToP.getChildren(bvars[i]); |
| 1653 |
if (children.length === 2) { |
| 1654 |
for (var j = 0;j<2;j++) { |
| 1655 |
if (children[j].nodeName === 'degree') { |
| 1656 |
if (/^\s*\d+\s*$/.test(CToP.getTextContent(children[j]))) { |
| 1657 |
degree += Number(CToP.getTextContent(children[j])); |
| 1658 |
} else { |
| 1659 |
if (hadFirst) { |
| 1660 |
CToP.appendToken(degreeRow,'mo','+'); |
| 1661 |
} |
| 1662 |
hadFirst = true; |
| 1663 |
CToP.applyTransform(degreeRow,CToP.getChildren(children[j])[0],0); |
| 1664 |
} |
| 1665 |
} |
| 1666 |
} |
| 1667 |
} else { |
| 1668 |
degree++; |
| 1669 |
} |
| 1670 |
} |
| 1671 |
if (degree>0) { |
| 1672 |
if (hadFirst) { |
| 1673 |
CToP.appendToken(degreeRow,'mo','+'); |
| 1674 |
} |
| 1675 |
CToP.appendToken(degreeRow,'mn',degree); |
| 1676 |
} |
| 1677 |
} |
| 1678 |
|
| 1679 |
if (args.length) { |
| 1680 |
differendNode = args[0]; |
| 1681 |
} |
| 1682 |
|
| 1683 |
for (i = 0, l = bvars.length; i<l; i++ ) { |
| 1684 |
CToP.appendToken(bottomrow,'mo','\u2202'); |
| 1685 |
children = CToP.getChildren(bvars[i]); |
| 1686 |
|
| 1687 |
if (children.length === 2) { |
| 1688 |
for (j = 0;j<2;j++) { |
| 1689 |
if (children[j].nodeName === 'degree') { |
| 1690 |
var msup2 = CToP.createElement('msup'); |
| 1691 |
CToP.applyTransform(msup2,children[1-j],0); |
| 1692 |
var bvarDegreeNode = CToP.getChildren(children[j])[0]; |
| 1693 |
CToP.applyTransform(msup2,bvarDegreeNode,0); |
| 1694 |
bottomrow.appendChild(msup2); |
| 1695 |
} |
| 1696 |
} |
| 1697 |
} else if (children.length === 1) { |
| 1698 |
CToP.applyTransform(bottomrow,children[0],0); |
| 1699 |
} |
| 1700 |
} |
| 1701 |
} |
| 1702 |
if (differendNode) { |
| 1703 |
switch(differendNode.nodeName) { |
| 1704 |
case 'apply': |
| 1705 |
case 'bind': |
| 1706 |
case 'reln': |
| 1707 |
mrow = CToP.createElement('mrow'); |
| 1708 |
mrow.appendChild(mfrac); |
| 1709 |
CToP.applyTransform(mrow,differendNode,3); |
| 1710 |
outNode = mrow; |
| 1711 |
break; |
| 1712 |
default: |
| 1713 |
CToP.applyTransform(toprow,differendNode,0); |
| 1714 |
outNode = mfrac; |
| 1715 |
} |
| 1716 |
} else { |
| 1717 |
outNode = mfrac; |
| 1718 |
} |
| 1719 |
parentNode.appendChild(outNode); |
| 1720 |
} |
| 1721 |
}; |
| 1722 |
CToP.applyTokens.size = CToP.applyTokens.card; |
| 1723 |
|
| 1724 |
return CToP; |
| 1725 |
})(MathJax.Hub); |
| 1726 |
|
| 1727 |
|
| 1728 |
MathJax.Hub.Register.StartupHook("MathML Jax Ready",function () { |
| 1729 |
|
| 1730 |
var MATHML = MathJax.InputJax.MathML; |
| 1731 |
|
| 1732 |
var CToP = MathJax.Extension["MathML/content-mathml"]; |
| 1733 |
CToP.mbase = MathJax.ElementJax.mml.mbase; |
| 1734 |
CToP.MML = MathJax.ElementJax.mml; |
| 1735 |
|
| 1736 |
MATHML.DOMfilterHooks.Add(function (data) { |
| 1737 |
data.math = CToP.transformElement(data.math); |
| 1738 |
}); |
| 1739 |
|
| 1740 |
MathJax.Hub.Startup.signal.Post("MathML/content-mathml Ready"); |
| 1741 |
}); |
| 1742 |
|
| 1743 |
MathJax.Ajax.loadComplete("[MathJax]/extensions/MathML/content-mathml.js"); |