Coverage for /usr/lib/python3/dist-packages/sympy/printing/mathml.py: 12%

1""" 

2A MathML printer. 

3""" 

4 

5from __future__ import annotations 

6from typing import Any 

7 

8from sympy.core.mul import Mul 

9from sympy.core.singleton import S 

10from sympy.core.sorting import default_sort_key 

11from sympy.core.sympify import sympify 

12from sympy.printing.conventions import split_super_sub, requires_partial 

13from sympy.printing.precedence import \ 

14 precedence_traditional, PRECEDENCE, PRECEDENCE_TRADITIONAL 

15from sympy.printing.pretty.pretty_symbology import greek_unicode 

16from sympy.printing.printer import Printer, print_function 

17 

18from mpmath.libmp import prec_to_dps, repr_dps, to_str as mlib_to_str 

19 

20 

21class MathMLPrinterBase(Printer): 

22 """Contains common code required for MathMLContentPrinter and 

23 MathMLPresentationPrinter. 

24 """ 

25 

26 _default_settings: dict[str, Any] = { 

27 "order": None, 

28 "encoding": "utf-8", 

29 "fold_frac_powers": False, 

30 "fold_func_brackets": False, 

31 "fold_short_frac": None, 

32 "inv_trig_style": "abbreviated", 

33 "ln_notation": False, 

34 "long_frac_ratio": None, 

35 "mat_delim": "[", 

36 "mat_symbol_style": "plain", 

37 "mul_symbol": None, 

38 "root_notation": True, 

39 "symbol_names": {}, 

40 "mul_symbol_mathml_numbers": '·', 

41 } 

42 

43 def __init__(self, settings=None): 

44 Printer.__init__(self, settings) 

45 from xml.dom.minidom import Document, Text 

46 

47 self.dom = Document() 

48 

49 # Workaround to allow strings to remain unescaped 

50 # Based on 

51 # https://stackoverflow.com/questions/38015864/python-xml-dom-minidom-\ 

52 # please-dont-escape-my-strings/38041194 

53 class RawText(Text): 

54 def writexml(self, writer, indent='', addindent='', newl=''): 

55 if self.data: 

56 writer.write('{}{}{}'.format(indent, self.data, newl)) 

57 

58 def createRawTextNode(data): 

59 r = RawText() 

60 r.data = data 

61 r.ownerDocument = self.dom 

62 return r 

63 

64 self.dom.createTextNode = createRawTextNode 

65 

66 def doprint(self, expr): 

67 """ 

68 Prints the expression as MathML. 

69 """ 

70 mathML = Printer._print(self, expr) 

71 unistr = mathML.toxml() 

72 xmlbstr = unistr.encode('ascii', 'xmlcharrefreplace') 

73 res = xmlbstr.decode() 

74 return res 

75 

76 def apply_patch(self): 

77 # Applying the patch of xml.dom.minidom bug 

78 # Date: 2011-11-18 

79 # Description: http://ronrothman.com/public/leftbraned/xml-dom-minidom\ 

80 # -toprettyxml-and-silly-whitespace/#best-solution 

81 # Issue: https://bugs.python.org/issue4147 

82 # Patch: https://hg.python.org/cpython/rev/7262f8f276ff/ 

83 

84 from xml.dom.minidom import Element, Text, Node, _write_data 

85 

86 def writexml(self, writer, indent="", addindent="", newl=""): 

87 # indent = current indentation 

88 # addindent = indentation to add to higher levels 

89 # newl = newline string 

90 writer.write(indent + "<" + self.tagName) 

91 

92 attrs = self._get_attributes() 

93 a_names = list(attrs.keys()) 

94 a_names.sort() 

95 

96 for a_name in a_names: 

97 writer.write(" %s=\"" % a_name) 

98 _write_data(writer, attrs[a_name].value) 

99 writer.write("\"") 

100 if self.childNodes: 

101 writer.write(">") 

102 if (len(self.childNodes) == 1 and 

103 self.childNodes[0].nodeType == Node.TEXT_NODE): 

104 self.childNodes[0].writexml(writer, '', '', '') 

105 else: 

106 writer.write(newl) 

107 for node in self.childNodes: 

108 node.writexml( 

109 writer, indent + addindent, addindent, newl) 

110 writer.write(indent) 

111 writer.write("</%s>%s" % (self.tagName, newl)) 

112 else: 

113 writer.write("/>%s" % (newl)) 

114 self._Element_writexml_old = Element.writexml 

115 Element.writexml = writexml 

116 

117 def writexml(self, writer, indent="", addindent="", newl=""): 

118 _write_data(writer, "%s%s%s" % (indent, self.data, newl)) 

119 self._Text_writexml_old = Text.writexml 

120 Text.writexml = writexml 

121 

122 def restore_patch(self): 

123 from xml.dom.minidom import Element, Text 

124 Element.writexml = self._Element_writexml_old 

125 Text.writexml = self._Text_writexml_old 

126 

127 

128class MathMLContentPrinter(MathMLPrinterBase): 

129 """Prints an expression to the Content MathML markup language. 

130 

131 References: https://www.w3.org/TR/MathML2/chapter4.html 

132 """ 

133 printmethod = "_mathml_content" 

134 

135 def mathml_tag(self, e): 

136 """Returns the MathML tag for an expression.""" 

137 translate = { 

138 'Add': 'plus', 

139 'Mul': 'times', 

140 'Derivative': 'diff', 

141 'Number': 'cn', 

142 'int': 'cn', 

143 'Pow': 'power', 

144 'Max': 'max', 

145 'Min': 'min', 

146 'Abs': 'abs', 

147 'And': 'and', 

148 'Or': 'or', 

149 'Xor': 'xor', 

150 'Not': 'not', 

151 'Implies': 'implies', 

152 'Symbol': 'ci', 

153 'MatrixSymbol': 'ci', 

154 'RandomSymbol': 'ci', 

155 'Integral': 'int', 

156 'Sum': 'sum', 

157 'sin': 'sin', 

158 'cos': 'cos', 

159 'tan': 'tan', 

160 'cot': 'cot', 

161 'csc': 'csc', 

162 'sec': 'sec', 

163 'sinh': 'sinh', 

164 'cosh': 'cosh', 

165 'tanh': 'tanh', 

166 'coth': 'coth', 

167 'csch': 'csch', 

168 'sech': 'sech', 

169 'asin': 'arcsin', 

170 'asinh': 'arcsinh', 

171 'acos': 'arccos', 

172 'acosh': 'arccosh', 

173 'atan': 'arctan', 

174 'atanh': 'arctanh', 

175 'atan2': 'arctan', 

176 'acot': 'arccot', 

177 'acoth': 'arccoth', 

178 'asec': 'arcsec', 

179 'asech': 'arcsech', 

180 'acsc': 'arccsc', 

181 'acsch': 'arccsch', 

182 'log': 'ln', 

183 'Equality': 'eq', 

184 'Unequality': 'neq', 

185 'GreaterThan': 'geq', 

186 'LessThan': 'leq', 

187 'StrictGreaterThan': 'gt', 

188 'StrictLessThan': 'lt', 

189 'Union': 'union', 

190 'Intersection': 'intersect', 

191 } 

192 

193 for cls in e.__class__.__mro__: 

194 n = cls.__name__ 

195 if n in translate: 

196 return translate[n] 

197 # Not found in the MRO set 

198 n = e.__class__.__name__ 

199 return n.lower() 

200 

201 def _print_Mul(self, expr): 

202 

203 if expr.could_extract_minus_sign(): 

204 x = self.dom.createElement('apply') 

205 x.appendChild(self.dom.createElement('minus')) 

206 x.appendChild(self._print_Mul(-expr)) 

207 return x 

208 

209 from sympy.simplify import fraction 

210 numer, denom = fraction(expr) 

211 

212 if denom is not S.One: 

213 x = self.dom.createElement('apply') 

214 x.appendChild(self.dom.createElement('divide')) 

215 x.appendChild(self._print(numer)) 

216 x.appendChild(self._print(denom)) 

217 return x 

218 

219 coeff, terms = expr.as_coeff_mul() 

220 if coeff is S.One and len(terms) == 1: 

221 # XXX since the negative coefficient has been handled, I don't 

222 # think a coeff of 1 can remain 

223 return self._print(terms[0]) 

224 

225 if self.order != 'old': 

226 terms = Mul._from_args(terms).as_ordered_factors() 

227 

228 x = self.dom.createElement('apply') 

229 x.appendChild(self.dom.createElement('times')) 

230 if coeff != 1: 

231 x.appendChild(self._print(coeff)) 

232 for term in terms: 

233 x.appendChild(self._print(term)) 

234 return x 

235 

236 def _print_Add(self, expr, order=None): 

237 args = self._as_ordered_terms(expr, order=order) 

238 lastProcessed = self._print(args[0]) 

239 plusNodes = [] 

240 for arg in args[1:]: 

241 if arg.could_extract_minus_sign(): 

242 # use minus 

243 x = self.dom.createElement('apply') 

244 x.appendChild(self.dom.createElement('minus')) 

245 x.appendChild(lastProcessed) 

246 x.appendChild(self._print(-arg)) 

247 # invert expression since this is now minused 

248 lastProcessed = x 

249 if arg == args[-1]: 

250 plusNodes.append(lastProcessed) 

251 else: 

252 plusNodes.append(lastProcessed) 

253 lastProcessed = self._print(arg) 

254 if arg == args[-1]: 

255 plusNodes.append(self._print(arg)) 

256 if len(plusNodes) == 1: 

257 return lastProcessed 

258 x = self.dom.createElement('apply') 

259 x.appendChild(self.dom.createElement('plus')) 

260 while plusNodes: 

261 x.appendChild(plusNodes.pop(0)) 

262 return x 

263 

264 def _print_Piecewise(self, expr): 

265 if expr.args[-1].cond != True: 

266 # We need the last conditional to be a True, otherwise the resulting 

267 # function may not return a result. 

268 raise ValueError("All Piecewise expressions must contain an " 

269 "(expr, True) statement to be used as a default " 

270 "condition. Without one, the generated " 

271 "expression may not evaluate to anything under " 

272 "some condition.") 

273 root = self.dom.createElement('piecewise') 

274 for i, (e, c) in enumerate(expr.args): 

275 if i == len(expr.args) - 1 and c == True: 

276 piece = self.dom.createElement('otherwise') 

277 piece.appendChild(self._print(e)) 

278 else: 

279 piece = self.dom.createElement('piece') 

280 piece.appendChild(self._print(e)) 

281 piece.appendChild(self._print(c)) 

282 root.appendChild(piece) 

283 return root 

284 

285 def _print_MatrixBase(self, m): 

286 x = self.dom.createElement('matrix') 

287 for i in range(m.rows): 

288 x_r = self.dom.createElement('matrixrow') 

289 for j in range(m.cols): 

290 x_r.appendChild(self._print(m[i, j])) 

291 x.appendChild(x_r) 

292 return x 

293 

294 def _print_Rational(self, e): 

295 if e.q == 1: 

296 # don't divide 

297 x = self.dom.createElement('cn') 

298 x.appendChild(self.dom.createTextNode(str(e.p))) 

299 return x 

300 x = self.dom.createElement('apply') 

301 x.appendChild(self.dom.createElement('divide')) 

302 # numerator 

303 xnum = self.dom.createElement('cn') 

304 xnum.appendChild(self.dom.createTextNode(str(e.p))) 

305 # denominator 

306 xdenom = self.dom.createElement('cn') 

307 xdenom.appendChild(self.dom.createTextNode(str(e.q))) 

308 x.appendChild(xnum) 

309 x.appendChild(xdenom) 

310 return x 

311 

312 def _print_Limit(self, e): 

313 x = self.dom.createElement('apply') 

314 x.appendChild(self.dom.createElement(self.mathml_tag(e))) 

315 

316 x_1 = self.dom.createElement('bvar') 

317 x_2 = self.dom.createElement('lowlimit') 

318 x_1.appendChild(self._print(e.args[1])) 

319 x_2.appendChild(self._print(e.args[2])) 

320 

321 x.appendChild(x_1) 

322 x.appendChild(x_2) 

323 x.appendChild(self._print(e.args[0])) 

324 return x 

325 

326 def _print_ImaginaryUnit(self, e): 

327 return self.dom.createElement('imaginaryi') 

328 

329 def _print_EulerGamma(self, e): 

330 return self.dom.createElement('eulergamma') 

331 

332 def _print_GoldenRatio(self, e): 

333 """We use unicode #x3c6 for Greek letter phi as defined here 

334 https://www.w3.org/2003/entities/2007doc/isogrk1.html""" 

335 x = self.dom.createElement('cn') 

336 x.appendChild(self.dom.createTextNode("\N{GREEK SMALL LETTER PHI}")) 

337 return x 

338 

339 def _print_Exp1(self, e): 

340 return self.dom.createElement('exponentiale') 

341 

342 def _print_Pi(self, e): 

343 return self.dom.createElement('pi') 

344 

345 def _print_Infinity(self, e): 

346 return self.dom.createElement('infinity') 

347 

348 def _print_NaN(self, e): 

349 return self.dom.createElement('notanumber') 

350 

351 def _print_EmptySet(self, e): 

352 return self.dom.createElement('emptyset') 

353 

354 def _print_BooleanTrue(self, e): 

355 return self.dom.createElement('true') 

356 

357 def _print_BooleanFalse(self, e): 

358 return self.dom.createElement('false') 

359 

360 def _print_NegativeInfinity(self, e): 

361 x = self.dom.createElement('apply') 

362 x.appendChild(self.dom.createElement('minus')) 

363 x.appendChild(self.dom.createElement('infinity')) 

364 return x 

365 

366 def _print_Integral(self, e): 

367 def lime_recur(limits): 

368 x = self.dom.createElement('apply') 

369 x.appendChild(self.dom.createElement(self.mathml_tag(e))) 

370 bvar_elem = self.dom.createElement('bvar') 

371 bvar_elem.appendChild(self._print(limits[0][0])) 

372 x.appendChild(bvar_elem) 

373 

374 if len(limits[0]) == 3: 

375 low_elem = self.dom.createElement('lowlimit') 

376 low_elem.appendChild(self._print(limits[0][1])) 

377 x.appendChild(low_elem) 

378 up_elem = self.dom.createElement('uplimit') 

379 up_elem.appendChild(self._print(limits[0][2])) 

380 x.appendChild(up_elem) 

381 if len(limits[0]) == 2: 

382 up_elem = self.dom.createElement('uplimit') 

383 up_elem.appendChild(self._print(limits[0][1])) 

384 x.appendChild(up_elem) 

385 if len(limits) == 1: 

386 x.appendChild(self._print(e.function)) 

387 else: 

388 x.appendChild(lime_recur(limits[1:])) 

389 return x 

390 

391 limits = list(e.limits) 

392 limits.reverse() 

393 return lime_recur(limits) 

394 

395 def _print_Sum(self, e): 

396 # Printer can be shared because Sum and Integral have the 

397 # same internal representation. 

398 return self._print_Integral(e) 

399 

400 def _print_Symbol(self, sym): 

401 ci = self.dom.createElement(self.mathml_tag(sym)) 

402 

403 def join(items): 

404 if len(items) > 1: 

405 mrow = self.dom.createElement('mml:mrow') 

406 for i, item in enumerate(items): 

407 if i > 0: 

408 mo = self.dom.createElement('mml:mo') 

409 mo.appendChild(self.dom.createTextNode(" ")) 

410 mrow.appendChild(mo) 

411 mi = self.dom.createElement('mml:mi') 

412 mi.appendChild(self.dom.createTextNode(item)) 

413 mrow.appendChild(mi) 

414 return mrow 

415 else: 

416 mi = self.dom.createElement('mml:mi') 

417 mi.appendChild(self.dom.createTextNode(items[0])) 

418 return mi 

419 

420 # translate name, supers and subs to unicode characters 

421 def translate(s): 

422 if s in greek_unicode: 

423 return greek_unicode.get(s) 

424 else: 

425 return s 

426 

427 name, supers, subs = split_super_sub(sym.name) 

428 name = translate(name) 

429 supers = [translate(sup) for sup in supers] 

430 subs = [translate(sub) for sub in subs] 

431 

432 mname = self.dom.createElement('mml:mi') 

433 mname.appendChild(self.dom.createTextNode(name)) 

434 if not supers: 

435 if not subs: 

436 ci.appendChild(self.dom.createTextNode(name)) 

437 else: 

438 msub = self.dom.createElement('mml:msub') 

439 msub.appendChild(mname) 

440 msub.appendChild(join(subs)) 

441 ci.appendChild(msub) 

442 else: 

443 if not subs: 

444 msup = self.dom.createElement('mml:msup') 

445 msup.appendChild(mname) 

446 msup.appendChild(join(supers)) 

447 ci.appendChild(msup) 

448 else: 

449 msubsup = self.dom.createElement('mml:msubsup') 

450 msubsup.appendChild(mname) 

451 msubsup.appendChild(join(subs)) 

452 msubsup.appendChild(join(supers)) 

453 ci.appendChild(msubsup) 

454 return ci 

455 

456 _print_MatrixSymbol = _print_Symbol 

457 _print_RandomSymbol = _print_Symbol 

458 

459 def _print_Pow(self, e): 

460 # Here we use root instead of power if the exponent is the reciprocal 

461 # of an integer 

462 if (self._settings['root_notation'] and e.exp.is_Rational 

463 and e.exp.p == 1): 

464 x = self.dom.createElement('apply') 

465 x.appendChild(self.dom.createElement('root')) 

466 if e.exp.q != 2: 

467 xmldeg = self.dom.createElement('degree') 

468 xmlcn = self.dom.createElement('cn') 

469 xmlcn.appendChild(self.dom.createTextNode(str(e.exp.q))) 

470 xmldeg.appendChild(xmlcn) 

471 x.appendChild(xmldeg) 

472 x.appendChild(self._print(e.base)) 

473 return x 

474 

475 x = self.dom.createElement('apply') 

476 x_1 = self.dom.createElement(self.mathml_tag(e)) 

477 x.appendChild(x_1) 

478 x.appendChild(self._print(e.base)) 

479 x.appendChild(self._print(e.exp)) 

480 return x 

481 

482 def _print_Number(self, e): 

483 x = self.dom.createElement(self.mathml_tag(e)) 

484 x.appendChild(self.dom.createTextNode(str(e))) 

485 return x 

486 

487 def _print_Float(self, e): 

488 x = self.dom.createElement(self.mathml_tag(e)) 

489 repr_e = mlib_to_str(e._mpf_, repr_dps(e._prec)) 

490 x.appendChild(self.dom.createTextNode(repr_e)) 

491 return x 

492 

493 def _print_Derivative(self, e): 

494 x = self.dom.createElement('apply') 

495 diff_symbol = self.mathml_tag(e) 

496 if requires_partial(e.expr): 

497 diff_symbol = 'partialdiff' 

498 x.appendChild(self.dom.createElement(diff_symbol)) 

499 x_1 = self.dom.createElement('bvar') 

500 

501 for sym, times in reversed(e.variable_count): 

502 x_1.appendChild(self._print(sym)) 

503 if times > 1: 

504 degree = self.dom.createElement('degree') 

505 degree.appendChild(self._print(sympify(times))) 

506 x_1.appendChild(degree) 

507 

508 x.appendChild(x_1) 

509 x.appendChild(self._print(e.expr)) 

510 return x 

511 

512 def _print_Function(self, e): 

513 x = self.dom.createElement("apply") 

514 x.appendChild(self.dom.createElement(self.mathml_tag(e))) 

515 for arg in e.args: 

516 x.appendChild(self._print(arg)) 

517 return x 

518 

519 def _print_Basic(self, e): 

520 x = self.dom.createElement(self.mathml_tag(e)) 

521 for arg in e.args: 

522 x.appendChild(self._print(arg)) 

523 return x 

524 

525 def _print_AssocOp(self, e): 

526 x = self.dom.createElement('apply') 

527 x_1 = self.dom.createElement(self.mathml_tag(e)) 

528 x.appendChild(x_1) 

529 for arg in e.args: 

530 x.appendChild(self._print(arg)) 

531 return x 

532 

533 def _print_Relational(self, e): 

534 x = self.dom.createElement('apply') 

535 x.appendChild(self.dom.createElement(self.mathml_tag(e))) 

536 x.appendChild(self._print(e.lhs)) 

537 x.appendChild(self._print(e.rhs)) 

538 return x 

539 

540 def _print_list(self, seq): 

541 """MathML reference for the <list> element: 

542 https://www.w3.org/TR/MathML2/chapter4.html#contm.list""" 

543 dom_element = self.dom.createElement('list') 

544 for item in seq: 

545 dom_element.appendChild(self._print(item)) 

546 return dom_element 

547 

548 def _print_int(self, p): 

549 dom_element = self.dom.createElement(self.mathml_tag(p)) 

550 dom_element.appendChild(self.dom.createTextNode(str(p))) 

551 return dom_element 

552 

553 _print_Implies = _print_AssocOp 

554 _print_Not = _print_AssocOp 

555 _print_Xor = _print_AssocOp 

556 

557 def _print_FiniteSet(self, e): 

558 x = self.dom.createElement('set') 

559 for arg in e.args: 

560 x.appendChild(self._print(arg)) 

561 return x 

562 

563 def _print_Complement(self, e): 

564 x = self.dom.createElement('apply') 

565 x.appendChild(self.dom.createElement('setdiff')) 

566 for arg in e.args: 

567 x.appendChild(self._print(arg)) 

568 return x 

569 

570 def _print_ProductSet(self, e): 

571 x = self.dom.createElement('apply') 

572 x.appendChild(self.dom.createElement('cartesianproduct')) 

573 for arg in e.args: 

574 x.appendChild(self._print(arg)) 

575 return x 

576 

577 # XXX Symmetric difference is not supported for MathML content printers. 

578 

579 

580class MathMLPresentationPrinter(MathMLPrinterBase): 

581 """Prints an expression to the Presentation MathML markup language. 

582 

583 References: https://www.w3.org/TR/MathML2/chapter3.html 

584 """ 

585 printmethod = "_mathml_presentation" 

586 

587 def mathml_tag(self, e): 

588 """Returns the MathML tag for an expression.""" 

589 translate = { 

590 'Number': 'mn', 

591 'Limit': '&#x2192;', 

592 'Derivative': '&dd;', 

593 'int': 'mn', 

594 'Symbol': 'mi', 

595 'Integral': '&int;', 

596 'Sum': '&#x2211;', 

597 'sin': 'sin', 

598 'cos': 'cos', 

599 'tan': 'tan', 

600 'cot': 'cot', 

601 'asin': 'arcsin', 

602 'asinh': 'arcsinh', 

603 'acos': 'arccos', 

604 'acosh': 'arccosh', 

605 'atan': 'arctan', 

606 'atanh': 'arctanh', 

607 'acot': 'arccot', 

608 'atan2': 'arctan', 

609 'Equality': '=', 

610 'Unequality': '&#x2260;', 

611 'GreaterThan': '&#x2265;', 

612 'LessThan': '&#x2264;', 

613 'StrictGreaterThan': '>', 

614 'StrictLessThan': '<', 

615 'lerchphi': '&#x3A6;', 

616 'zeta': '&#x3B6;', 

617 'dirichlet_eta': '&#x3B7;', 

618 'elliptic_k': '&#x39A;', 

619 'lowergamma': '&#x3B3;', 

620 'uppergamma': '&#x393;', 

621 'gamma': '&#x393;', 

622 'totient': '&#x3D5;', 

623 'reduced_totient': '&#x3BB;', 

624 'primenu': '&#x3BD;', 

625 'primeomega': '&#x3A9;', 

626 'fresnels': 'S', 

627 'fresnelc': 'C', 

628 'LambertW': 'W', 

629 'Heaviside': '&#x398;', 

630 'BooleanTrue': 'True', 

631 'BooleanFalse': 'False', 

632 'NoneType': 'None', 

633 'mathieus': 'S', 

634 'mathieuc': 'C', 

635 'mathieusprime': 'S&#x2032;', 

636 'mathieucprime': 'C&#x2032;', 

637 } 

638 

639 def mul_symbol_selection(): 

640 if (self._settings["mul_symbol"] is None or 

641 self._settings["mul_symbol"] == 'None'): 

642 return '&InvisibleTimes;' 

643 elif self._settings["mul_symbol"] == 'times': 

644 return '&#xD7;' 

645 elif self._settings["mul_symbol"] == 'dot': 

646 return '&#xB7;' 

647 elif self._settings["mul_symbol"] == 'ldot': 

648 return '&#x2024;' 

649 elif not isinstance(self._settings["mul_symbol"], str): 

650 raise TypeError 

651 else: 

652 return self._settings["mul_symbol"] 

653 for cls in e.__class__.__mro__: 

654 n = cls.__name__ 

655 if n in translate: 

656 return translate[n] 

657 # Not found in the MRO set 

658 if e.__class__.__name__ == "Mul": 

659 return mul_symbol_selection() 

660 n = e.__class__.__name__ 

661 return n.lower() 

662 

663 def parenthesize(self, item, level, strict=False): 

664 prec_val = precedence_traditional(item) 

665 if (prec_val < level) or ((not strict) and prec_val <= level): 

666 brac = self.dom.createElement('mfenced') 

667 brac.appendChild(self._print(item)) 

668 return brac 

669 else: 

670 return self._print(item) 

671 

672 def _print_Mul(self, expr): 

673 

674 def multiply(expr, mrow): 

675 from sympy.simplify import fraction 

676 numer, denom = fraction(expr) 

677 if denom is not S.One: 

678 frac = self.dom.createElement('mfrac') 

679 if self._settings["fold_short_frac"] and len(str(expr)) < 7: 

680 frac.setAttribute('bevelled', 'true') 

681 xnum = self._print(numer) 

682 xden = self._print(denom) 

683 frac.appendChild(xnum) 

684 frac.appendChild(xden) 

685 mrow.appendChild(frac) 

686 return mrow 

687 

688 coeff, terms = expr.as_coeff_mul() 

689 if coeff is S.One and len(terms) == 1: 

690 mrow.appendChild(self._print(terms[0])) 

691 return mrow 

692 if self.order != 'old': 

693 terms = Mul._from_args(terms).as_ordered_factors() 

694 

695 if coeff != 1: 

696 x = self._print(coeff) 

697 y = self.dom.createElement('mo') 

698 y.appendChild(self.dom.createTextNode(self.mathml_tag(expr))) 

699 mrow.appendChild(x) 

700 mrow.appendChild(y) 

701 for term in terms: 

702 mrow.appendChild(self.parenthesize(term, PRECEDENCE['Mul'])) 

703 if not term == terms[-1]: 

704 y = self.dom.createElement('mo') 

705 y.appendChild(self.dom.createTextNode(self.mathml_tag(expr))) 

706 mrow.appendChild(y) 

707 return mrow 

708 mrow = self.dom.createElement('mrow') 

709 if expr.could_extract_minus_sign(): 

710 x = self.dom.createElement('mo') 

711 x.appendChild(self.dom.createTextNode('-')) 

712 mrow.appendChild(x) 

713 mrow = multiply(-expr, mrow) 

714 else: 

715 mrow = multiply(expr, mrow) 

716 

717 return mrow 

718 

719 def _print_Add(self, expr, order=None): 

720 mrow = self.dom.createElement('mrow') 

721 args = self._as_ordered_terms(expr, order=order)