def table_to_printstream(species, table, fmt='rst'):
"""Given species table and reaction table get properly formatted output.
Arguments:
species: table of species as output by gen_table
table: rxn table as returned by gen_table
Returns:
string formatted output
"""
model_name = table["model"][0]
table = table.sort_values("model")[[
"schema", "fwd_rate", "rev_rate", "kd"
]]
printstream_info = [
tb.tabulate(np.expand_dims(t[1].transpose(), axis=1), tablefmt=fmt)
for t in table.iterrows()
]
if fmt == 'latex':
return "\n".join(["\documentclass{article}",
r"\usepackage[utf8]{inputenc}",
r"\usepackage{amsmath}",
"\\begin{document}",
"\def\\arraystretch{2}",
model_name,
"\n".join(["%s: %s" % (latex(r[1]), latex(r[0])) for r in species])] + \
printstream_info + \
["\end{document}"])
elif fmt == 'plain':
return "\n============================\n".join([
"", model_name, "\n".join(
["%s: %s" % (r[1], r[0]) for r in species])
] + printstream_info) + "\n"
def test_deprecated_print_cyclic():
p = Permutation(0, 1, 2)
try:
Permutation.print_cyclic = True
with warns_deprecated_sympy():
assert sstr(p) == '(0 1 2)'
with warns_deprecated_sympy():
assert srepr(p) == 'Permutation(0, 1, 2)'
with warns_deprecated_sympy():
assert pretty(p) == '(0 1 2)'
with warns_deprecated_sympy():
assert latex(p) == r'\left( 0\; 1\; 2\right)'
Permutation.print_cyclic = False
with warns_deprecated_sympy():
assert sstr(p) == 'Permutation([1, 2, 0])'
with warns_deprecated_sympy():
assert srepr(p) == 'Permutation([1, 2, 0])'
with warns_deprecated_sympy():
assert pretty(p, use_unicode=False) == '/0 1 2\\\n\\1 2 0/'
with warns_deprecated_sympy():
assert latex(p) == \
r'\begin{pmatrix} 0 & 1 & 2 \\ 1 & 2 & 0 \end{pmatrix}'
finally:
Permutation.print_cyclic = None
def print_mat(xs):
from sympy.printing import latex
rv = "\\begin{pmatrix} "
for row in xrange(0, len(xs)):
s = latex(xs[row, 0])
for col in xrange(1, len(xs)):
s += " & " + latex(xs[row, col])
rv += s + " \\\\ "
return rv[:-3] + " \\end{pmatrix}"
def print_mat(xs):
from sympy.printing import latex
rv = "\\begin{pmatrix} "
for row in xrange(0, len(xs)):
s = latex(xs[row, 0])
for col in xrange(1, len(xs)):
s += " & " + latex(xs[row, col])
rv += s + " \\\\ "
return rv[:-3] + " \\end{pmatrix}"
def create_linear_system(symbol, superscript, sym_group='622', tdim=2):
sg = RedSgSymOps()
print(sg.symops['6parZ3'])
symops = sg(sym_group)
symop = symops[0]
R = Matrix(symop)
Rsym = Matrix([[Symbol('R_{{{},{}}}'.format(i, j)) for j in range(1, 4)]
for i in range(1, 4)])
print('Rsym=\n', latex(Rsym))
print('R=\n', latex(R))
print(symop)
ivm, vm = SymbolicTensor.voigt_map(2)
print(ivm)
print(vm)
indices0 = list(product(range(3), repeat=tdim))
indices1 = list(product(range(1, 4), repeat=tdim))
print(indices0)
print(indices1)
lhs = Matrix([[Rsym[I, i] * Rsym[J, j] for (i, j) in indices0]
for (I, J) in indices0])
print(latex(lhs))
vec = Matrix([[Symbol('c_{{{},{}}}'.format(i, j))] for (i, j) in indices1])
print(latex(vec))
vvec = Matrix([[Symbol('c_{{{}}}'.format(vm[k] + 1))] for k in indices0])
print(latex(vvec))
lines = []
frac_lines = []
redfrac_lines = []
symbol += '^{{{}}}'.format(superscript)
for (I, J) in indices:
line = '&'.join([
"{}_{{{}{}}} {}_{{{}{}}}".format(symbol, I, i, symbol, J, j)
for (i, j) in indices
])
lines.append(line)
Iint = int(I) - 1
Jint = int(J) - 1
frac_line = '&'.join([
"{} \cdot {}".format(symop[Iint, int(i) - 1], symop[Jint,
int(j) - 1])
for (i, j) in indices
])
frac_line = frac_line.replace('sqrt(3)', '\\sqrt{3}')
frac_lines.append(frac_line)
redfrac_line = '&'.join([
"{}".format(4 * symop[Iint, int(i) - 1] *
symop[Jint, int(j) - 1]) for (i, j) in indices
])
redfrac_line = redfrac_line.replace('sqrt(3)', '\\sqrt{3}')
redfrac_lines.append(redfrac_line)
print('\\\\'.join(lines))
print('\\\\'.join(frac_lines))
print('\\\\'.join(redfrac_lines))
def latex(self, variable):
funs = self.funs
seps = self.seps
s = r"""\begin{{cases}}
{} & {} \in (-\infty,{})\\
""".format(latex(funs[0]), variable, seps[0])
for (sup, inf, fun) in zip(seps[1:], seps[:-1], funs[1:]):
s += r"""{} & {} \in [{},{})\\
""".format(latex(fun), variable, inf, sup)
s += r""" {} & {} \in [{}, +\infty )
\end{{cases}}""".format(latex(funs[-1]), variable, seps[-1])
return s
def _repr_html_(self):
'''
Returns a string formatted in RST.
'''
rows = [
f'<p><b>{self.__class__.__name__}</b></p>',
'',
'<p><i>Quantities</i></p>',
'',
'<ul>'
]
for name, _, doc in self._q:
rows.append(f'<li><i>{name}</i>: {doc}</li>')
rows.extend(['</ul>', '', '<p><i>Constants</i></p>', '', '<ul>'])
for name, _, doc in self._c:
rows.append(f'<li><i>{name}</i>: {doc}</li>')
rows.extend(['</ul>', '', '<p><i>Parameters</i></p>', '', '<ul>'])
for name, _, doc in self._p:
rows.append(f'<li><i>{name}</i>: {doc}</li>')
if self._eq is not None:
rows.extend(['</ul>', '', '<p><i>Equations</i></p>', '', '<ul>'])
for i, (k, v) in enumerate(sorted(self._eq.items())):
lats = "\\frac{d%s}{dt} = %s" % (k, printing.latex(v))
lat = latex(lats, mode='equation')
line = "".join(["<li>", str(lat), '</li>'])
rows.append(line)
rows.append("</ul>")
return '\n'.join(rows)
def print_pygame(st):
try:
import pygame
except ImportError:
print "Pygame is not installed. In Debian, install the " "python-pygame package."
return
from pygame import QUIT, KEYDOWN, K_ESCAPE, K_q
st = latex(st)
pygame.font.init()
size = 640, 240
screen = pygame.display.set_mode(size)
screen.fill((255, 255, 255))
font = pygame.font.Font(None, 24)
text = font.render(st, True, (0, 0, 0))
textpos = text.get_rect(centerx=screen.get_width() / 2)
screen.blit(text, textpos)
pygame.display.flip()
image = tex2png(st, pygame)
imagepos = image.get_rect(centerx=screen.get_width() / 2).move((0, 30))
screen.blit(image, imagepos)
pygame.display.flip()
while 1:
for event in pygame.event.get():
if event.type == QUIT:
return
elif event.type == KEYDOWN and event.key == K_ESCAPE:
return
elif event.type == KEYDOWN and event.key == K_q:
return
def fmt_rct(r, species_dict, fmt='plain'):
"""Formats a given reaction from pysb to a given output format.
Arguments:
r : collections.namedtuple reaction object
species_dict : mapping of pysb species names present in expressions to the actual species eg __s0 --> B(...)
fmt: string format to output. current options are
'plain': plaintext
'latex': latex
TODO: implement the species_dict mapping
Returns:
List of strings [reaction_name, reaction_schema, k_f, k_r, k_d]
"""
arrow = {'latex': " $\longleftrightarrow$ ", 'plain': "<-->"}[fmt]
fmt_fct = {
'latex':
lambda x: "$%s$" % latex(x).replace("__", "").replace(" % ", ""),
'plain': lambda x: str(x).replace(" % ", "")
}[fmt]
r_schema = " + ".join(map(fmt_fct, r.reactants)) + arrow + "".join(
map(fmt_fct, r.products))
return [
r.name.replace("_", "-"), r_schema,
fmt_fct(r.fwd_rate),
fmt_fct(r.rev_rate),
fmt_fct(r.kd)
]
def _repr_latex_(self):
"""Latex repr hook for IPython."""
if self.DEFAULT_REPR_LATEX == "dim_dict":
expr_dim = expand_dict_to_expr(self.dim_dict)
return "$" + latex(expr_dim) + "$"
else: # self.DEFAULT_REPR_LATEX == "SI_unit":
return self.latex_SI_unit()
def fmt_fct(x):
if type(x) is ComplexPattern:
x = species_dict[str(x)]
return {
'latex': "$%s$" % latex(x).replace("__", "").replace(" % ", ""),
'plain': str(x).replace(" % ", "")
}[fmt]
def out(self, expr):
"""
expr: A sympy expression
"""
if type(expr) == str: return expr
l = latex(expr, symbol_names=self.symbol_names)
return l
def to_rst(self):
'''
Returns a string formatted in RST.
'''
rows = [
f'*{self.__class__.__name__}*',
'',
'*Quantities*',
''
]
for name, _, doc in self._q:
rows.append(f'* *{name}*: {doc}')
rows.extend(['', '*Constants*', ''])
for name, _, doc in self._c:
rows.append(f'* *{name}*: {doc}')
rows.extend(['', '*Parameters*', ''])
for name, _, doc in self._p:
rows.append(f'* *{name}*: {doc}')
if self._eq is not None:
rows.extend(['', '*Equations*', '', '.. math::',
'', ' \\begin{array}{l}'])
for i, (k, v) in enumerate(sorted(self._eq.items())):
line = "".join(
[" ", "\\frac{d%s}{dt} = " % k, printing.latex(v)])
if i < len(self._eq) - 1:
line += " \\\\"
rows.append(line)
rows.append(" \\end{array}")
return '\n'.join(rows)
def write_problems(self, valid_combos):
"""Takes variable values and returns problem / answer pairs as LaTeX."""
# To be used when converting the equation to sympy
transformations = standard_transformations + (
implicit_multiplication_application, )
# To preserve the order of the expression, may need to sub each arg separately and then reconstruct the whole equation (sympy can identify each term as an arg)
for combo in valid_combos:
# Sympy doesn't like equations, so this allows it to evaluate
# the left and right side independently
subbed_left_side = self.equation[:self.equation.find('=')]
subbed_right_side = self.equation[self.equation.find('=') + 1:]
for i, var in enumerate(self.variables):
variable = var['variable']
# Replace non-answer variables with values
if i < len(self.variables) - 1:
subbed_left_side = subbed_left_side.replace(
variable, str(combo['values'][variable]))
subbed_right_side = subbed_right_side.replace(
variable, str(combo['values'][variable]))
# Store the answer(s)
else:
if len(combo['values'][variable]) == 1:
combo[
'answer'] = f"{variable} = {combo['values'][variable][0]}"
else:
combo[
'answer'] = f"{variable} = {combo['values'][variable]}"
# Latexify each side of the equation, then concatenate
latex_left_side = latex(
parse_expr(subbed_left_side,
transformations=transformations,
evaluate=False))
latex_right_side = latex(
parse_expr(subbed_right_side,
transformations=transformations,
evaluate=False))
latex_problem = str(latex_left_side) + ' = ' + str(
latex_right_side)
combo['problem'] = str(latex_problem)
def latex(self, request=None, raw=False):
self.latex = latex(self.expression, mode='plain')
obj = {'string':self.expressionString,
'javascript': self.javascript, 'latex':self.latex}
if (raw):
return obj
else:
return JsonResponse(obj)
def draw_plot(f, lower=-10, upper=-10, num=1000):
y = parse_expr(f)
xvals = linspace(lower, upper, num=num)
vals = [y.evalf(subs={'x': x}) for x in xvals]
plot(xvals, vals)
title('$%s$' % latex(y))
grid()
savefig('/tmp/plot.png')
show()
def _plot_bradford(self, std, proteins, p, r_sq):
'''
plot bradford standard curve and sample absorbance data points
'''
# plot
fig, ax = plt.subplots(figsize=(6, 5))
# standard curve and labeled points
xra = np.linspace(std['abs_595'].min(), std['abs_595'].max(), 100)
plt.plot(xra, p(xra), lw=2.5, color='orange', zorder=0)
plt.scatter(std['abs_595'],
std['Sample'],
edgecolor='k',
alpha=0.5,
label='BSA standards',
marker='s')
# plot replicates of each sample abs
for samp in proteins['Sample'].unique():
temp = proteins[proteins['Sample'] == samp]
plt.scatter(temp['abs_595'],
p(temp['abs_595']),
label=samp,
edgecolor='k',
alpha=0.8)
plt.grid(alpha=0.2)
plt.legend(loc='center left',
bbox_to_anchor=(1, 0.5),
fontsize='large')
ax.set_axisbelow(True)
# setup poly equation to pretty print
x = symbols("x")
# extract coefficients and reverse so order is decreasing powers
poly = sum(
S("{:6.1f}".format(v)) * x**i for i, v in enumerate(p.c[::-1]))
eq_latex = printing.latex(poly)
annotation_str = '${}$'.format(eq_latex)
annotation_str += '\n'
annotation_str += r'$R^2$ = {:.3f}'.format(r_sq)
plt.text(0.05,
0.8,
annotation_str,
transform=ax.transAxes,
fontsize='large')
plt.xlabel('OD595')
plt.ylabel('Concentration (ug/mL)')
plt.title('Bradford Assay Standard Curve')
plt.savefig(Path(cwd, 'tmp', f'{self.filename}_std_curve.png'),
bbox_inches='tight',
dpi=300)
def get_foc():
jData = request.get_json()
retData = {}
c_points = []
x = Symbol('x')
Xt = jData['init_func']
retData['init_func'] = Xt
derivative_data = []
try:
d1 = Derivative(Xt, x).doit()
retData['d1'] = printing.latex(d1)
d2 = Derivative(Xt, x, 2).doit()
retData['d2'] = printing.latex(d2)
# critical_points = solve(d1)
# print(critical_points)
# for idx,c in enumerate(critical_points):
# retData['critical_points_'+str(idx)] = str(round(d2.subs({x:c}).evalf(),3))
# print('found max mins')
for c in range(-100, 100, 1):
new_row = []
new_row.append((c / 20))
new_row.append((round((sympify(Xt)).subs({x: c / 20}).evalf(), 4)))
new_row.append((round(d1.subs({x: c / 20}).evalf(), 4)))
new_row.append((round(d2.subs({x: c / 20}).evalf(), 4)))
if c / 20 == 3 or c / 20 == -3:
new_row.append((round((sympify(Xt)).subs({
x: c / 20
}).evalf(), 4)))
else:
new_row.append(None)
derivative_data.append(new_row)
print('created data')
retData['forViz'] = str(derivative_data)
except SympifyError:
print('Parsing error')
error_msg = {'error': "Incorrect function. Please rectify."}
return jsonify(success=False, data=error_msg)
except:
print('Doesn\' t exist')
error_msg = {'error': 'Doesn\' t exist'}
return jsonify(success=False, data=error_msg)
return jsonify(success=True, data=retData)
def test_logic_printing():
from sympy import symbols, pretty
from sympy.printing import latex
syms = symbols('a:f')
expr = And(*syms)
assert latex(expr) == 'a \\wedge b \\wedge c \\wedge d \\wedge e \\wedge f'
assert pretty(expr) == 'And(a, b, c, d, e, f)'
assert str(expr) == 'And(a, b, c, d, e, f)'
def calc(s: str) -> LatexResult:
global sympy_dict
if (m := assignment_pattern.match(s)) is not None:
name = m.group(1)
value = parse_expr(m.group(2),
local_dict=sympy_dict,
transformations=TRANSFORMATIONS)
sympy_dict[name] = value
return LatexResult(latex(value))
def eval_math(obj):
if 'func' not in obj:
raise ValueError('must provide func')
func = obj['func']
if func not in FUNC_WHITELIST:
raise ValueError('func must be eval, latex, or literal')
if 'expr' not in obj:
raise ValueError('must provide expr')
expr = obj['expr']
if func == 'eval':
kwargs = {'ln_notation': 'True', 'inv_trig_style': 'power'}
return latex(eval(expr), **kwargs)
elif func == 'latex':
return latex(sympify(expr, evaluate=False))
elif func == 'literal':
return expr
return 'error'
def latex_equation(eq_string):
"""
Helper function to convert the right hand side of an equation string
`eq_string` to a LaTeX expression (not a full equation in LaTeX terms)
using `sympy`.
"""
# convert equation to latex
latex_eq = latex(DocumentWriter.to_sympy_expression(eq_string),
mode='plain')
return latex_eq
def latex(self, request=None, raw=False):
self.latex = latex(self.expression, mode='plain')
obj = {
'string': self.expressionString,
'javascript': self.javascript,
'latex': self.latex
}
if (raw):
return obj
else:
return JsonResponse(obj)
def latex_equation(eq_string):
"""
Helper function to convert the right hand side of an equation string
`eq_string` to a LaTeX expression (not a full equation in LaTeX terms)
using `sympy`.
"""
# convert equation to latex
latex_eq = latex(DocumentWriter.to_sympy_expression(eq_string),
mode='plain')
return latex_eq
def _repr_markdown_(self):
""" Return markdown representation for IPython notebook
"""
if self.ptformatter is not None and self.format is '' and isinstance(self.value, float):
# %precision magic only works for floats
fmt = self.ptformatter.float_format
return u"%s %s" % (fmt % self.value, self.unit._repr_markdown_())
if str(type(self.value)).find('sympy') > 0:
# sympy
return '${0}$ {1}'.format(printing.latex(self.value), self.unit.markdown)
return '{0:{format}} {1}'.format(self.value, self.unit.markdown, format=self.format)
def sympy2latex(sp_object, symbol_names):
"""
print latex code from sympy object
"""
if isinstance(sp_object, types.matrix_types) and any(el == 0
for el in
sp_object.shape):
return r'\left(\right)'
else:
return latex(sp_object, fold_short_frac=fold_short_frac,
mat_str=mat_str, mat_delim=mat_delim,
mul_symbol=mul_symbol, symbol_names=symbol_names)
def format_TeX_mat(self):
tex_mat = deepcopy(self.original_mat)
for c, i in enumerate(tex_mat):
tex_mat[c] = format_matrix_element(i)
tex_form = UnevaluatedExpr(
self.ket_row) * UnevaluatedExpr(tex_mat) * UnevaluatedExpr(
self.bra_col)
tex_formatted_form = R'$\hat{H}=' + printing.latex(
tex_form, mat_delim='(', mat_str='matrix') + '$'
return tex_formatted_form
def latex_SI_unit(self):
"""Latex repr of SI unit form.
Leverage sympy's latex function to compute the latex expression equivalent to
the SI-unit string representation of the Dimension.
See also
--------
Dimension.siunit_dict
"""
expr_SI = expand_dict_to_expr(self.siunit_dict())
return "$" + latex(expr_SI) + "$"
def sympy2latex(sp_object, symbol_names):
"""
print latex code from sympy object
"""
if isinstance(sp_object, types.matrix_types) and any(el == 0
for el in
sp_object.shape):
return r'\left(\right)'
else:
return latex(sp_object, fold_short_frac=fold_short_frac,
mat_str=mat_str, mat_delim=mat_delim,
mul_symbol=mul_symbol, symbol_names=symbol_names)
def render_expression(self, expression, differential=False):
"""
Function to render mathematical expression using
`sympy.printing.latex`
Parameters
----------
expression : str, Quantity
Expression that has to rendered
differential : bool, optional
Whether should be treated as variable in differential equation
Returns
-------
rend_exp : str
Markdown text for the expression
"""
# change to str
if isinstance(expression, Quantity):
expression = str(expression)
else:
if not isinstance(expression, str):
expression = str(expression)
# convert to sympy expression
expression = str_to_sympy(expression)
# check to be treated as differential variable
if differential:
# independent variable is always 't'
t = symbols('t')
expression = Derivative(expression, 't')
# render expression
rend_exp = latex(expression,
mode='equation',
itex=True,
mul_symbol='.')
# horrible way to remove _placeholder_{arg} inside brackets
rend_exp = rend_exp.replace('_placeholder_{arg}', '-')
rend_exp = rend_exp.replace('\operatorname', '')
# check GitHub based markdown rendering
if self.github_md:
# to remove `$$`
rend_exp = rend_exp[2:][:-2]
# link to render as image
git_rend_exp = (
'<img src="https://render.githubusercontent.com/render/math?math='
+ rend_exp + '">')
return git_rend_exp
# to remove `$` (in most md compiler single $ is used)
return rend_exp[1:][:-1]
def model(self, u, var, returnlatex=False):
from sympy.tensor.array import derive_by_array, tensorproduct
m = len(var)
gradient = Matrix(derive_by_array(u, var))
length = sqrt(trace(Matrix(tensorproduct(gradient, gradient)).reshape(m, m)))
n = gradient/length
div = Matrix(derive_by_array(n, var)).reshape(m, m)
div_n = trace(div)
# div_n = sym.simplify(div_n)
hessian = Matrix(derive_by_array(gradient, var)).reshape(m, m)
laplace = trace(hessian)
laplace = sym.simplify(laplace)
val = {'grad': gradient, 'Hessian': hessian, 'Laplace': laplace,
'unit_normal':n, 'div_unit_normal':div_n}
if returnlatex is False:
return val
else:
print('grad:\n', printing.latex(val['grad']))
print('Hessian:\n', printing.latex(val['Hessian']))
print('Laplace:\n', printing.latex(val['Laplace']))
print('unit_normal:\n', printing.latex(val['unit_normal']))
print('div_unit_normal:\n', printing.latex(val['div_unit_normal']))
def _repr_markdown_(self):
""" Return markdown representation for IPython notebook
"""
if self.ptformatter is not None and self.format is '' and isinstance(
self.value, float): # pragma: no cover
# %precision magic only works for floats
fmt = self.ptformatter.float_format
return u"%s %s" % (fmt % self.value, self.unit._repr_markdown_())
if str(type(self.value)).find('sympy') > 0:
# sympy
return '${0}$ {1}'.format(printing.latex(self.value),
self.unit.markdown)
return '{0:{format}} {1}'.format(self.value,
self.unit.markdown,
format=self.format)
def printable(num, digits=3, return_zero=False, return_one=True):
if num == 0:
if return_zero: return '0'
else: return ''
elif num == 1 and return_one == False:
return ''
elif num == -1 and return_one == False:
return '-'
# Surprisingly, sympy does not handle these cases
elif num == np.inf:
return r'\infty'
elif num == -np.inf:
return r'-\infty'
if isinstance(num, float):
return '%.3f' % num
else:
from sympy.printing import latex
return latex(num)
def printable(num,digits=3,return_zero=False,return_one=True):
if num==0:
if return_zero: return '0'
else: return ''
elif num==1 and return_one==False:
return ''
elif num==-1 and return_one==False:
return '-'
# Surprisingly, sympy does not handle these cases
elif num == np.inf:
return r'\infty'
elif num == -np.inf:
return r'-\infty'
if isinstance(num,float):
return '%.3f' % num
else:
from sympy.printing import latex
return latex(num)
def test_generated_cases(self):
failed_tests = []
n_tests = 20
print 'Generating', n_tests, 'test_cases\n'
for _ in np.arange(n_tests):
n_terms = np.random.randint(1, high=5)
expr = generate_term()
for _ in np.arange(n_terms - 1):
term = generate_term()
op = np.random.choice(ops)
if op == '+':
expr = expr + term
elif op == '-':
expr = expr - term
elif op == '*':
expr = expr * term
elif op == '/':
expr = expr / term
elif op == '^':
expr = expr**term
else:
assert False
s_l_expr = latex(expr)
try:
l_expr = process_sympy(s_l_expr)
equiv = equivalent(expr, l_expr)
e = None
except Exception as e:
# Parsing failed
l_expr = None
equiv = False
if not equiv:
print '%s %s' % (s_l_expr, 'PASSED' if equiv else 'FAILED')
failed_tests.append((s_l_expr, l_expr))
print 'sympy: %s\nlatex: %s' % (expr, l_expr)
if e is not None:
print e
print
if failed_tests:
print len(failed_tests), 'failed test cases'
assert len(failed_tests) == 0
def out(self, expr):
"""
expr: A sympy expression
_l = _latex()
_p = _l.out
_d = _l.symbol_names
from sympy import MatrixSymbol
from sympy import Symbol
from sympy import Matrix
X = MatrixSymbol('X', 3, 3)
_d[X]=r'\Phi_W'
_p(Matrix([[X], [X]]))
k = Symbol('k')
_d[k]=r'\k_W'
_p(Sum(X * k, (k, 1, 10)))
"""
l = latex(expr, symbol_names=self.symbol_names)
print(l)
return l
def write_results(self, filename):
'''
Write the model reduction results in a file given by filename.
The symbolic data is written in LaTeX.
'''
from sympy.printing import latex
f1 = open(filename, 'w')
f1.write('Model reduction results.\n')
for key, value in self.results_dict.items():
f1.write('A possible reduced model: \n \n')
f1.write('\n$x_{hat} = ')
f1.write(str(key.x))
f1.write('$\n\n\n\n')
for k in range(len(key.f)):
f1.write('\n$f_{hat}(' + str(k + 1) + ') = ')
f1.write(latex(key.f[k]))
f1.write('$\n\n')
f1.write('\n\n\n')
f1.write('\nError metric:')
f1.write(str(value[0]))
f1.write('\n\n\n')
f1.write('\nRobustness metric:')
f1.write(str(value[1]))
f1.write('\n\n\n')
f1.write('Other properties')
f1.write('\n\n\n')
f1.write('\n C = ')
f1.write(str(key.C))
f1.write('\n$ g = ')
f1.write(str(key.g))
f1.write('$\n h = ')
f1.write(str(key.h))
f1.write('\n$h = ')
f1.write(str(key.h))
f1.write('$\n Solutions : \n')
f1.write(str(key.x_sol))
f1.write('\n\n\n\n')
f1.write('\n Sensitivity Solutions : \n')
f1.write(str(key.S))
f1.write('\n\n\n\n')
f1.close()
def print_tex(data):
return '''
\\title{A Very Simple \\LaTeXe{} Template}
\\author{
Vitaly Surazhsky \\\\
Department of Computer Science\\\\
Technion---Israel Institute of Technology\\\\
Technion City, Haifa 32000, \\underline{Israel}
\\and
Yossi Gil\\\\
Department of Computer Science\\\\
Technion---Israel Institute of Technology\\\\
Technion City, Haifa 32000, \\underline{Israel}
}
\\date{\\today}
\\documentclass[12pt]{article}
\\begin{document}
$$%s$$
\\end{document}
''' % str(printing.latex(data))
def latex(self):
"""A laTeX representation of the compact form."""
from sympy.printing import latex
d = self.d
A = self.A
Ahat = self.Ahat
b = self.b
bhat = self.bhat
theta = self.theta
s= r'\begin{align}'
s+='\n'
s+=r' \begin{array}{c|'
s+='c'*(len(self)) +'|'
s+='c'*(len(self))
s+='}\n'
for i in range(len(self)):
s+=' '+latex(d[i])
for j in range(len(self)):
s+=' & '+latex(Ahat[i,j])
for j in range(len(self)):
s+=' & '+latex(A[i,j])
s+=r'\\'
s+='\n'
s+=r' \hline'
s+='\n'
s+= ' '+latex(theta)
for j in range(len(self)):
s+=' & '+latex(bhat[j])
for j in range(len(self)):
s+=' & '+latex(b[j])
s+='\n'
s+=r' \end{array}'
s+='\n'
s+=r'\end{align}'
s=s.replace('- -','')
return s
def latex(self):
"""A laTeX representation of the compact form."""
from sympy.printing import latex
d = self.d
A = self.A
Ahat = self.Ahat
b = self.b
bhat = self.bhat
theta = self.theta
s = r'\begin{align}'
s += '\n'
s += r' \begin{array}{c|'
s += 'c' * (len(self)) + '|'
s += 'c' * (len(self))
s += '}\n'
for i in range(len(self)):
s += ' ' + latex(d[i])
for j in range(len(self)):
s += ' & ' + latex(Ahat[i, j])
for j in range(len(self)):
s += ' & ' + latex(A[i, j])
s += r'\\'
s += '\n'
s += r' \hline'
s += '\n'
s += ' ' + latex(theta)
for j in range(len(self)):
s += ' & ' + latex(bhat[j])
for j in range(len(self)):
s += ' & ' + latex(b[j])
s += '\n'
s += r' \end{array}'
s += '\n'
s += r'\end{align}'
s = s.replace('- -', '')
return s
from sympy import *
#u_i_n = Symbol("u_i^{n}")
u_i_n = Symbol("u_i^n")
pprint(u_i_n)
import sympy.printing as printing
delta__y_l = symbols("Delta__y_l")
print(printing.latex(delta__y_l))
u_i_np1 = symbols("u_i__n+1")
print(printing.latex(u_i_np1))
u_ip1_np1 = symbols("u_i+1__n+1")
print(printing.latex(u_ip1_np1))
u_ip1j_np1 = symbols("u_{i+1,j}__n+1")
print(printing.latex(u_ip1j_np1))
pprint(u_ip1j_np1)
def a_matrix(theta, alpha, l, d):
return Matrix([[cos(theta), -1*(sin(theta)*cos(alpha)), sin(theta)*sin(alpha), l*cos(theta)],
[sin(theta), cos(theta)*cos(alpha), -1*cos(theta)*sin(alpha), l*sin(theta)],
[0, sin(alpha), cos(alpha), d],
[0, 0, 0, 1]])
output = eye(4)
a_matrices = [a_matrix(t_1, np.deg2rad(config['theta_1']['alpha']), config['theta_1']['l'], config['theta_1']['d']),
a_matrix(t_2, np.deg2rad(config['theta_2']['alpha']), config['theta_2']['l'], config['theta_2']['d']),
a_matrix(t_3, np.deg2rad(config['theta_3']['alpha']), config['theta_3']['l'], config['theta_3']['d']),
a_matrix(t_4, np.deg2rad(config['theta_4']['alpha']), config['theta_4']['l'], config['theta_4']['d']),
a_matrix(t_5, np.deg2rad(config['theta_5']['alpha']), config['theta_5']['l'], config['theta_5']['d'])]
for matrix in a_matrices:
output = output*matrix
print(latex(simplify(trigsimp(output[0,0]))) +'\n')
print(latex(simplify(trigsimp(output[0,1]))) +'\n')
print(latex(simplify(trigsimp(output[0,2]))) +'\n')
print(latex(simplify(trigsimp(output[0,3]))) +'\n')
print(latex(simplify(trigsimp(output[1,0]))) +'\n')
print(latex(simplify(trigsimp(output[1,1]))) +'\n')
print(latex(simplify(trigsimp(output[1,2]))) +'\n')
print(latex(simplify(trigsimp(output[1,3]))) +'\n')
print(latex(simplify(trigsimp(output[2,0]))) +'\n')
print(latex(simplify(trigsimp(output[2,1]))) +'\n')
print(latex(simplify(trigsimp(output[2,2]))) +'\n')
print(latex(simplify(trigsimp(output[2,3]))) +'\n')
#q1
q_1 = asin(((q_24-d_5*q_23-((l_3*q_23))/sin(t_3+t_4))-(l_2*q_23/sin(t_3+t_4)))/l_1)
q_2 = asin((q_23)/(sin(t_3+t_4)))-t_1
