r"""

# for a non-math symbol, simply return its unicode index

if not math:

return ord(symbol)

# From UTF #25: U+2212 minus sign is the preferred

# representation of the unary and binary minus sign rather than

# the ASCII-derived U+002D hyphen-minus, because minus sign is

# unambiguous and because it is rendered with a more desirable

# length, usually longer than a hyphen.

if symbol == '-':

return 0x2212

try: # This will succeed if symbol is a single unicode char

return ord(symbol)

except TypeError:

pass

try: # Is symbol a TeX symbol (i.e. \alpha)

return tex2uni[symbol.strip("\\")]

except KeyError as err:

raise ValueError(

"'{}' is not a valid Unicode character or TeX/Type1 symbol"

"""

def __init__(self, default_font_prop, mathtext_backend):

"""

self.default_font_prop = default_font_prop

self.mathtext_backend = mathtext_backend

self.used_characters = {}

@_api.deprecated("3.4")

def destroy(self):

"""

self.used_characters = None

def get_kern(self, font1, fontclass1, sym1, fontsize1,

font2, fontclass2, sym2, fontsize2, dpi):

"""

return 0.

def get_metrics(self, font, font_class, sym, fontsize, dpi, math=True):

r"""

info = self._get_info(font, font_class, sym, fontsize, dpi, math)

return info.metrics

def set_canvas_size(self, w, h, d):

"""

self.width, self.height, self.depth = np.ceil([w, h, d])

self.mathtext_backend.set_canvas_size(

self.width, self.height, self.depth)

@_api.rename_parameter("3.4", "facename", "font")

def render_glyph(self, ox, oy, font, font_class, sym, fontsize, dpi):

"""

info = self._get_info(font, font_class, sym, fontsize, dpi)

self.used_characters.setdefault(info.font.fname, set()).add(info.num)

self.mathtext_backend.render_glyph(ox, oy, info)

def render_rect_filled(self, x1, y1, x2, y2):

"""

self.mathtext_backend.render_rect_filled(x1, y1, x2, y2)

def get_xheight(self, font, fontsize, dpi):

"""

raise NotImplementedError()

def get_underline_thickness(self, font, fontsize, dpi):

"""

raise NotImplementedError()

def get_used_characters(self):

"""

return self.used_characters

def get_results(self, box):

"""

result = self.mathtext_backend.get_results(

box, self.get_used_characters())

if self.destroy != TruetypeFonts.destroy.__get__(self):

destroy = _api.deprecate_method_override(

__class__.destroy, self, since="3.4")

if destroy:

destroy()

return result

def get_sized_alternatives_for_symbol(self, fontname, sym):

"""

"""

def __init__(self, default_font_prop, mathtext_backend):

super().__init__(default_font_prop, mathtext_backend)

self.glyphd = {}

self._fonts = {}

filename = findfont(default_font_prop)

default_font = get_font(filename)

self._fonts['default'] = default_font

self._fonts['regular'] = default_font

@_api.deprecated("3.4")

def destroy(self):

self.glyphd = None

super().destroy()

def _get_font(self, font):

if font in self.fontmap:

basename = self.fontmap[font]

else:

basename = font

cached_font = self._fonts.get(basename)

if cached_font is None and os.path.exists(basename):

cached_font = get_font(basename)

self._fonts[basename] = cached_font

self._fonts[cached_font.postscript_name] = cached_font

self._fonts[cached_font.postscript_name.lower()] = cached_font

return cached_font

def _get_offset(self, font, glyph, fontsize, dpi):

if font.postscript_name == 'Cmex10':

return (glyph.height / 64 / 2) + (fontsize/3 * dpi/72)

return 0.

def _get_info(self, fontname, font_class, sym, fontsize, dpi, math=True):

key = fontname, font_class, sym, fontsize, dpi

bunch = self.glyphd.get(key)

if bunch is not None:

return bunch

font, num, glyph_name, fontsize, slanted = \

self._get_glyph(fontname, font_class, sym, fontsize, math)

font.set_size(fontsize, dpi)

glyph = font.load_char(

num,

flags=self.mathtext_backend.get_hinting_type())

xmin, ymin, xmax, ymax = [val/64.0 for val in glyph.bbox]

offset = self._get_offset(font, glyph, fontsize, dpi)

metrics = types.SimpleNamespace(

advance = glyph.linearHoriAdvance/65536.0,

height = glyph.height/64.0,

width = glyph.width/64.0,

xmin = xmin,

xmax = xmax,

ymin = ymin+offset,

ymax = ymax+offset,

# iceberg is the equivalent of TeX's "height"

iceberg = glyph.horiBearingY/64.0 + offset,

slanted = slanted

)

result = self.glyphd[key] = types.SimpleNamespace(

font = font,

fontsize = fontsize,

postscript_name = font.postscript_name,

metrics = metrics,

glyph_name = glyph_name,

symbol_name = glyph_name, # Backcompat alias.

num = num,

glyph = glyph,

offset = offset

)

return result

def get_xheight(self, fontname, fontsize, dpi):

font = self._get_font(fontname)

font.set_size(fontsize, dpi)

pclt = font.get_sfnt_table('pclt')

if pclt is None:

# Some fonts don't store the xHeight, so we do a poor man's xHeight

metrics = self.get_metrics(

fontname, mpl.rcParams['mathtext.default'], 'x', fontsize, dpi)

return metrics.iceberg

xHeight = (pclt['xHeight'] / 64.0) * (fontsize / 12.0) * (dpi / 100.0)

return xHeight

def get_underline_thickness(self, font, fontsize, dpi):

# This function used to grab underline thickness from the font

# metrics, but that information is just too un-reliable, so it

# is now hardcoded.

return ((0.75 / 12.0) * fontsize * dpi) / 72.0

def get_kern(self, font1, fontclass1, sym1, fontsize1,

font2, fontclass2, sym2, fontsize2, dpi):

if font1 == font2 and fontsize1 == fontsize2:

info1 = self._get_info(font1, fontclass1, sym1, fontsize1, dpi)

info2 = self._get_info(font2, fontclass2, sym2, fontsize2, dpi)

font = info1.font

return font.get_kerning(info1.num, info2.num, KERNING_DEFAULT) / 64

return super().get_kern(font1, fontclass1, sym1, fontsize1,

"""

_fontmap = {

'cal': 'cmsy10',

'rm': 'cmr10',

'tt': 'cmtt10',

'it': 'cmmi10',

'bf': 'cmb10',

'sf': 'cmss10',

'ex': 'cmex10',

}

def __init__(self, *args, **kwargs):

self._stix_fallback = StixFonts(*args, **kwargs)

super().__init__(*args, **kwargs)

self.fontmap = {}

for key, val in self._fontmap.items():

fullpath = findfont(val)

self.fontmap[key] = fullpath

self.fontmap[val] = fullpath

_slanted_symbols = set(r"\int \oint".split())

def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):

glyph_name = None

font = None

if fontname in self.fontmap and sym in latex_to_bakoma:

basename, num = latex_to_bakoma[sym]

slanted = (basename == "cmmi10") or sym in self._slanted_symbols

font = self._get_font(basename)

elif len(sym) == 1:

slanted = (fontname == "it")

font = self._get_font(fontname)

if font is not None:

num = ord(sym)

if font is not None:

gid = font.get_char_index(num)

if gid != 0:

glyph_name = font.get_glyph_name(gid)

if glyph_name is None:

return self._stix_fallback._get_glyph(

fontname, font_class, sym, fontsize, math)

return font, num, glyph_name, fontsize, slanted

# The Bakoma fonts contain many pre-sized alternatives for the

# delimiters. The AutoSizedChar class will use these alternatives

# and select the best (closest sized) glyph.

_size_alternatives = {

'(': [('rm', '('), ('ex', '\xa1'), ('ex', '\xb3'),

('ex', '\xb5'), ('ex', '\xc3')],

')': [('rm', ')'), ('ex', '\xa2'), ('ex', '\xb4'),

('ex', '\xb6'), ('ex', '\x21')],

'{': [('cal', '{'), ('ex', '\xa9'), ('ex', '\x6e'),

('ex', '\xbd'), ('ex', '\x28')],

'}': [('cal', '}'), ('ex', '\xaa'), ('ex', '\x6f'),

('ex', '\xbe'), ('ex', '\x29')],

# The fourth size of '[' is mysteriously missing from the BaKoMa

# font, so I've omitted it for both '[' and ']'

'[': [('rm', '['), ('ex', '\xa3'), ('ex', '\x68'),

('ex', '\x22')],

']': [('rm', ']'), ('ex', '\xa4'), ('ex', '\x69'),

('ex', '\x23')],

r'\lfloor': [('ex', '\xa5'), ('ex', '\x6a'),

('ex', '\xb9'), ('ex', '\x24')],

r'\rfloor': [('ex', '\xa6'), ('ex', '\x6b'),

('ex', '\xba'), ('ex', '\x25')],

r'\lceil': [('ex', '\xa7'), ('ex', '\x6c'),

('ex', '\xbb'), ('ex', '\x26')],

r'\rceil': [('ex', '\xa8'), ('ex', '\x6d'),

('ex', '\xbc'), ('ex', '\x27')],

r'\langle': [('ex', '\xad'), ('ex', '\x44'),

('ex', '\xbf'), ('ex', '\x2a')],

r'\rangle': [('ex', '\xae'), ('ex', '\x45'),

('ex', '\xc0'), ('ex', '\x2b')],

r'\__sqrt__': [('ex', '\x70'), ('ex', '\x71'),

('ex', '\x72'), ('ex', '\x73')],

r'\backslash': [('ex', '\xb2'), ('ex', '\x2f'),

('ex', '\xc2'), ('ex', '\x2d')],

r'/': [('rm', '/'), ('ex', '\xb1'), ('ex', '\x2e'),

('ex', '\xcb'), ('ex', '\x2c')],

r'\widehat': [('rm', '\x5e'), ('ex', '\x62'), ('ex', '\x63'),

('ex', '\x64')],

r'\widetilde': [('rm', '\x7e'), ('ex', '\x65'), ('ex', '\x66'),

('ex', '\x67')],

r'<': [('cal', 'h'), ('ex', 'D')],

r'>': [('cal', 'i'), ('ex', 'E')]

}

for alias, target in [(r'\leftparen', '('),

(r'\rightparent', ')'),

(r'\leftbrace', '{'),

(r'\rightbrace', '}'),

(r'\leftbracket', '['),

(r'\rightbracket', ']'),

(r'\{', '{'),

(r'\}', '}'),

(r'\[', '['),

(r'\]', ']')]:

_size_alternatives[alias] = _size_alternatives[target]

def get_sized_alternatives_for_symbol(self, fontname, sym):

"""

use_cmex = True # Unused; delete once mathtext becomes private.

def __init__(self, *args, **kwargs):

# This must come first so the backend's owner is set correctly

fallback_rc = mpl.rcParams['mathtext.fallback']

font_cls = {'stix': StixFonts,

'stixsans': StixSansFonts,

'cm': BakomaFonts

}.get(fallback_rc)

self.cm_fallback = font_cls(*args, **kwargs) if font_cls else None

super().__init__(*args, **kwargs)

self.fontmap = {}

for texfont in "cal rm tt it bf sf".split():

prop = mpl.rcParams['mathtext.' + texfont]

font = findfont(prop)

self.fontmap[texfont] = font

prop = FontProperties('cmex10')

font = findfont(prop)

self.fontmap['ex'] = font

# include STIX sized alternatives for glyphs if fallback is STIX

if isinstance(self.cm_fallback, StixFonts):

stixsizedaltfonts = {

0: 'STIXGeneral',

1: 'STIXSizeOneSym',

2: 'STIXSizeTwoSym',

3: 'STIXSizeThreeSym',

4: 'STIXSizeFourSym',

5: 'STIXSizeFiveSym'}

for size, name in stixsizedaltfonts.items():

fullpath = findfont(name)

self.fontmap[size] = fullpath

self.fontmap[name] = fullpath

_slanted_symbols = set(r"\int \oint".split())

def _map_virtual_font(self, fontname, font_class, uniindex):

return fontname, uniindex

def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):

try:

uniindex = get_unicode_index(sym, math)

found_symbol = True

except ValueError:

uniindex = ord('?')

found_symbol = False

_log.warning("No TeX to unicode mapping for {!a}.".format(sym))

fontname, uniindex = self._map_virtual_font(

fontname, font_class, uniindex)

new_fontname = fontname

# Only characters in the "Letter" class should be italicized in 'it'

# mode. Greek capital letters should be Roman.

if found_symbol:

if fontname == 'it' and uniindex < 0x10000:

char = chr(uniindex)

if (unicodedata.category(char)[0] != "L"

or unicodedata.name(char).startswith("GREEK CAPITAL")):

new_fontname = 'rm'

slanted = (new_fontname == 'it') or sym in self._slanted_symbols

found_symbol = False

font = self._get_font(new_fontname)

if font is not None:

if font.family_name == "cmr10" and uniindex == 0x2212:

# minus sign exists in cmsy10 (not cmr10)

font = get_font(

cbook._get_data_path("fonts/ttf/cmsy10.ttf"))

uniindex = 0xa1

glyphindex = font.get_char_index(uniindex)

if glyphindex != 0:

found_symbol = True

if not found_symbol:

if self.cm_fallback:

if (fontname in ('it', 'regular')

and isinstance(self.cm_fallback, StixFonts)):

fontname = 'rm'

g = self.cm_fallback._get_glyph(fontname, font_class,

sym, fontsize)

fname = g[0].family_name

if fname in list(BakomaFonts._fontmap.values()):

fname = "Computer Modern"

_log.info("Substituting symbol %s from %s", sym, fname)

return g

else:

if (fontname in ('it', 'regular')

and isinstance(self, StixFonts)):

return self._get_glyph('rm', font_class, sym, fontsize)

_log.warning("Font {!r} does not have a glyph for {!a} "

"[U+{:x}], substituting with a dummy "

"symbol.".format(new_fontname, sym, uniindex))

fontname = 'rm'

font = self._get_font(fontname)

uniindex = 0xA4 # currency char, for lack of anything better

glyphindex = font.get_char_index(uniindex)

slanted = False

glyph_name = font.get_glyph_name(glyphindex)

return font, uniindex, glyph_name, fontsize, slanted

def get_sized_alternatives_for_symbol(self, fontname, sym):

if self.cm_fallback:

return self.cm_fallback.get_sized_alternatives_for_symbol(

fontname, sym)

use_cmex = False # Unused; delete once mathtext becomes private.

def __init__(self, *args, **kwargs):

# This must come first so the backend's owner is set correctly

if isinstance(self, DejaVuSerifFonts):

self.cm_fallback = StixFonts(*args, **kwargs)

else:

self.cm_fallback = StixSansFonts(*args, **kwargs)

self.bakoma = BakomaFonts(*args, **kwargs)

TruetypeFonts.__init__(self, *args, **kwargs)

self.fontmap = {}

# Include Stix sized alternatives for glyphs

self._fontmap.update({

1: 'STIXSizeOneSym',

2: 'STIXSizeTwoSym',

3: 'STIXSizeThreeSym',

4: 'STIXSizeFourSym',

5: 'STIXSizeFiveSym',

})

for key, name in self._fontmap.items():

fullpath = findfont(name)

self.fontmap[key] = fullpath

self.fontmap[name] = fullpath

def _get_glyph(self, fontname, font_class, sym, fontsize, math=True):

# Override prime symbol to use Bakoma.

if sym == r'\prime':

return self.bakoma._get_glyph(

fontname, font_class, sym, fontsize, math)

else:

# check whether the glyph is available in the display font

uniindex = get_unicode_index(sym)

font = self._get_font('ex')

if font is not None:

glyphindex = font.get_char_index(uniindex)

if glyphindex != 0:

return super()._get_glyph(

'ex', font_class, sym, fontsize, math)

# otherwise return regular glyph

return super()._get_glyph(

"""

_fontmap = {

'rm': 'DejaVu Serif',

'it': 'DejaVu Serif:italic',

'bf': 'DejaVu Serif:weight=bold',

'sf': 'DejaVu Sans',

'tt': 'DejaVu Sans Mono',

'ex': 'DejaVu Serif Display',

0: 'DejaVu Serif',

"""

_fontmap = {

'rm': 'DejaVu Sans',

'it': 'DejaVu Sans:italic',

'bf': 'DejaVu Sans:weight=bold',

'sf': 'DejaVu Sans',

'tt': 'DejaVu Sans Mono',

'ex': 'DejaVu Sans Display',

0: 'DejaVu Sans',

"""

_fontmap = {

'rm': 'STIXGeneral',

'it': 'STIXGeneral:italic',

'bf': 'STIXGeneral:weight=bold',

'nonunirm': 'STIXNonUnicode',

'nonuniit': 'STIXNonUnicode:italic',

'nonunibf': 'STIXNonUnicode:weight=bold',

0: 'STIXGeneral',

1: 'STIXSizeOneSym',

2: 'STIXSizeTwoSym',

3: 'STIXSizeThreeSym',

4: 'STIXSizeFourSym',

5: 'STIXSizeFiveSym',

}

use_cmex = False # Unused; delete once mathtext becomes private.

cm_fallback = False

_sans = False

def __init__(self, *args, **kwargs):

TruetypeFonts.__init__(self, *args, **kwargs)

self.fontmap = {}

for key, name in self._fontmap.items():

fullpath = findfont(name)

self.fontmap[key] = fullpath

self.fontmap[name] = fullpath

def _map_virtual_font(self, fontname, font_class, uniindex):

# Handle these "fonts" that are actually embedded in

# other fonts.

mapping = stix_virtual_fonts.get(fontname)

if (self._sans and mapping is None

and fontname not in ('regular', 'default')):

mapping = stix_virtual_fonts['sf']

doing_sans_conversion = True

else:

doing_sans_conversion = False

if mapping is not None:

if isinstance(mapping, dict):

try:

mapping = mapping[font_class]

except KeyError:

mapping = mapping['rm']

# Binary search for the source glyph

lo = 0

hi = len(mapping)

while lo < hi:

mid = (lo+hi)//2

range = mapping[mid]

if uniindex < range[0]:

hi = mid

elif uniindex <= range[1]:

break

else:

lo = mid + 1

if range[0] <= uniindex <= range[1]:

uniindex = uniindex - range[0] + range[3]

fontname = range[2]

elif not doing_sans_conversion:

# This will generate a dummy character

uniindex = 0x1

fontname = mpl.rcParams['mathtext.default']

# Fix some incorrect glyphs.

if fontname in ('rm', 'it'):

uniindex = stix_glyph_fixes.get(uniindex, uniindex)

# Handle private use area glyphs

if fontname in ('it', 'rm', 'bf') and 0xe000 <= uniindex <= 0xf8ff:

fontname = 'nonuni' + fontname

return fontname, uniindex

@functools.lru_cache()

def get_sized_alternatives_for_symbol(self, fontname, sym):

fixes = {

'\\{': '{', '\\}': '}', '\\[': '[', '\\]': ']',

'<': '\N{MATHEMATICAL LEFT ANGLE BRACKET}',

'>': '\N{MATHEMATICAL RIGHT ANGLE BRACKET}',

}

sym = fixes.get(sym, sym)

try:

uniindex = get_unicode_index(sym)

except ValueError:

return [(fontname, sym)]

alternatives = [(i, chr(uniindex)) for i in range(6)

if self._get_font(i).get_char_index(uniindex) != 0]

# The largest size of the radical symbol in STIX has incorrect

# metrics that cause it to be disconnected from the stem.

if sym == r'\__sqrt__':

alternatives = alternatives[:-1]

"""

"""

basepath = str(cbook._get_data_path('fonts/afm'))

fontmap = {

'cal': 'pzcmi8a', # Zapf Chancery

'rm': 'pncr8a', # New Century Schoolbook

'tt': 'pcrr8a', # Courier

'it': 'pncri8a', # New Century Schoolbook Italic

'sf': 'phvr8a', # Helvetica

'bf': 'pncb8a', # New Century Schoolbook Bold

None: 'psyr', # Symbol

}

def __init__(self, default_font_prop, mathtext_backend=None):

if mathtext_backend is None:

# Circular import, can be dropped after public access to

# StandardPsFonts is removed and mathtext_backend made a required

# parameter.

from . import mathtext

mathtext_backend = mathtext.MathtextBackendPath()

super().__init__(default_font_prop, mathtext_backend)

self.glyphd = {}

self.fonts = {}

filename = findfont(default_font_prop, fontext='afm',

directory=self.basepath)

if filename is None:

filename = findfont('Helvetica', fontext='afm',

directory=self.basepath)

with open(filename, 'rb') as fd:

default_font = AFM(fd)

default_font.fname = filename

self.fonts['default'] = default_font

self.fonts['regular'] = default_font

pswriter = _api.deprecated("3.4")(property(lambda self: StringIO()))

def _get_font(self, font):

if font in self.fontmap:

basename = self.fontmap[font]

else:

basename = font

cached_font = self.fonts.get(basename)

if cached_font is None:

fname = os.path.join(self.basepath, basename + ".afm")

with open(fname, 'rb') as fd:

cached_font = AFM(fd)

cached_font.fname = fname

self.fonts[basename] = cached_font

self.fonts[cached_font.get_fontname()] = cached_font

return cached_font

def _get_info(self, fontname, font_class, sym, fontsize, dpi, math=True):

"""Load the cmfont, metrics and glyph with caching."""

key = fontname, sym, fontsize, dpi

tup = self.glyphd.get(key)

if tup is not None:

return tup

# Only characters in the "Letter" class should really be italicized.

# This class includes greek letters, so we're ok

if (fontname == 'it' and

(len(sym) > 1

or not unicodedata.category(sym).startswith("L"))):

fontname = 'rm'

found_symbol = False

if sym in latex_to_standard:

fontname, num = latex_to_standard[sym]

glyph = chr(num)

found_symbol = True

elif len(sym) == 1:

glyph = sym

num = ord(glyph)

found_symbol = True

else:

_log.warning(

"No TeX to built-in Postscript mapping for {!r}".format(sym))

slanted = (fontname == 'it')

font = self._get_font(fontname)

if found_symbol:

try:

glyph_name = font.get_name_char(glyph)

except KeyError:

_log.warning(

"No glyph in standard Postscript font {!r} for {!r}"

.format(font.get_fontname(), sym))

found_symbol = False

if not found_symbol:

glyph = '?'

num = ord(glyph)

glyph_name = font.get_name_char(glyph)

offset = 0

scale = 0.001 * fontsize

xmin, ymin, xmax, ymax = [val * scale

for val in font.get_bbox_char(glyph)]

metrics = types.SimpleNamespace(

advance = font.get_width_char(glyph) * scale,

width = font.get_width_char(glyph) * scale,

height = font.get_height_char(glyph) * scale,

xmin = xmin,

xmax = xmax,

ymin = ymin+offset,

ymax = ymax+offset,

# iceberg is the equivalent of TeX's "height"

iceberg = ymax + offset,

slanted = slanted

)

self.glyphd[key] = types.SimpleNamespace(

font = font,

fontsize = fontsize,

postscript_name = font.get_fontname(),

metrics = metrics,

glyph_name = glyph_name,

symbol_name = glyph_name, # Backcompat alias.

num = num,

glyph = glyph,

offset = offset

)

return self.glyphd[key]

def get_kern(self, font1, fontclass1, sym1, fontsize1,

font2, fontclass2, sym2, fontsize2, dpi):

if font1 == font2 and fontsize1 == fontsize2:

info1 = self._get_info(font1, fontclass1, sym1, fontsize1, dpi)

info2 = self._get_info(font2, fontclass2, sym2, fontsize2, dpi)

font = info1.font

return (font.get_kern_dist(info1.glyph, info2.glyph)

* 0.001 * fontsize1)

return super().get_kern(font1, fontclass1, sym1, fontsize1,

font2, fontclass2, sym2, fontsize2, dpi)

def get_xheight(self, font, fontsize, dpi):

font = self._get_font(font)

return font.get_xheight() * 0.001 * fontsize

def get_underline_thickness(self, font, fontsize, dpi):

font = self._get_font(font)

"""

# Percentage of x-height of additional horiz. space after sub/superscripts

script_space = 0.05

# Percentage of x-height that sub/superscripts drop below the baseline

subdrop = 0.4

# Percentage of x-height that superscripts are raised from the baseline

sup1 = 0.7

# Percentage of x-height that subscripts drop below the baseline

sub1 = 0.3

# Percentage of x-height that subscripts drop below the baseline when a

# superscript is present

sub2 = 0.5

# Percentage of x-height that sub/supercripts are offset relative to the

# nucleus edge for non-slanted nuclei

delta = 0.025

# Additional percentage of last character height above 2/3 of the

# x-height that supercripts are offset relative to the subscript

# for slanted nuclei

delta_slanted = 0.2

# Percentage of x-height that supercripts and subscripts are offset for

# integrals

script_space = 0.075

subdrop = 0.2

sup1 = 0.45

sub1 = 0.2

sub2 = 0.3

delta = 0.075

delta_slanted = 0.3