Debian Codegraph @

unpacked/extensions/MathML/content-mathml.js

raw
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>&#x2212;</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");