def process(tag):
"""
Converts html "latex" tag to actual latex.
"""
if isinstance(tag, elements.LatexNavigableString):
yield utf8tolatex(tag.strip('\n'), non_ascii_only=True, brackets=False)
elif isinstance(tag, bs4.element.NavigableString):
yield utf8tolatex(Translator.escape(tag).strip('\n'),
non_ascii_only=True,
brackets=False)
else:
yield tag.get('data-latex-open')
yield tag.get('data-latex-begin-prefix')
yield tag.get('data-latex-begin')
yield tag.get('data-latex-begin-suffix')
for child in tag.children:
for p in Translator.process(child):
yield p
yield tag.get('data-latex-end-prefix')
yield tag.get('data-latex-end')
yield tag.get('data-latex-end-suffix')
yield tag.get('data-latex-close')
def generate_latex_label(label):
"""Convert a label to a valid latex string."""
if not HAS_PYLATEX:
raise MissingOptionalLibraryError(
libname="pylatexenc",
name="the latex and latex_source circuit drawers",
pip_install="pip install pylatexenc",
)
regex = re.compile(r"(?<!\\)\$(.*)(?<!\\)\$")
match = regex.search(label)
if not match:
label = label.replace(r"\$", "$")
final_str = utf8tolatex(label, non_ascii_only=True)
else:
mathmode_string = match.group(1).replace(r"\$", "$")
before_match = label[: match.start()]
before_match = before_match.replace(r"\$", "$")
after_match = label[match.end() :]
after_match = after_match.replace(r"\$", "$")
final_str = (
utf8tolatex(before_match, non_ascii_only=True)
+ mathmode_string
+ utf8tolatex(after_match, non_ascii_only=True)
)
return final_str.replace(" ", "\\,") # Put in proper spaces
def _add_caption(label, caption):
"""Adds a caption to a label using LaTeX"""
full_label = ''
if label != '' or caption != '':
if label != '':
label = utf8tolatex(label)
label = label + r'\\*'
if caption != '':
caption = utf8tolatex(caption)
caption = r'\textit{\small{' + caption + r'}}'
full_label = r'\begin{center}' + label + caption + r'\end{center}'
return full_label
def create_template(self,
oral,
fp1,
template='template.tex',
comment=False,
dirname='papers'):
def read_template(filename):
# with open(filename, 'r', encoding='utf-8') as template_file:
with open(filename, 'r') as template_file:
template_file_content = template_file.read()
return Template(template_file_content)
T_paper = read_template(template)
kwargs = {}
kwargs['FNAME'] = utf8tolatex(oral['firstname'])
kwargs['FNAMEI'] = utf8tolatex(oral['firstname'][:1])
kwargs['LNAME'] = utf8tolatex(oral['lastname'])
if 'Affiliation' in oral:
kwargs['INAME'] = utf8tolatex(oral['Affiliation'])
if 'affiliation' in oral:
kwargs['INAME'] = utf8tolatex(oral['affiliation'])
kwargs['EMAIL'] = oral['email']
if 'Title' in oral:
kwargs['TITLE'] = utf8tolatex(oral['Title'])
if 'title' in oral:
kwargs['TITLE'] = utf8tolatex(oral['title'])
if 'Abstract' in oral:
kwargs['ABSTRACT'] = utf8tolatex(oral['Abstract'])
if 'abstract' in oral:
kwargs['ABSTRACT'] = utf8tolatex(oral['abstract'])
kwargs['F1'] = '$^1$'
kwargs['F2'] = '$^2$'
kwargs['F3'] = '$^3$'
kwargs['LENA'] = str(len(kwargs['ABSTRACT']))
kwargs['LENW'] = ""
kwargs['PCODE'] = oral['pcode'].replace('.', '-')
pcode = oral['pcode'].replace('.', '-')
if comment:
kwargs['COMMENT'] = "%"
kwargs['NOCOMMENT'] = ""
else:
kwargs['COMMENT'] = ""
kwargs['NOCOMMENT'] = "%"
t1 = T_paper.substitute(**kwargs)
fn = dirname + '/' + pcode + '.tex' # no, it should be P1-12.tex, not P1.12.tex
print("Writing %s" % fn)
fp = open(fn, 'w')
fp.write(t1)
fp.close()
msg = '\\tocinsertentry[r]{%s}{%s.~%s}{authors/%s_inc}\n' % (
kwargs['TITLE'], oral['firstname'], oral['lastname'],
oral['pcode'])
fp1.write(msg)
def toascii(val):
val = utf8tolatex(val)
for old, new in [(r"{\textquoteright}", "`"), (r"{\textbackslash}", "\\"),
(r"{\{}", "{"), (r"{\}}", "}"), (r"\''", r'\"'),
(r"{\$}", "$"), (r"{\textasciitilde}", "~")]:
val = val.replace(old, new)
return val
def format_paper_list_entry(arxiv_id, submission_comment='', desired_authors=None, author_list_length_limit=10):
import re
from pylatexenc.latexencode import utf8tolatex
import textwrap
wrapper = textwrap.TextWrapper(initial_indent=' ', subsequent_indent=' ', width=70,
break_long_words=False, break_on_hyphens=False)
entry = get_entry_by_arxiv_id(arxiv_id)
authors = [author['name'] for author in entry['authors']]
authors = limit_author_list(authors, desired_authors=desired_authors, author_list_length_limit=author_list_length_limit)
authors = [utf8tolatex(a).replace(r'{\textasciitilde}', '~') for a in authors]
author_list = ', '.join(authors)
title = r'\textit{{{0}}}'.format(entry['title'])
submission_comment = submission_comment.strip()
if not submission_comment:
journal_ref = get_journal_reference(entry, r'{pub} \textbf{{{volume}}}, {issue} ({year})')
if journal_ref:
submission_comment = ', published as ' + journal_ref.strip()
else:
submission_comment = get_submission_comment(entry)
if submission_comment and not submission_comment.startswith(','):
submission_comment = ', ' + submission_comment
arxiv_url = re.sub('v[0-9]*$', '', entry['id'].replace('http://', 'https://'))
entry = r'\item {0}, {1}{2}; available at \url{{{3}}}'.format(author_list, title, submission_comment, arxiv_url)
entry = wrapper.fill(' '.join(entry.split()))
return entry
def format_entry(self, record):
"""
Special customization function for BibTex entries. Sanitizes HTML characters from any part of the entry, ensures
that page ranges use two dashes, and abbreviates journals if possible.
:param record: the entry dict to modify
:return: the modified dict
"""
for key, value in record.items():
record[key] = sanitize_html_strings(value)
record = bibtexparser.customization.page_double_hyphen(record)
if 'journal' in record:
record['journal'] = abbreviate_journal(record['journal'])
# This should happen after we've sanitized the author string for miscellanceous HTML crud.
record['ID'] = self.format_id(record)
for key, value in record.items():
if key != 'ID':
# This needs to happen after we create the ID, because the id creation can remove accents from unicode
# characters but not Latex accents. The non_ascii_only is needed to avoid escaping special Latex
# characters already present, like with e.g. {NO}$_2$
record[key] = utf8tolatex(record[key], non_ascii_only=True)
return record
def thefilter(x):
if (self.fix_swedish_a):
x = re.sub(r'\\AA\s+', r'\AA{}', x);
if (self.encode_utf8_to_latex):
x = latexencode.utf8tolatex(x, non_ascii_only=True);
if (self.encode_latex_to_utf8):
x = latex2text.latex2text(x);
return x
def test_basic(self):
input = u"\"\N{LATIN CAPITAL LETTER A WITH GRAVE} votre sant\N{LATIN SMALL LETTER E WITH ACUTE}!\" s'exclama le ma\N{LATIN SMALL LETTER I WITH CIRCUMFLEX}tre de maison \N{LATIN SMALL LETTER A WITH GRAVE} 100%."
self.assertEqual(
utf8tolatex(input),
u"''{\\`A} votre sant{\\'e}!'' s'exclama le ma{\\^\\i}tre de maison {\\`a} 100{\\%}."
)
self.assertEqual(
utf8tolatex(input, non_ascii_only=True),
u"\"{\\`A} votre sant{\\'e}!\" s'exclama le ma{\\^\\i}tre de maison {\\`a} 100%."
)
# TODO: in the future, be clever and avoid breaking macros like this ("\itre"):
self.assertEqual(
utf8tolatex(input, brackets=False),
u"''\\`A votre sant\\'e!'' s'exclama le ma\\^\\itre de maison \\`a 100\%."
)
ascii_chars_convert = u" \" # $ % & \\ _ { } ~ "
self.assertEqual(utf8tolatex(ascii_chars_convert, non_ascii_only=True),
ascii_chars_convert)
self.assertEqual(
utf8tolatex(ascii_chars_convert, non_ascii_only=False),
u" '' {\\#} {\\$} {\\%} {\\&} {\\textbackslash} {\\_} {\\{} {\\}} {\\textasciitilde} "
)
# generates warnings -- that's good
test_bad_chars = u"A unicode character: \N{THAI CHARACTER THO THONG}"
self.assertEqual(
utf8tolatex(test_bad_chars, substitute_bad_chars=False),
test_bad_chars) # unchanged
self.assertEqual(
utf8tolatex(test_bad_chars, substitute_bad_chars=True),
u"A unicode character: {\\bfseries ?}")
def cleanUpText(string):
# clean up text
cleanedUpText = latexencode.utf8tolatex(string, substitute_bad_chars=True)
cleanedUpText = re.sub("- ", "", string)
cleanedUpText = re.sub(r"([><])", r"$\1$", cleanedUpText)
cleanedUpText = re.sub("([a-z])([A-Z])", r"\1 \2", cleanedUpText)
return cleanedUpText
def latex(self):
"""Return the corresponding math mode latex string."""
try:
from pylatexenc.latexencode import utf8tolatex
except ImportError as ex:
raise MissingOptionalLibraryError("pylatexenc",
"latex-from-qasm exporter",
"pip install pylatexenc") from ex
return utf8tolatex(self.sym())
def generate_latex_label(label):
"""Convert a label to a valid latex string."""
from pylatexenc.latexencode import utf8tolatex
regex = re.compile(r"(?<!\\)\$(.*)(?<!\\)\$")
match = regex.search(label)
if not match:
label = label.replace(r"\$", "$")
final_str = utf8tolatex(label, non_ascii_only=True)
else:
mathmode_string = match.group(1).replace(r"\$", "$")
before_match = label[:match.start()]
before_match = before_match.replace(r"\$", "$")
after_match = label[match.end():]
after_match = after_match.replace(r"\$", "$")
final_str = (utf8tolatex(before_match, non_ascii_only=True) +
mathmode_string +
utf8tolatex(after_match, non_ascii_only=True))
return final_str.replace(" ", "\\,") # Put in proper spaces
def encode_laTex(text):
"""
:param text:
:return:
"""
# make sure the input has unicode type
if (isinstance(text, str)):
text = unicode(text)
# character subtitution
return utf8tolatex(text)
def latex(self, prec=15, nested_scope=None):
"""Return the corresponding math mode latex string."""
del prec, nested_scope # unused
try:
from pylatexenc.latexencode import utf8tolatex
except ImportError:
raise ImportError("To export latex from qasm "
"pylatexenc needs to be installed. Run "
"'pip install pylatexenc' before using this "
"method.")
return utf8tolatex(self.value)
def generate_latex_label(label):
"""Convert a label to a valid latex string."""
if not HAS_PYLATEX:
raise ImportError('The latex and latex_source drawers need '
'pylatexenc installed. Run "pip install '
'pylatexenc" before using the latex or '
'latex_source drawers.')
regex = re.compile(r"(?<!\\)\$(.*)(?<!\\)\$")
match = regex.search(label)
if not match:
label = label.replace(r'\$', '$')
return utf8tolatex(label)
else:
mathmode_string = match.group(1).replace(r'\$', '$')
before_match = label[:match.start()]
before_match = before_match.replace(r'\$', '$')
after_match = label[match.end():]
after_match = after_match.replace(r'\$', '$')
return utf8tolatex(before_match) + mathmode_string + utf8tolatex(
after_match)
def parse_accents_str(string):
"""Function that reads a string and translates
all the known unicode characters into latex commands.
Parameters:
string: the string to be translated
Output:
the processed string
"""
if string is not None and string != "":
string = utf8tolatex(string, non_ascii_only=True)
return string
def thefilter(x):
if (self.fix_space_after_escape):
x = do_fix_space_after_escape(x)
if (self.fix_swedish_a):
# OBSOLETE, but still accepted for backwards compatibility
x = re.sub(r'\\AA\s+', r'\AA{}', x);
x = re.sub(r'\\o\s+', r'\o{}', x);
if (self.encode_utf8_to_latex):
# Need non_ascii_only=True because we might have e.g. braces or other
# LaTeX code we want to preserve.
x = latexencode.utf8tolatex(x, non_ascii_only=True);
if (self.encode_latex_to_utf8):
x = latex2text.latex2text(x);
return x
def test_all(self):
loglevel = logging.getLogger().level
logging.getLogger().setLevel(logging.CRITICAL)
def fn(x, bdir=os.path.realpath(os.path.abspath(os.path.dirname(__file__)))):
return os.path.join(bdir, x)
with codecs.open(fn('_tmp_uni_chars_test.temp.txt'), 'w', encoding='utf-8') as testf:
for i in range(0x10FFFF):
# iter over all valid unicode characters
try:
chrname = unicodedata.name(unichr(i)) # test if valid, i.e., it has a UNICODE NAME
except ValueError:
continue
line = "0x%04X %-50s |%s|\n"%(i, '['+chrname+']', unichr(i))
# try to encode it using utf8tolatex
try:
enc = utf8tolatex(line, fail_bad_chars=True)
except ValueError:
continue
testf.write(enc)
with codecs.open(fn('uni_chars_test_previous.txt'), 'r', encoding='utf-8') as reff, \
codecs.open(fn('_tmp_uni_chars_test.temp.txt'), 'r', encoding='utf-8') as testf:
a = reff.readlines()
b = testf.readlines()
logging.getLogger().setLevel(loglevel)
logger = logging.getLogger(__name__)
# only check up to the supported unicode range
if sys.maxunicode < 0x10FFFF:
logger.warning("Only checking up to unicode U+%X, you python build doesn't support higher",
sys.maxunicode)
afiltered = [ aline for aline in a
if int(aline[:aline.find(' ')], 0) < sys.maxunicode ]
a = afiltered
s = difflib.unified_diff(a, b,
fromfile='uni_chars_test_previous.txt',
tofile='_tmp_uni_chars_test.temp.txt')
diffmsg = "".join(list(s)).strip()
if diffmsg:
print(diffmsg)
raise self.failureException("Unicode coverage tests failed. See full diff above.")
def latex(self, prec=None, nested_scope=None):
"""Return the corresponding math mode latex string."""
if prec is not None:
warnings.warn('Parameter \'BinaryOp.latex(..., prec)\' is no longer used '
'and is being deprecated.', DeprecationWarning, 2)
if nested_scope is not None:
warnings.warn('Parameter \'BinaryOp.latex(..., nested_scope)\' is no longer used '
'and is being deprecated.', DeprecationWarning, 2)
try:
from pylatexenc.latexencode import utf8tolatex
except ImportError:
raise ImportError("To export latex from qasm "
"pylatexenc needs to be installed. Run "
"'pip install pylatexenc' before using this "
"method.")
return utf8tolatex(self.sym())
def export_to_bytes(self):
tiers = self.createTiers(self.conjugations)
formatted_tiers = []
for t in tiers:
tier_list = []
for item in BUILD_CONFIG['filemaker']['latex_tiers']:
if item['name'] == 'translation':
tier_list.append(t['translation'])
else:
tier_list.append(
self.appendTier(t[item['name']], item['sep']))
formatted_tiers.append(tier_list)
data = {"title": self.title, "conjugations": formatted_tiers}
tex = utf8tolatex(self.sanitize(self.template.render(data=data)),
non_ascii_only=True)
return bytes(tex, encoding='utf8')
def write_to_temp(self, ftype="tex"):
formatted_tiers = [[conjugation["output"] for conjugation in x]
for x in self.formatted_data]
data = {
"title": self.settings["heading"],
"conjugations": formatted_tiers
}
tex = utf8tolatex(self.sanitize(self.template.render(data=data)),
non_ascii_only=True)
fd, path = mkstemp()
if ftype == "pdf":
pdf = build_pdf(tex)
pdf.save_to(path)
else:
with open(path, "w") as f:
f.write(tex)
return path
def _flush_output(out, out_buffer, convert_to_latex):
output = out_buffer.getvalue()
out_buffer.close()
if convert_to_latex:
from pylatexenc.latexencode import utf8tolatex
output = (
"\\documentclass{article}\\begin{document}"
"\\section{Physalia Hypothesis Test}\n" + utf8tolatex(output)
).replace(GREEK_ALPHABET["H0"], "$H_0$").replace(
GREEK_ALPHABET["H1"], "$H_1$"
).replace("<", "\\ensuremath{<}").replace("\n", "\n\n").replace(
"1.", '\\begin{enumerate}\n\\item '
).replace("2.", '\\item ').replace(
"3. All populations have equal standard deviation.",
'\\item All populations have equal standard deviation.\n\\end{enumerate}'
) + "\\end{document}"
out.write(output)
def parse_accents_record(record):
"""Function that reads the fields inside a bibtex dictionary
and translates all the known unicode characters into latex commands.
Parameters:
record: the bibtex dictionary generated by bibtexparser
Output:
the dictionary after having processed all the fields
"""
for val in record:
if val != "ID" and len(record[val].strip()) > 0:
tmp = utf8tolatex(record[val], non_ascii_only=True)
if tmp != record[val]:
pBLogger.info(pastr.converting % record["ID"])
pBLogger.info(pastr.infodashes + tmp.encode("utf-8"))
accents_changed.append(record["ID"])
record[val] = tmp
return record
def sanitize(text):
"""
This is a helper function that should be used to sanitize text for LaTeX output.
You'll probably need to edit the LaTeX slightly afterwards, but it should look pretty good!
"""
results = text
# Fix quotation marks
if results.startswith('"'):
results = "``" + results[1:]
if results.startswith("'"):
results = "`" + results[1:]
results = results.replace(" '", ' `')
results = results.replace(' "', ' ``')
results = results.replace('"', "''")
# Fix unicode characters. Bad characters are replaced by a bold '?'
results = utf8tolatex(results, substitute_bad_chars=True)
# Fix math entries a^b
results = re.sub(r'(.\^.)', r'$\1$', results)
# Fix math entries a_b (note that utf8tolatex has converted _ to {\_})
results = re.sub(r'(.){\\_}(.)', r'$\1_\2$', results)
return results
def get_latex_from_LT(LT_list, page_number, image_res=None):
latex_str = ""
prevfontname = ""
prevfontstyle = ""
for i in range(len(LT_list)):
if isinstance(LT_list[i], LTChar):
attr = re.split(",|-", LT_list[i].fontname)
if (prevfontname != attr[0]):
# latex_str += "\\fontfamily{" + attr[0] + "}\\selectfont "
prevfontname = attr[0]
if (len(attr) > 1 and prevfontstyle != attr[1]):
if prevfontstyle:
latex_str += "}"
prevfontstyle = attr[1]
if prevfontstyle.startswith("Bold"):
latex_str += "\\textbf{"
elif prevfontstyle.startswith("Italic"):
latex_str += "\\textit{"
elif len(attr) == 1:
if prevfontstyle:
latex_str += "}"
prevfontstyle = ""
latex_str += utf8tolatex(LT_list[i].get_text())
elif isinstance(LT_list[i], LTFigure) or isinstance(
LT_list[i], LTImage):
if prevfontstyle:
latex_str += "}"
prevfontstyle = ""
img_name = save_image(LT_list[i], page_number, "images", image_res)
if img_name:
latex_str += "\\begin{figure}\\includegraphics[width=\\linewidth]{" + str(
img_name) + "}\\end{figure}"
# elif isinstance(LT_list[i], LTAnno):
# latex_str += "\\newline\n"
if prevfontstyle:
latex_str += "}"
prevfontstyle = ""
return latex_str
def latex(self, prec=None, nested_scope=None):
"""Return the corresponding math mode latex string."""
if prec is not None:
warnings.warn(
"Parameter 'Real.latex(..., prec)' is no longer used and is being deprecated.",
DeprecationWarning,
2,
)
if nested_scope is not None:
warnings.warn(
"Parameter 'Real.latex(..., nested_scope)' is no longer used and is "
"being deprecated.",
DeprecationWarning,
2,
)
try:
from pylatexenc.latexencode import utf8tolatex
except ImportError as ex:
raise MissingOptionalLibraryError("pylatexenc",
"latex-from-qasm exporter",
"pip install pylatexenc") from ex
return utf8tolatex(self.value)
def plot_lines(y_vectors,
x=None,
labels=None,
title='Loss',
xlabel='',
ylabel='',
caption='',
out_file=None):
"""Plots a line graph for each y vector in a list of y vectors"""
# Ensure all y_vectors are the same length
lens = np.array([len(_) for _ in y_vectors])
if not np.all(len(y_vectors[0]) == lens):
raise ValueError('All vectors in y_vectors must be the same length')
# Default x and labels to array indices
if x is None:
x = range(len(y_vectors[0]))
if labels is None:
labels = [str(_) for _ in range(len(y_vectors[0]))]
rc('text', usetex=True)
full_xlabel = _add_caption(xlabel, caption)
for y, label in zip(y_vectors, labels):
plt.plot(x, y, label=utf8tolatex(label))
plt.legend(loc='best')
plt.title(title)
plt.xlabel(full_xlabel)
plt.ylabel(ylabel)
# Output to file or to screen
if out_file is not None:
plt.savefig(out_file)
else:
plt.show()
rc('text', usetex=False)
plt.close()
def dblp_comp(inputfile, outputfile):
# counters
dblp_cnt = 0
local_cnt = 0
parser = BibTexParser()
parser.customization = homogeneize_latex_encoding
with open(inputfile) as input_file:
bib_database = bibtexparser.load(input_file, parser=parser)
for entry in bib_database.entries:
try:
title = entry['title']
except:
pprint(style.FAIL, 'LOCL', '(Unknown)',
'entry does not have a title')
local_cnt += 1
continue
title = title.replace('}', '')
title = title.replace('{', '')
title = title.replace('\n', ' ')
searchstr = re.sub(' ', '$.', title)
searchstr = re.sub('$', '$', searchstr)
try:
xmlstr = urllib2.urlopen(
"http://dblp.org/search/publ/api/?q=" + searchstr + "&format=xml&h=1").read()
except:
pprint(style.FAIL, 'LOCL', title,
'failed to fetch results from DBLP')
local_cnt += 1
continue
xml = ET.fromstring(xmlstr)
hit = xml.find('./hits/hit/info/url')
if hit != None:
xmlstr = urllib2.urlopen(
re.sub('/rec/', '/rec/xml/', hit.text)).read()
xml = ET.fromstring(xmlstr)
hit = xml.find('./')
t = re.sub('\.$', '', hit.find('title').text)
t2 = t
t2 = t2.replace('}', '')
t2 = t2.replace('{', '')
if t2.lower() == title.lower():
# we found the same title; add the information on DBLP
pprint(style.OKGREEN, 'DBLP', t)
dblp_cnt += 1
entrytype = entry['ENTRYTYPE']
entryid = entry['ID']
entry.clear()
entry['ENTRYTYPE'] = entrytype
entry['ID'] = entryid
# Title. Use t2 if you wish a title without brackets
entry['title'] = latexencode.utf8tolatex(t)
# Authors
alist = ''
first = True
for a in hit.findall('author'):
if not first:
alist += " and "
first = False
alist += a.text
entry['author'] = latexencode.utf8tolatex(alist)
# DOI
try:
doi = hit.find('ee').text.split('/')[
3] + '/' + hit.find('ee').text.split('/')[4]
entry['doi'] = latexencode.utf8tolatex(doi)
except:
pass
# Other fields
for i in hit:
if i.tag not in exceptions:
entry[i.tag] = latexencode.utf8tolatex(i.text)
else:
# if we don't find results, we keep our old data
pprint(style.WARNING, 'LOCL', t2, 'titles do not match', title)
local_cnt += 1
else:
pprint(style.WARNING, 'LOCL', title, 'entry not found')
local_cnt += 1
# As recommended by DBLP, sleep before continuing the search
time.sleep(1)
# write entries to output
writer = BibTexWriter()
writer.indent = ' '
with open(outputfile, 'w') as output_file:
bibtexparser.dump(bib_database, output_file)
print('')
if sys.stdout.isatty():
print('Database updated. ' + style.OKGREEN + str(dblp_cnt) + style.ENDC + ' entries updated from DBLP, ' +
style.WARNING + str(local_cnt) + style.ENDC + ' entries kept as they were.')
else:
print('Database updated. ' + str(dblp_cnt) + ' entries updated from DBLP, ' +
str(local_cnt) + ' entries kept as they were.')
print('')
def _build_latex_array(self, aliases=None):
"""Returns an array of strings containing \\LaTeX for this circuit.
If aliases is not None, aliases contains a dict mapping
the current qubits in the circuit to new qubit names.
We will deduce the register names and sizes from aliases.
"""
# Rename qregs if necessary
if aliases:
qregdata = {}
for q in aliases.values():
if q[0] not in qregdata:
qregdata[q[0]] = q[1] + 1
elif qregdata[q[0]] < q[1] + 1:
qregdata[q[0]] = q[1] + 1
else:
qregdata = self.qregs
for column, layer in enumerate(self.ops, 1):
for op in layer:
if op.condition:
mask = self._get_mask(op.condition[0])
cl_reg = self.clbit_list[self._ffs(mask)]
if_reg = cl_reg[0]
pos_2 = self.img_regs[cl_reg]
if_value = format(op.condition[1],
'b').zfill(self.cregs[if_reg])[::-1]
if op.name not in [
'measure', 'barrier', 'snapshot', 'load', 'save',
'noise'
]:
nm = op.name
qarglist = op.qargs
if aliases is not None:
qarglist = map(lambda x: aliases[x], qarglist)
if len(qarglist) == 1:
pos_1 = self.img_regs[(qarglist[0][0], qarglist[0][1])]
if op.condition:
mask = self._get_mask(op.condition[0])
cl_reg = self.clbit_list[self._ffs(mask)]
if_reg = cl_reg[0]
pos_2 = self.img_regs[cl_reg]
if nm == "x":
self._latex[pos_1][column] = "\\gate{X}"
elif nm == "y":
self._latex[pos_1][column] = "\\gate{Y}"
elif nm == "z":
self._latex[pos_1][column] = "\\gate{Z}"
elif nm == "h":
self._latex[pos_1][column] = "\\gate{H}"
elif nm == "s":
self._latex[pos_1][column] = "\\gate{S}"
elif nm == "sdg":
self._latex[pos_1][column] = "\\gate{S^\\dag}"
elif nm == "t":
self._latex[pos_1][column] = "\\gate{T}"
elif nm == "tdg":
self._latex[pos_1][column] = "\\gate{T^\\dag}"
elif nm == "u0":
self._latex[pos_1][
column] = "\\gate{U_0(%s)}" % (
op.op.params[0])
elif nm == "u1":
self._latex[pos_1][
column] = "\\gate{U_1(%s)}" % (
op.op.params[0])
elif nm == "u2":
self._latex[pos_1][column] = \
"\\gate{U_2\\left(%s,%s\\right)}" % (
op.op.params[0], op.op.params[1])
elif nm == "u3":
self._latex[pos_1][column] = (
"\\gate{U_3(%s,%s,%s)}" %
(op.op.params[0], op.op.params[1],
op.op.params[2]))
elif nm == "rx":
self._latex[pos_1][
column] = "\\gate{R_x(%s)}" % (
op.op.params[0])
elif nm == "ry":
self._latex[pos_1][
column] = "\\gate{R_y(%s)}" % (
op.op.params[0])
elif nm == "rz":
self._latex[pos_1][
column] = "\\gate{R_z(%s)}" % (
op.op.params[0])
else:
self._latex[pos_1][column] = ("\\gate{%s}" %
utf8tolatex(nm))
gap = pos_2 - pos_1
for i in range(self.cregs[if_reg]):
if if_value[i] == '1':
self._latex[pos_2 + i][column] = \
"\\control \\cw \\cwx[-" + str(gap) + "]"
gap = 1
else:
self._latex[pos_2 + i][column] = \
"\\controlo \\cw \\cwx[-" + str(gap) + "]"
gap = 1
else:
if nm == "x":
self._latex[pos_1][column] = "\\gate{X}"
elif nm == "y":
self._latex[pos_1][column] = "\\gate{Y}"
elif nm == "z":
self._latex[pos_1][column] = "\\gate{Z}"
elif nm == "h":
self._latex[pos_1][column] = "\\gate{H}"
elif nm == "s":
self._latex[pos_1][column] = "\\gate{S}"
elif nm == "sdg":
self._latex[pos_1][column] = "\\gate{S^\\dag}"
elif nm == "t":
self._latex[pos_1][column] = "\\gate{T}"
elif nm == "tdg":
self._latex[pos_1][column] = "\\gate{T^\\dag}"
elif nm == "u0":
self._latex[pos_1][
column] = "\\gate{U_0(%s)}" % (
op.op.params[0])
elif nm == "u1":
self._latex[pos_1][
column] = "\\gate{U_1(%s)}" % (
op.op.params[0])
elif nm == "u2":
self._latex[pos_1][column] = \
"\\gate{U_2\\left(%s,%s\\right)}" % (
op.op.params[0], op.op.params[1])
elif nm == "u3":
self._latex[pos_1][column] = (
"\\gate{U_3(%s,%s,%s)}" %
(op.op.params[0], op.op.params[1],
op.op.params[2]))
elif nm == "rx":
self._latex[pos_1][
column] = "\\gate{R_x(%s)}" % (
op.op.params[0])
elif nm == "ry":
self._latex[pos_1][
column] = "\\gate{R_y(%s)}" % (
op.op.params[0])
elif nm == "rz":
self._latex[pos_1][
column] = "\\gate{R_z(%s)}" % (
op.op.params[0])
elif nm == "reset":
self._latex[pos_1][column] = (
"\\push{\\rule{.6em}{0em}\\ket{0}\\"
"rule{.2em}{0em}} \\qw")
else:
self._latex[pos_1][column] = ("\\gate{%s}" %
utf8tolatex(nm))
elif len(qarglist) == 2:
pos_1 = self.img_regs[(qarglist[0][0], qarglist[0][1])]
pos_2 = self.img_regs[(qarglist[1][0], qarglist[1][1])]
if op.condition:
pos_3 = self.img_regs[(if_reg, 0)]
temp = [pos_1, pos_2, pos_3]
temp.sort(key=int)
bottom = temp[1]
gap = pos_3 - bottom
for i in range(self.cregs[if_reg]):
if if_value[i] == '1':
self._latex[pos_3 + i][column] = \
"\\control \\cw \\cwx[-" + str(gap) + "]"
gap = 1
else:
self._latex[pos_3 + i][column] = \
"\\controlo \\cw \\cwx[-" + str(gap) + "]"
gap = 1
if nm == "cx":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\targ"
elif nm == "cz":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\control\\qw"
elif nm == "cy":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\gate{Y}"
elif nm == "ch":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\gate{H}"
elif nm == "swap":
self._latex[pos_1][column] = "\\qswap"
self._latex[pos_2][column] = \
"\\qswap \\qwx[" + str(pos_1 - pos_2) + "]"
elif nm == "crz":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = \
"\\gate{R_z(%s)}" % (op.op.params[0])
elif nm == "cu1":
self._latex[pos_1][
column -
1] = "\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column -
1] = "\\control\\qw"
self._latex[min(pos_1, pos_2)][column] = \
"\\dstick{%s}\\qw" % (op.op.params[0])
self._latex[max(pos_1, pos_2)][column] = "\\qw"
elif nm == "cu3":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = \
"\\gate{U_3(%s,%s,%s)}" % (op.op.params[0],
op.op.params[1],
op.op.params[2])
else:
temp = [pos_1, pos_2]
temp.sort(key=int)
if nm == "cx":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\targ"
elif nm == "cz":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\control\\qw"
elif nm == "cy":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\gate{Y}"
elif nm == "ch":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\gate{H}"
elif nm == "swap":
self._latex[pos_1][column] = "\\qswap"
self._latex[pos_2][column] = \
"\\qswap \\qwx[" + str(pos_1 - pos_2) + "]"
elif nm == "crz":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = \
"\\gate{R_z(%s)}" % (op.op.params[0])
elif nm == "cu1":
self._latex[pos_1][
column -
1] = "\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column -
1] = "\\control\\qw"
self._latex[min(pos_1, pos_2)][column] = \
"\\dstick{%s}\\qw" % (op.op.params[0])
self._latex[max(pos_1, pos_2)][column] = "\\qw"
elif nm == "cu3":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = (
"\\gate{U_3(%s,%s,%s)}" %
(op.op.params[0], op.op.params[1],
op.op.params[2]))
else:
start_pos = min([pos_1, pos_2])
stop_pos = max([pos_1, pos_2])
if stop_pos - start_pos >= 2:
delta = stop_pos - start_pos
self._latex[start_pos][column] = (
"\\multigate{%s}{%s}" %
(delta, utf8tolatex(nm)))
for i_pos in range(start_pos + 1,
stop_pos + 1):
self._latex[i_pos][column] = (
"\\ghost{%s}" % utf8tolatex(nm))
else:
self._latex[start_pos][column] = (
"\\multigate{1}{%s}" % utf8tolatex(nm))
self._latex[stop_pos][column] = (
"\\ghost{%s}" % utf8tolatex(nm))
elif len(qarglist) == 3:
pos_1 = self.img_regs[(qarglist[0][0], qarglist[0][1])]
pos_2 = self.img_regs[(qarglist[1][0], qarglist[1][1])]
pos_3 = self.img_regs[(qarglist[2][0], qarglist[2][1])]
if op.condition:
pos_4 = self.img_regs[(if_reg, 0)]
temp = [pos_1, pos_2, pos_3, pos_4]
temp.sort(key=int)
bottom = temp[2]
prev_column = [x[column - 1] for x in self._latex]
for item, prev_entry in enumerate(prev_column):
if 'barrier' in prev_entry:
span = re.search('barrier{(.*)}',
prev_entry)
if span and any(i in temp for i in range(
item, int(span.group(1)))):
self._latex[item][column - 1] = \
prev_entry.replace(
'\\barrier{',
'\\barrier[-0.65em]{')
gap = pos_4 - bottom
for i in range(self.cregs[if_reg]):
if if_value[i] == '1':
self._latex[pos_4 + i][column] = \
"\\control \\cw \\cwx[-" + str(gap) + "]"
gap = 1
else:
self._latex[pos_4 + i][column] = \
"\\controlo \\cw \\cwx[-" + str(gap) + "]"
gap = 1
if nm == "ccx":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\ctrl{" + str(
pos_3 - pos_2) + "}"
self._latex[pos_3][column] = "\\targ"
if nm == "cswap":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\qswap"
self._latex[pos_3][column] = \
"\\qswap \\qwx[" + str(pos_2 - pos_3) + "]"
else:
temp = [pos_1, pos_2, pos_3]
temp.sort(key=int)
prev_column = [x[column - 1] for x in self._latex]
for item, prev_entry in enumerate(prev_column):
if 'barrier' in prev_entry:
span = re.search('barrier{(.*)}',
prev_entry)
if span and any(i in temp for i in range(
item, int(span.group(1)))):
self._latex[item][column - 1] = \
prev_entry.replace(
'\\barrier{',
'\\barrier[-0.65em]{')
if nm == "ccx":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\ctrl{" + str(
pos_3 - pos_2) + "}"
self._latex[pos_3][column] = "\\targ"
elif nm == "cswap":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\qswap"
self._latex[pos_3][column] = \
"\\qswap \\qwx[" + str(pos_2 - pos_3) + "]"
else:
start_pos = min([pos_1, pos_2, pos_3])
stop_pos = max([pos_1, pos_2, pos_3])
if stop_pos - start_pos >= 3:
delta = stop_pos - start_pos
self._latex[start_pos][column] = (
"\\multigate{%s}{%s}" %
(delta, utf8tolatex(nm)))
for i_pos in range(start_pos + 1,
stop_pos + 1):
self._latex[i_pos][column] = (
"\\ghost{%s}" % utf8tolatex(nm))
else:
self._latex[pos_1][column] = (
"\\multigate{2}{%s}" % utf8tolatex(nm))
self._latex[pos_2][column] = (
"\\ghost{%s}" % utf8tolatex(nm))
self._latex[pos_3][column] = (
"\\ghost{%s}" % utf8tolatex(nm))
elif len(qarglist) > 3:
nbits = len(qarglist)
pos_array = [
self.img_regs[(qarglist[0][0], qarglist[0][1])]
]
for i in range(1, nbits):
pos_array.append(self.img_regs[(qarglist[i][0],
qarglist[i][1])])
pos_start = min(pos_array)
pos_stop = max(pos_array)
delta = pos_stop - pos_start
self._latex[pos_start][column] = (
"\\multigate{%s}{%s}" %
(nbits - 1, utf8tolatex(nm)))
for pos in range(pos_start + 1, pos_stop + 1):
self._latex[pos][column] = ("\\ghost{%s}" %
utf8tolatex(nm))
elif op.name == "measure":
if (len(op.cargs) != 1 or len(op.qargs) != 1
or op.op.params):
raise exceptions.VisualizationError(
"bad operation record")
if op.condition:
raise exceptions.VisualizationError(
"If controlled measures currently not supported.")
qname, qindex = op.qargs[0]
cname, cindex = op.cargs[0]
if aliases:
newq = aliases[(qname, qindex)]
qname = newq[0]
qindex = newq[1]
pos_1 = self.img_regs[(qname, qindex)]
pos_2 = self.img_regs[(cname, cindex)]
try:
self._latex[pos_1][column] = "\\meter"
prev_column = [x[column - 1] for x in self._latex]
for item, prev_entry in enumerate(prev_column):
if 'barrier' in prev_entry:
span = re.search('barrier{(.*)}', prev_entry)
if span and (item +
int(span.group(1))) - pos_1 >= 0:
self._latex[item][column - 1] = \
prev_entry.replace(
'\\barrier{',
'\\barrier[-1.15em]{')
self._latex[pos_2][column] = \
"\\cw \\cwx[-" + str(pos_2 - pos_1) + "]"
except Exception as e:
raise exceptions.VisualizationError(
'Error during Latex building: %s' % str(e))
elif op.name in [
'barrier', 'snapshot', 'load', 'save', 'noise'
]:
if self.plot_barriers:
qarglist = op.qargs
indexes = [self._get_qubit_index(x) for x in qarglist]
start_bit = self.qubit_list[min(indexes)]
if aliases is not None:
qarglist = map(lambda x: aliases[x], qarglist)
start = self.img_regs[start_bit]
span = len(op.qargs) - 1
self._latex[start][column] = "\\qw \\barrier{" + str(
span) + "}"
else:
raise exceptions.VisualizationError("bad node data")
def parseMeta(metadict,basedir,folder,isfile,iszotero,iskeyword,verbose=True):
'''Parse document meta-data
metadict
'''
def getField(doc,field,default=''):
return doc[field] or default
page_re=re.compile('(.*?)-(.*)', re.UNICODE)
def _subDash(match):
return '%s--%s' %(match.group(1),match.group(2))
#--------------------Get header--------------------
doctype=getField(metadict,'type','article')
if doctype==u'JournalArticle':
doctype='article' #Necessary?
citekey=getField(metadict,'citationkey','citationkey')
#-------------------Get authors-------------------
first=metadict['firstnames']
last=metadict['lastname']
if first is None or last is None:
authors=''
if type(first) is not list and type(last) is not list:
authors='%s, %s' %(last, first)
else:
authors=['%s, %s' %(ii[0],ii[1]) for ii in zip(last,first)]
authors=' and '.join(authors)
authors=latexencode.utf8tolatex(authors)
string='@%s{%s,\n' %(doctype,citekey)
entries=['author = {%s}' %authors,]
#--------------Populate other fields--------------
gotkeywords=False
for kk,vv in metadict.items():
if vv is None:
continue
if kk in ['type','firstnames','lastname','docid']:
continue
if kk in ['year','month','day']:
# Convert float to int to str
try:
vv=str(int(vv))
except:
# vv is nan
continue
if kk=='publication' and doctype=='article':
kk='journal'
if kk=='pages':
vv=page_re.sub(_subDash,vv)
if kk=='path':
if not isfile:
continue
if not isinstance(vv,list) and not isinstance(vv,tuple):
vv=[vv,]
vv=[parseFilePath(ii,basedir,folder,iszotero) for\
ii in vv]
# proper way of joining multiple paths?
#vv='}, {'.join(vv)
vv='; '.join(vv)
vv=u'%s' %vv
if vv=='':
continue
else:
kk='file'
#--------------Parse unicode to latex--------------
if type(vv) is list:
fieldvv=[latexencode.utf8tolatex(ii) for ii in vv]
else:
# Leave file path alone
if kk!='file':
fieldvv=latexencode.utf8tolatex(vv)
else:
fieldvv=vv
#----------Add tags to keywords if iszotero----------
if iszotero and (kk=='tags' or kk=='keywords') and not gotkeywords:
if iskeyword:
keywords=getField(metadict,'keywords',[])
else:
keywords=[]
if not isinstance(keywords, list):
keywords=[keywords,]
tags=getField(metadict,'tags',[])
if not isinstance(tags, list):
tags=[tags,]
keywords.extend(tags)
keywords=list(set(keywords))
fieldvv=[latexencode.utf8tolatex(ii) for ii in keywords]
kk='keywords'
gotkeywords=True
#----------------Parse annotations----------------
#if kk=='annote':
if kk in ['notes', 'highlights']:
#if type(fieldvv) is not list:
#fieldvv=[fieldvv,]
if len(fieldvv)==0:
continue
# For import to zotero, separate annotes
if iszotero:
for ii in fieldvv:
entrykk='%s = { %s }' %('annote',ii)
entries.append(entrykk)
else:
fieldvv=['{ %s }' %ii for ii in fieldvv]
fieldvv=u', '.join(fieldvv)
#entrykk='%s = {%s}' %(kk, fieldvv)
entrykk='%s = {%s}' %('annote', fieldvv)
entries.append(entrykk)
#--------------------All others--------------------
else:
if type(fieldvv) is list:
fieldvv=u', '.join(fieldvv)
entrykk='%s = {%s}' %(kk, fieldvv)
entries.append(entrykk)
#entries=',\n'.join(entries)
entries=',\n'.join([u'\t%s' %eii for eii in entries])
string=string+entries+'\n}\n\n'
string=string.encode('ascii','replace')
return string
def _build_latex_array(self, aliases=None):
"""Returns an array of strings containing \\LaTeX for this circuit.
If aliases is not None, aliases contains a dict mapping
the current qubits in the circuit to new qubit names.
We will deduce the register names and sizes from aliases.
"""
# Rename qregs if necessary
if aliases:
qregdata = {}
for q in aliases.values():
if q[0] not in qregdata:
qregdata[q[0]] = q[1] + 1
elif qregdata[q[0]] < q[1] + 1:
qregdata[q[0]] = q[1] + 1
else:
qregdata = self.qregs
column = 1
for layer in self.ops:
num_cols_used = 1
for op in layer:
if op.condition:
mask = self._get_mask(op.condition[0])
cl_reg = self.clbit_list[self._ffs(mask)]
if_reg = cl_reg.register
pos_2 = self.img_regs[cl_reg]
if_value = format(op.condition[1],
'b').zfill(self.cregs[if_reg])[::-1]
if op.name not in [
'measure', 'barrier', 'snapshot', 'load', 'save',
'noise'
]:
nm = utf8tolatex(op.name).replace(" ", "\\,")
qarglist = op.qargs
if aliases is not None:
qarglist = map(lambda x: aliases[x], qarglist)
if len(qarglist) == 1:
pos_1 = self.img_regs[qarglist[0]]
if op.condition:
mask = self._get_mask(op.condition[0])
cl_reg = self.clbit_list[self._ffs(mask)]
if_reg = cl_reg.register
pos_2 = self.img_regs[cl_reg]
if nm == "x":
self._latex[pos_1][column] = "\\gate{X}"
elif nm == "y":
self._latex[pos_1][column] = "\\gate{Y}"
elif nm == "z":
self._latex[pos_1][column] = "\\gate{Z}"
elif nm == "h":
self._latex[pos_1][column] = "\\gate{H}"
elif nm == "s":
self._latex[pos_1][column] = "\\gate{S}"
elif nm == "sdg":
self._latex[pos_1][column] = "\\gate{S^\\dag}"
elif nm == "t":
self._latex[pos_1][column] = "\\gate{T}"
elif nm == "tdg":
self._latex[pos_1][column] = "\\gate{T^\\dag}"
elif nm == "u0":
self._latex[pos_1][
column] = "\\gate{U_0(%s)}" % (pi_check(
op.op.params[0], output='latex'))
elif nm == "u1":
self._latex[pos_1][
column] = "\\gate{U_1(%s)}" % (pi_check(
op.op.params[0], output='latex'))
elif nm == "u2":
self._latex[pos_1][column] = \
"\\gate{U_2\\left(%s,%s\\right)}" % (
pi_check(op.op.params[0], output='latex'),
pi_check(op.op.params[1], output='latex'))
elif nm == "u3":
self._latex[pos_1][column] = (
"\\gate{U_3(%s,%s,%s)}" %
(pi_check(op.op.params[0], output='latex'),
pi_check(op.op.params[1], output='latex'),
pi_check(op.op.params[2],
output='latex')))
elif nm == "rx":
self._latex[pos_1][
column] = "\\gate{R_x(%s)}" % (pi_check(
op.op.params[0], output='latex'))
elif nm == "ry":
self._latex[pos_1][
column] = "\\gate{R_y(%s)}" % (pi_check(
op.op.params[0], output='latex'))
elif nm == "rz":
self._latex[pos_1][
column] = "\\gate{R_z(%s)}" % (pi_check(
op.op.params[0], output='latex'))
else:
self._latex[pos_1][column] = ("\\gate{%s}" %
nm)
gap = pos_2 - pos_1
for i in range(self.cregs[if_reg]):
if if_value[i] == '1':
self._latex[pos_2 + i][column] = \
"\\control \\cw \\cwx[-" + str(gap) + "]"
gap = 1
else:
self._latex[pos_2 + i][column] = \
"\\controlo \\cw \\cwx[-" + str(gap) + "]"
gap = 1
else:
if nm == "x":
self._latex[pos_1][column] = "\\gate{X}"
elif nm == "y":
self._latex[pos_1][column] = "\\gate{Y}"
elif nm == "z":
self._latex[pos_1][column] = "\\gate{Z}"
elif nm == "h":
self._latex[pos_1][column] = "\\gate{H}"
elif nm == "s":
self._latex[pos_1][column] = "\\gate{S}"
elif nm == "sdg":
self._latex[pos_1][column] = "\\gate{S^\\dag}"
elif nm == "t":
self._latex[pos_1][column] = "\\gate{T}"
elif nm == "tdg":
self._latex[pos_1][column] = "\\gate{T^\\dag}"
elif nm == "u0":
self._latex[pos_1][
column] = "\\gate{U_0(%s)}" % (pi_check(
op.op.params[0], output='latex'))
elif nm == "u1":
self._latex[pos_1][
column] = "\\gate{U_1(%s)}" % (pi_check(
op.op.params[0], output='latex'))
elif nm == "u2":
self._latex[pos_1][column] = \
"\\gate{U_2\\left(%s,%s\\right)}" % (
pi_check(op.op.params[0], output='latex'),
pi_check(op.op.params[1], output='latex'))
elif nm == "u3":
self._latex[pos_1][column] = (
"\\gate{U_3(%s,%s,%s)}" %
(pi_check(op.op.params[0], output='latex'),
pi_check(op.op.params[1], output='latex'),
pi_check(op.op.params[2],
output='latex')))
elif nm == "rx":
self._latex[pos_1][
column] = "\\gate{R_x(%s)}" % (pi_check(
op.op.params[0], output='latex'))
elif nm == "ry":
self._latex[pos_1][
column] = "\\gate{R_y(%s)}" % (pi_check(
op.op.params[0], output='latex'))
elif nm == "rz":
self._latex[pos_1][
column] = "\\gate{R_z(%s)}" % (pi_check(
op.op.params[0], output='latex'))
elif nm == "reset":
self._latex[pos_1][column] = (
"\\push{\\rule{.6em}{0em}\\ket{0}\\"
"rule{.2em}{0em}} \\qw")
else:
self._latex[pos_1][column] = ("\\gate{%s}" %
nm)
elif len(qarglist) == 2:
pos_1 = self.img_regs[qarglist[0]]
pos_2 = self.img_regs[qarglist[1]]
if op.condition:
pos_3 = self.img_regs[(if_reg, 0)]
temp = [pos_1, pos_2, pos_3]
temp.sort(key=int)
bottom = temp[1]
gap = pos_3 - bottom
for i in range(self.cregs[if_reg]):
if if_value[i] == '1':
self._latex[pos_3 + i][column] = \
"\\control \\cw \\cwx[-" + str(gap) + "]"
gap = 1
else:
self._latex[pos_3 + i][column] = \
"\\controlo \\cw \\cwx[-" + str(gap) + "]"
gap = 1
if nm == "cx":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\targ"
elif nm == "cz":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\control\\qw"
elif nm == "cy":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\gate{Y}"
elif nm == "ch":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\gate{H}"
elif nm == "swap":
self._latex[pos_1][column] = "\\qswap"
self._latex[pos_2][column] = \
"\\qswap \\qwx[" + str(pos_1 - pos_2) + "]"
elif nm == "crz":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = \
"\\gate{R_z(%s)}" % (pi_check(op.op.params[0], output='latex'))
elif nm == "cu1":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\control \\qw"
self._latex[min(pos_1, pos_2)][column + 1] = \
"\\dstick{%s}\\qw" % (pi_check(op.op.params[0], output='latex'))
self._latex[max(pos_1,
pos_2)][column + 1] = "\\qw"
# this is because this gate takes up 2 columns,
# and we have just written to the next column
num_cols_used = 2
elif nm == "cu3":
self._latex[pos_1][column] = \
"\\ctrl{" + str(pos_2 - pos_1) + "}"
self._latex[pos_2][column] = \
"\\gate{U_3(%s,%s,%s)}" % \
(pi_check(op.op.params[0], output='latex'),
pi_check(op.op.params[1], output='latex'),
pi_check(op.op.params[2], output='latex'))
elif nm == "rzz":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\control \\qw"
# Based on the \cds command of the qcircuit package
self._latex[min(pos_1, pos_2)][column + 1] = \
"*+<0em,0em>{\\hphantom{zz()}} \\POS [0,0].[%d,0]=" \
"\"e\",!C *{zz(%s)};\"e\"+ R \\qw" %\
(max(pos_1, pos_2), pi_check(op.op.params[0], output='latex'))
self._latex[max(pos_1,
pos_2)][column + 1] = "\\qw"
num_cols_used = 2
else:
temp = [pos_1, pos_2]
temp.sort(key=int)
if nm == "cx":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\targ"
elif nm == "cz":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\control\\qw"
elif nm == "cy":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\gate{Y}"
elif nm == "ch":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\gate{H}"
elif nm == "swap":
self._latex[pos_1][column] = "\\qswap"
self._latex[pos_2][column] = \
"\\qswap \\qwx[" + str(pos_1 - pos_2) + "]"
elif nm == "crz":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = \
"\\gate{R_z(%s)}" % (pi_check(op.op.params[0], output='latex'))
elif nm == "cu1":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\control \\qw"
self._latex[min(pos_1, pos_2)][column + 1] = \
"\\dstick{%s}\\qw" % (pi_check(op.op.params[0], output='latex'))
self._latex[max(pos_1,
pos_2)][column + 1] = "\\qw"
num_cols_used = 2
elif nm == "cu3":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = \
("\\gate{U_3(%s,%s,%s)}" %
(pi_check(op.op.params[0], output='latex'),
pi_check(op.op.params[1], output='latex'),
pi_check(op.op.params[2], output='latex')))
elif nm == "rzz":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\control \\qw"
# Based on the \cds command of the qcircuit package
self._latex[min(pos_1, pos_2)][column + 1] = \
"*+<0em,0em>{\\hphantom{zz()}} \\POS [0,0].[%d,0]=" \
"\"e\",!C *{zz(%s)};\"e\"+ R \\qw" %\
(max(pos_1, pos_2), pi_check(op.op.params[0], output='latex'))
self._latex[max(pos_1,
pos_2)][column + 1] = "\\qw"
num_cols_used = 2
else:
start_pos = min([pos_1, pos_2])
stop_pos = max([pos_1, pos_2])
if stop_pos - start_pos >= 2:
delta = stop_pos - start_pos
self._latex[start_pos][column] = (
"\\multigate{%s}{%s}" % (delta, nm))
for i_pos in range(start_pos + 1,
stop_pos + 1):
self._latex[i_pos][column] = (
"\\ghost{%s}" % nm)
else:
self._latex[start_pos][column] = (
"\\multigate{1}{%s}" % nm)
self._latex[stop_pos][column] = (
"\\ghost{%s}" % nm)
elif len(qarglist) == 3:
pos_1 = self.img_regs[qarglist[0]]
pos_2 = self.img_regs[qarglist[1]]
pos_3 = self.img_regs[qarglist[2]]
if op.condition:
pos_4 = self.img_regs[(if_reg, 0)]
temp = [pos_1, pos_2, pos_3, pos_4]
temp.sort(key=int)
bottom = temp[2]
gap = pos_4 - bottom
for i in range(self.cregs[if_reg]):
if if_value[i] == '1':
self._latex[pos_4 + i][column] = \
"\\control \\cw \\cwx[-" + str(gap) + "]"
gap = 1
else:
self._latex[pos_4 + i][column] = \
"\\controlo \\cw \\cwx[-" + str(gap) + "]"
gap = 1
if nm == "ccx":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\ctrl{" + str(
pos_3 - pos_2) + "}"
self._latex[pos_3][column] = "\\targ"
if nm == "cswap":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\qswap"
self._latex[pos_3][column] = \
"\\qswap \\qwx[" + str(pos_2 - pos_3) + "]"
else:
if nm == "ccx":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\ctrl{" + str(
pos_3 - pos_2) + "}"
self._latex[pos_3][column] = "\\targ"
elif nm == "cswap":
self._latex[pos_1][column] = "\\ctrl{" + str(
pos_2 - pos_1) + "}"
self._latex[pos_2][column] = "\\qswap"
self._latex[pos_3][column] = \
"\\qswap \\qwx[" + str(pos_2 - pos_3) + "]"
else:
start_pos = min([pos_1, pos_2, pos_3])
stop_pos = max([pos_1, pos_2, pos_3])
if stop_pos - start_pos >= 3:
delta = stop_pos - start_pos
self._latex[start_pos][column] = (
"\\multigate{%s}{%s}" % (delta, nm))
for i_pos in range(start_pos + 1,
stop_pos + 1):
self._latex[i_pos][column] = (
"\\ghost{%s}" % nm)
else:
self._latex[pos_1][column] = (
"\\multigate{2}{%s}" % nm)
self._latex[pos_2][column] = (
"\\ghost{%s}" % nm)
self._latex[pos_3][column] = (
"\\ghost{%s}" % nm)
elif len(qarglist) > 3:
nbits = len(qarglist)
pos_array = [
self.img_regs[(qarglist[0].register,
qarglist[0].index)]
]
for i in range(1, nbits):
pos_array.append(
self.img_regs[(qarglist[i].register,
qarglist[i].index)])
pos_start = min(pos_array)
pos_stop = max(pos_array)
self._latex[pos_start][column] = (
"\\multigate{%s}{%s}" % (nbits - 1, nm))
for pos in range(pos_start + 1, pos_stop + 1):
self._latex[pos][column] = ("\\ghost{%s}" % nm)
elif op.name == "measure":
if (len(op.cargs) != 1 or len(op.qargs) != 1
or op.op.params):
raise exceptions.VisualizationError(
"bad operation record")
if op.condition:
raise exceptions.VisualizationError(
"If controlled measures currently not supported.")
if aliases:
newq = aliases[(qname, qindex)]
qname = newq[0]
qindex = newq[1]
pos_1 = self.img_regs[op.qargs[0]]
pos_2 = self.img_regs[op.cargs[0]]
try:
self._latex[pos_1][column] = "\\meter"
self._latex[pos_2][column] = \
"\\cw \\cwx[-" + str(pos_2 - pos_1) + "]"
except Exception as e:
raise exceptions.VisualizationError(
'Error during Latex building: %s' % str(e))
elif op.name in [
'barrier', 'snapshot', 'load', 'save', 'noise'
]:
if self.plot_barriers:
qarglist = op.qargs
indexes = [self._get_qubit_index(x) for x in qarglist]
indexes.sort()
if aliases is not None:
qarglist = map(lambda x: aliases[x], qarglist)
first = last = indexes[0]
for index in indexes[1:]:
if index - 1 == last:
last = index
else:
pos = self.img_regs[self.qubit_list[first]]
self._latex[pos][
column -
1] += " \\barrier[0em]{" + str(last -
first) + "}"
self._latex[pos][column] = "\\qw"
first = last = index
pos = self.img_regs[self.qubit_list[first]]
self._latex[pos][
column -
1] += " \\barrier[0em]{" + str(last - first) + "}"
self._latex[pos][column] = "\\qw"
else:
raise exceptions.VisualizationError("bad node data")
# increase the number of columns by the number of columns this layer used
column += num_cols_used
def tex_escape(text):
"""
:param text: a plain text message
:return: the message escaped to appear correctly in LaTeX
"""
return utf8tolatex(text)
#!/usr/bin/env python3
from pylatexenc.latexencode import utf8tolatex
with open('../AUTHORS', 'r') as authors_file:
authors = list([utf8tolatex(x.rstrip()) for x in authors_file])
with open('../Qiskit.bib', 'w') as fd:
fd.write("@misc{ Qiskit,\n")
fd.write(' author = {%s},\n' % ' and '.join(authors))
fd.write(' title = {Qiskit: An Open-source Framework for Quantum Computing},\n')
fd.write(' year = {2019},\n}')
