def __init__(self, settings=None): StrPrinter.__init__(self, settings) self._init_leading_padding() assign_to = self._settings['assign_to'] if isinstance(assign_to, basestring): self._settings['assign_to'] = Symbol(assign_to) elif not isinstance(assign_to, (Basic, type(None))): raise TypeError("FCodePrinter cannot assign to object of type %s"% type(assign_to))
def __init__(self, settings=None): ReprPrinter.__init__(self) StrPrinter.__init__(self, settings) self.symbols = [] self.functions = [] # Create print methods for classes that should use StrPrinter instead # of ReprPrinter. for name in STRPRINT: f_name = "_print_%s"%name f = getattr(StrPrinter, f_name) setattr(PythonPrinter, f_name, f)
def __init__(self, settings=None): ReprPrinter.__init__(self) StrPrinter.__init__(self, settings) self.symbols = [] self.functions = [] # Create print methods for classes that should use StrPrinter instead # of ReprPrinter. for name in STRPRINT: f_name = "_print_%s" % name f = getattr(StrPrinter, f_name) setattr(PythonPrinter, f_name, f)
def _print_Function(self, expr): if expr.func.__name__ == "ceiling": return "ceil(%s)" % self.stringify(expr.args, ", ") elif expr.func.__name__ == "abs" and not expr.args[0].is_integer: return "fabs(%s)" % self.stringify(expr.args, ", ") else: return StrPrinter._print_Function(self, expr)
def doprint(self, expr): """Returns Fortran code for expr (as a string)""" # keep a set of expressions that are not strictly translatable to # Fortran. self.not_fortran = set([]) lines = [] if isinstance(expr, Piecewise): # support for top-level Piecewise function for i, (e, c) in enumerate(expr.args): if i == 0: lines.append(" if (%s) then" % self._print(c)) elif i == len(expr.args)-1 and c == True: lines.append(" else") else: lines.append(" else if (%s) then" % self._print(c)) if self._settings["assign_to"] is None: lines.append(" %s" % self._print(e)) else: lines.append(" %s = %s" % (self._settings["assign_to"], self._print(e))) lines.append(" end if") return "\n".join(lines) else: line = StrPrinter.doprint(self, expr) if self._settings["assign_to"] is None: return " %s" % line else: return " %s = %s" % (self._settings["assign_to"], line)
def _print_Pow(self, expr): PREC = precedence(expr) if expr.exp is S.NegativeOne: return '1.0/%s' % (self.parenthesize(expr.base, PREC)) elif expr.exp == 0.5: return 'sqrt(%s)' % self._print(expr.base) else: return StrPrinter._print_Pow(self, expr)
def _print_Pow(self, expr): PREC = precedence(expr) if expr.exp is S.NegativeOne: return '1.0/%s'%(self.parenthesize(expr.base, PREC)) elif expr.exp == 0.5: return 'sqrt(%s)' % self._print(expr.base) else: return StrPrinter._print_Pow(self, expr)
def _print_Mul(self, expr): # purpose: print complex numbers nicely in Fortran. if expr.is_imaginary and expr.is_number: return "cmplx(0,%s)" % ( self._print(-I*expr) ) else: return StrPrinter._print_Mul(self, expr)
def doprint(self, expr): """Returns Fortran code for expr (as a string)""" # find all number symbols number_symbols = set([]) for sub in postorder_traversal(expr): if isinstance(sub, NumberSymbol): number_symbols.add(sub) number_symbols = [(str(ns), ns.evalf(self._settings["precision"])) for ns in sorted(number_symbols)] # keep a set of expressions that are not strictly translatable to # Fortran. self._not_fortran = set([]) lines = [] if isinstance(expr, Piecewise): # support for top-level Piecewise function for i, (e, c) in enumerate(expr.args): if i == 0: lines.append(" if (%s) then" % self._print(c)) elif i == len(expr.args) - 1 and c == True: lines.append(" else") else: lines.append(" else if (%s) then" % self._print(c)) if self._settings["assign_to"] is None: lines.append(" %s" % self._print(e)) else: lines.append(" %s = %s" % (self._settings["assign_to"], self._print(e))) lines.append(" end if") text = "\n".join(lines) else: line = StrPrinter.doprint(self, expr) if self._settings["assign_to"] is None: text = " %s" % line else: text = " %s = %s" % (self._settings["assign_to"], line) # format the output if self._settings["human"]: lines = [] if len(self._not_fortran) > 0: lines.append("C Not Fortran 77:") for expr in sorted(self._not_fortran): lines.append("C %s" % expr) for name, value in number_symbols: lines.append(" parameter (%s = %s)" % (name, value)) lines.extend(text.split("\n")) lines = wrap_fortran(lines) result = "\n".join(lines) else: result = number_symbols, self._not_fortran, text del self._not_fortran return result
def doprint(self, expr): """Returns Fortran code for expr (as a string)""" # find all number symbols number_symbols = set([]) for sub in postorder_traversal(expr): if isinstance(sub, NumberSymbol): number_symbols.add(sub) number_symbols = [(str(ns), ns.evalf(self._settings["precision"])) for ns in sorted(number_symbols)] # keep a set of expressions that are not strictly translatable to # Fortran. self._not_fortran = set([]) lines = [] if isinstance(expr, Piecewise): # support for top-level Piecewise function for i, (e, c) in enumerate(expr.args): if i == 0: lines.append(" if (%s) then" % self._print(c)) elif i == len(expr.args)-1 and c == True: lines.append(" else") else: lines.append(" else if (%s) then" % self._print(c)) if self._settings["assign_to"] is None: lines.append(" %s" % self._print(e)) else: lines.append(" %s = %s" % (self._settings["assign_to"], self._print(e))) lines.append(" end if") text = "\n".join(lines) else: line = StrPrinter.doprint(self, expr) if self._settings["assign_to"] is None: text = " %s" % line else: text = " %s = %s" % (self._settings["assign_to"], line) # format the output if self._settings["human"]: lines = [] if len(self._not_fortran) > 0: lines.append("C Not Fortran 77:") for expr in sorted(self._not_fortran): lines.append("C %s" % expr) for name, value in number_symbols: lines.append(" parameter (%s = %s)" % (name, value)) lines.extend(text.split("\n")) lines = wrap_fortran(lines) result = "\n".join(lines) else: result = number_symbols, self._not_fortran, text del self._not_fortran return result
def _print_Add(self, expr): # purpose: print complex numbers nicely in Fortran. # collect the purely real and purely imaginary parts: pure_real = [] pure_imaginary = [] mixed = [] for arg in expr.args: if arg.is_real and arg.is_number: pure_real.append(arg) elif arg.is_imaginary and arg.is_number: pure_imaginary.append(arg) else: mixed.append(arg) if len(pure_imaginary) > 0: if len(mixed) > 0: PREC = precedence(expr) term = Add(*mixed) t = self._print(term) if t.startswith('-'): sign = "-" t = t[1:] else: sign = "+" if precedence(term) < PREC: t = "(%s)" % t return "cmplx(%s,%s) %s %s" % ( self._print(Add(*pure_real)), self._print(-I * Add(*pure_imaginary)), sign, t, ) else: return "cmplx(%s,%s)" % ( self._print(Add(*pure_real)), self._print(-I * Add(*pure_imaginary)), ) else: return StrPrinter._print_Add(self, expr)
def _print_Add(self, expr): # purpose: print complex numbers nicely in Fortran. # collect the purely real and purely imaginary parts: pure_real = [] pure_imaginary = [] mixed = [] for arg in expr.args: if arg.is_real and arg.is_number: pure_real.append(arg) elif arg.is_imaginary and arg.is_number: pure_imaginary.append(arg) else: mixed.append(arg) if len(pure_imaginary) > 0: if len(mixed) > 0: PREC = precedence(expr) term = Add(*mixed) t = self._print(term) if t.startswith('-'): sign = "-" t = t[1:] else: sign = "+" if precedence(term) < PREC: t = "(%s)" % t return "cmplx(%s,%s) %s %s" % ( self._print(Add(*pure_real)), self._print(-I*Add(*pure_imaginary)), sign, t, ) else: return "cmplx(%s,%s)" % ( self._print(Add(*pure_real)), self._print(-I*Add(*pure_imaginary)), ) else: return StrPrinter._print_Add(self, expr)
def _print_Function(self, expr): func = expr.func.__name__ if not hasattr(sympy, func) and not func in self.functions: self.functions.append(func) return StrPrinter._print_Function(self, expr)
def doprint(self, expr): """Returns Fortran code for expr (as a string)""" # find all number symbols number_symbols = set([]) for sub in postorder_traversal(expr): if isinstance(sub, NumberSymbol): number_symbols.add(sub) number_symbols = [(str(ns), ns.evalf(self._settings["precision"])) for ns in sorted(number_symbols)] # keep a set of expressions that are not strictly translatable to # Fortran. self._not_fortran = set([]) # Setup loops if expression contain Indexed objects openloop, closeloop, local_ints = self._get_loop_opening_ending_ints(expr) self._not_fortran |= set(local_ints) # the lhs may contain loops that are not in the rhs lhs = self._settings['assign_to'] if lhs: open_lhs, close_lhs, lhs_ints = self._get_loop_opening_ending_ints(lhs) for n,ind in enumerate(lhs_ints): if ind not in self._not_fortran: self._not_fortran.add(ind) openloop.insert(0,open_lhs[n]) closeloop.append(close_lhs[n]) lhs_printed = self._print(lhs) lines = [] if isinstance(expr, Piecewise): # support for top-level Piecewise function for i, (e, c) in enumerate(expr.args): if i == 0: lines.append("if (%s) then" % self._print(c)) elif i == len(expr.args)-1 and c == True: lines.append("else") else: lines.append("else if (%s) then" % self._print(c)) if self._settings["assign_to"] is None: lines.extend(openloop) lines.append(" %s" % self._print(e)) lines.extend(closeloop) else: lines.extend(openloop) lines.append(" %s = %s" % (lhs_printed, self._print(e))) lines.extend(closeloop) lines.append("end if") else: lines.extend(openloop) line = StrPrinter.doprint(self, expr) if self._settings["assign_to"] is None: text = "%s" % line else: text = "%s = %s" % (lhs_printed, line) lines.append(text) lines.extend(closeloop) # format the output if self._settings["human"]: frontlines = [] if len(self._not_fortran) > 0: frontlines.append("! Not Fortran:") for expr in sorted(self._not_fortran, key=self._print): frontlines.append("! %s" % expr) for name, value in number_symbols: frontlines.append("parameter (%s = %s)" % (name, value)) frontlines.extend(lines) lines = frontlines lines = self._pad_leading_columns(lines) lines = self._wrap_fortran(lines) lines = self.indent_code(lines) result = "\n".join(lines) else: lines = self._pad_leading_columns(lines) lines = self._wrap_fortran(lines) lines = self.indent_code(lines) result = number_symbols, self._not_fortran, "\n".join(lines) del self._not_fortran return result
def _print_Symbol(self, expr): symbol = self._str(expr) if symbol not in self.symbols: self.symbols.append(symbol) return StrPrinter._print_Symbol(self, expr)
def _print_Mul(self, expr): # purpose: print complex numbers nicely in Fortran. if expr.is_imaginary and expr.is_number: return "cmplx(0,%s)" % (self._print(-I * expr)) else: return StrPrinter._print_Mul(self, expr)
"""Printing subsystem""" from pretty import * from latex import latex, print_latex from mathml import mathml, print_mathml from python import python, print_python from ccode import ccode, print_ccode from gtk import * from preview import preview, view, pngview, pdfview, dviview from str import StrPrinter, sstr, sstrrepr _StrPrinter = StrPrinter() from repr import srepr # /cyclic/ from sympy.core import basic from sympy.matrices import matrices basic.StrPrinter = _StrPrinter matrices.StrPrinter = _StrPrinter del basic, matrices from tree import print_tree
def _print_not_fortran(self, expr): self.not_fortran.add(expr) return StrPrinter.emptyPrinter(self, expr)