-
Notifications
You must be signed in to change notification settings - Fork 2
/
latexify.py
493 lines (406 loc) · 14.2 KB
/
latexify.py
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
from Graph import *
import sympy as sp
from itertools import product
from core_matrices import *
from numerical_subs import *
from copy import deepcopy
"""
The file contains a very complete substitution function do_latex_subs() that
returns any symbolic input x after substituting symbolic parts by LaTeX. x
can be an sp.Syybol, sp.Matrix, sp.Eq, etc.
This file also contains various functions for printing matrices (sp.Matrix)
and lists (list[sp.Matrix]) in LaTeX
"""
def round_expr(expr, num_digits):
"""
This function rounds the numerical parts of any symbolic expression.
Parameters
----------
expr: most Sympy expressions
num_digits: int
Returns
-------
type(expr)
"""
return expr.xreplace(
{n: round(n, num_digits) for n in expr.atoms(sp.Number)})
def latex_time_superscript(time):
"""
This method returns a LaTeX superscript for various time inputs.
Parameters
----------
time: None or str or int
Must belong to list [None, "one", "n", "n_plus_one"] or be an int
Returns
-------
str
"""
if time is None:
superscript = ""
elif time == "one":
superscript = r"^{[1]}"
elif time == "n":
superscript = r"^{[n]}"
elif time == "n_plus_one":
superscript = r"^{[n+1]}"
elif isinstance(time, int):
superscript = r"^{[" + str(time) + r"]}"
else:
assert False
return superscript
def sb_cov_str(row, col, time):
"""
This method returns a symbolic string for the entry at position (row,
col) of the 1-time covariance matrix at time "time". Here row and col
are ints.
Parameters
----------
row: int
col: int
time: None or str or int
Returns
-------
str
"""
if time is None:
sb_str = "cov"
elif time in ["one", "n", "n_plus_one"]:
sb_str = "cov_" + time
elif isinstance(time, int):
sb_str = "cov_n" + str(time)
else:
assert False
sb_str += "_" + str(row) + "_" + str(col)
return sb_str
def latex_cov_str(row_nd, col_nd, time):
"""
This method returns a latex string for the entry at position (row_nd,
col_nd) of the 1-time covariance matrix at time "time". Here row_nd and
col_nd are node names.
Parameters
----------
row_nd: str
col_nd: str
time: None or str or int
Returns
-------
str
"""
superscript = latex_time_superscript(time)
if row_nd == col_nd:
latex_str = r"\sigma^2_{\underline{" + row_nd + \
r"}" + superscript + r"}"
else:
latex_str = r"\left\langle\underline{" + row_nd + \
r"}" + superscript + r",\underline{" + col_nd + \
r"}" + superscript + r"\right\rangle"
return latex_str
def sb_cov2times_str(row, col, time, delta=False):
"""
This method returns a symbolic string for the entry at position (row,
col) of the following 2-times covariance matrices between times time and
time+1. Here row_nd and col_nd are node names.
if delta=False, cov2times_n
if delta=True, d_cov2times_n
Parameters
----------
row: int
col: int
time: None or str or int
delta: bool
Returns
-------
str
"""
xtra_str = ""
if delta:
xtra_str = "d_"
if time == "n":
sb_str = xtra_str + "cov2times_n"
elif isinstance(time, int):
sb_str = xtra_str + "cov2times_n" + str(time)
else:
assert False
sb_str += "_" + str(row) + "_" + str(col)
return sb_str
def latex_cov2times_str(row_nd, col_nd, time, delta=False):
"""
This method returns a symbolic string for the entry at position (row_nd,
col_nd) of the following 2-times covariance matrices between times time
and time+1. Here row_nd and col_nd are node names.
if delta=False, cov2times_n
if delta=True, d_cov2times_n
Parameters
----------
row_nd: str
col_nd: str
time: None or str or int
delta: bool
Returns
-------
str
"""
if time == "n":
superscript = latex_time_superscript("n")
superscript_plus = latex_time_superscript("n_plus_one")
elif isinstance(time, int):
superscript = latex_time_superscript(time)
superscript_plus = latex_time_superscript(time + 1)
else:
assert False
xtra_str = ""
if delta:
xtra_str = r"\Delta "
latex_str = r"\left\langle\underline{" + row_nd + \
r"}" + superscript + r"," + xtra_str + \
r"\underline{" + col_nd + \
r"}" + superscript_plus + r"\right\rangle"
return latex_str
def do_latex_subs(graph, x, time=None):
"""
This method substitutes
sp.Symbol("sigma_eps_" + str(i))
sp.Symbol("sigma_" + str(i))
sp.Symbol("alpha_" + str(row) + "_L_" + str(col))
sp.Symbol("beta_" + str(row) + "_L_" + str(col))
sp.Symbol("cov_" + str(row) + "_" + str(col))
sp.Symbol("cov_one_" + str(row) + "_" + str(col))
sp.Symbol("cov_n_" + str(row) + "_" + str(col))
sp.Symbol("cov_n_plus_one_" + str(row) + "_" + str(col))
sp.Symbol("cov_n" + str(time) + "_" + str(row) + "_" + str(col))
sp.Symbol("cov2times_n" + str(row) + "_" + str(col))
sp.Symbol("cov2times_n" + str(time) + str(row) + "_" + str(col))
sp.Symbol("d_cov2times_n" + str(row) + "_" + str(col))
sp.Symbol("d_cov2times_n" + str(time) + str(row) + "_" + str(col))
sp.Symbol("ee_" + str(row) + "_" + str(col))
sp.Symbol("rho_" + str(row) + "_" + str(col))
sp.Symbol("pder_" + str(row) + "_wrt_" + str(col))
sp.Symbol("G_" + str(row) + "_" + str(col))
sp.Symbol("err_" + str(row) + "_" + str(col))
by their latex counterparts. str(i), str(row) and str(col) are all
replaced by a node name from the list graph.ord_nodes
Parameters
----------
graph: Graph
x: sp.Symbol or sp.Matrix or sp.Eq
time: None or str or int
Returns
-------
type(x)
"""
num_nds = graph.num_nds
for i in range(num_nds):
nd = graph.ord_nodes[i]
latex_str = r"\sigma_{\underline{\epsilon}" + \
r"_{\underline{" + nd + r"}}}"
sb_str = "sigma_eps_" + str(i)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
latex_str = r"\sigma_{\underline{" + nd + r"}}"
sb_str = "sigma_nd_" + str(i)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
for row, col in product(range(num_nds), range(num_nds)):
row_nd = graph.ord_nodes[row]
col_nd = graph.ord_nodes[col]
latex_str = r"\alpha_{\underline{" + row_nd + \
r"}|\underline{" + col_nd + r"}}"
sb_str = "alpha_" + str(row) + "_L_" + str(col)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
latex_str = r"\beta_{\underline{" + row_nd + \
r"}|\underline{" + col_nd + r"}}"
sb_str = "beta_" + str(row) + "_L_" + str(col)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
for time0 in [None, "one", "n", "n_plus_one"]:
latex_str = latex_cov_str(row_nd, col_nd, time0)
sb_str = sb_cov_str(row, col, time0)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
for delta in [True, False]:
latex_str = latex_cov2times_str(row_nd, col_nd, time="n",
delta=delta)
sb_str = sb_cov2times_str(row, col, time="n",
delta=delta)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
# print("vvbgh", time)
if isinstance(time, int):
latex_str = latex_cov_str(row_nd, col_nd, time)
sb_str = sb_cov_str(row, col, time)
# print("vvbg", sb_str, latex_str)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
latex_str = latex_cov2times_str(row_nd, col_nd, time)
sb_str = sb_cov2times_str(row, col, time)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
if row_nd == col_nd:
latex_str = r"\sigma^2_{\underline{\epsilon}" + \
r"_{\underline{" + row_nd + r"}}}"
else:
latex_str = r"\left\langle\underline{\epsilon}_\underline{" + \
row_nd + r"},\underline{\epsilon}_\underline{" + \
col_nd + r"}\right\rangle"
sb_str = "ee_" + str(row) + "_" + str(col)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
latex_str = r"\rho_{\underline{" + row_nd + \
r"},\underline{" + col_nd + r"}}"
sb_str = "rho_" + str(row) + "_" + str(col)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
latex_str = r"\frac{\partial\underline{" + row_nd + \
r"}}{\partial\underline{" + col_nd + r"}}"
sb_str = "pder_" + str(row) + "_wrt_" + str(col)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
latex_str = r"G_{\underline{" + row_nd + \
r"},\underline{" + col_nd + r"}}"
sb_str = "G_" + str(row) + "_" + str(col)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
latex_str = r"err_{\underline{" + row_nd + \
r"},\underline{" + col_nd + r"}}"
sb_str = "err_" + str(row) + "_" + str(col)
x = x.subs(sp.Symbol(sb_str), sp.Symbol(latex_str))
return x
def print_all_core_mats_after_latex_subs(graph):
"""
This method is for debugging 'do_latex_subs()'. It creates the core
matrices built by the functions in file core_matrices.py. Then it passes
those core matrices through 'do_latex_subs()'. Finally, it prints the
changed core matrices.
Parameters
----------
graph: Graph
Returns
-------
None
"""
dim = graph.num_nds
def sb_mat_print(x, time=None):
x = do_latex_subs(graph, x, time)
print("\n", x)
print(sp.latex(x))
sb_mat_print(sigma_eps_sb_mat(dim))
sb_mat_print(sigma_nd_sb_mat(dim))
sb_mat_print(alpha_sb_mat(dim))
sb_mat_print(beta_sb_mat(dim))
sb_mat_print(cov_sb_mat(dim))
sb_mat_print(cov_sb_mat(dim, time="one"))
sb_mat_print(cov_sb_mat(dim, time=5))
sb_mat_print(cov2times_sb_mat(dim))
sb_mat_print(cov2times_sb_mat(dim, time=5))
sb_mat_print(cov2times_sb_mat(dim, delta=True))
sb_mat_print(cov2times_sb_mat(dim, time=5, delta=True))
sb_mat_print(ee_sb_mat(dim))
sb_mat_print(rho_sb_mat(dim))
sb_mat_print(jacobian_sb_mat(dim))
def create_eq_list_from_matrix(mat, mat_name, graph, time):
"""
This method takes as input an sp.Matrix mat and creates a list[sp.Eq]
from it. The latter list can then be printed using latexify.print_list_sb()
Parameters
----------
mat: sp.Matrix
mat_name: str
graph: Graph
time: None or str or int
Returns
-------
list[sp.Eq]
"""
eq_list = []
dim = graph.num_nds
for row, col in product(range(dim), range(dim)):
if row <= col and mat_name == "alpha":
continue
mat_str = mat_name
sep = "_"
if mat_name in ["alpha", "beta"]:
sep = "_L_"
if mat_name == "pder":
sep = "_wrt_"
if isinstance(time, int):
mat_str += str(time)
mat_str += "_" + str(row) + sep + str(col)
eq_list.append(sp.Eq(sp.Symbol(mat_str), mat[row, col]))
return eq_list
def print_matrix_sb(mat, mat_name, graph, verbose=False, time=None):
"""
This method renders in latex, in a jupyter notebook (but not in the
console), the entries, one at a time, of the symbolic matrix 'mat' named
'mat_name'. Iff verbose=True, it also prints the same thing in ASCII,
in both the console and jupyter notebook.
Parameters
----------
mat: sp.Matrix
mat_name: str
graph: Graph or FBackGraph
verbose: bool
time: None or str or int
Returns
-------
sp.Symbol
"""
eq_list = create_eq_list_from_matrix(mat, mat_name, graph, time)
return print_list_sb(eq_list, graph, verbose=verbose, time=time)
def print_list_sb(eq_list, graph, verbose=False,
time=None, comment_list=None, rounded=True,
prefix_str=None):
"""
This method renders in latex, in a jupyter notebook (but not on the
console), a list 'eq_list' of type list[sp.Eq]. Iff verbose=True,
it also prints the same thing in ASCII, in both the console and jupyter
notebook.
Parameters
----------
eq_list: list[sp.Eq]
graph: Graph or FBackGraph
verbose: Bool
time: None or str or int
comment_list: list[str]
This List[str] should be of the same length as eq_list
rounded: bool
This is True iff the numerical parts of the answer are to be rounded.
prefix_str: str
prefix string to start each line printed.
Returns
-------
sp.Symbol
"""
if comment_list is None:
comment_list = [""]*len(eq_list)
assert len(eq_list) == len(comment_list)
if prefix_str is None:
prefix_str = ""
str0 = ""
x = eq_list
x_copy = deepcopy(x)
# print("lllj", type(x))
if verbose:
for i in range(len(x)):
print(prefix_str + " " + str(x[i]) + "\t" + comment_list[i] + "\n")
str0 += r"\begin{array}{l}" + "\n"
for i in range(len(x)):
if rounded:
x_copy[i] = round_expr(x_copy[i], 6)
x_copy[i] = do_latex_subs(graph, x_copy[i], time)
x_copy[i] = sp.latex(x_copy[i])
if len(prefix_str) != 0:
str0 += r"\text{" + prefix_str + r" } "
str0 += x_copy[i] + r"\quad" + comment_list[i] + "\n" + r"\\"\
+ "\n"
str0 = str0[:-3]
str0 += r"\end{array}"
# print("lluj", str0)
if verbose:
print("\n", str0)
# this return prints nothing on the console, but, if
# inserted as the last line of a jupyter cell, it renders
# the latex in str0
return sp.Symbol(str0)
if __name__ == "__main__":
def main():
dot = "digraph G {\n" \
"a->b;\n" \
"a->s;\n" \
"n->s,a,b;\n" \
"b->s\n" \
"}"
with open("tempo13.txt", "w") as file:
file.write(dot)
path = 'tempo13.txt'
graph = Graph(path)
print_all_core_mats_after_latex_subs(graph)
main()