path: root/fonts/mathabx/source/mathbdel.mf

% mathematical symbols by Anthony Phan.
% file: mathbdel.mf (big delimiters)
% last modification: May 16, 2005.
% Only known charcodes will be generated.

def horizontal_rules_list =
  0.5[-d, h]-math_axis, 0.5[-d, h]-math_axis+x_height,
  0.25[-d, h], 0.5[-d, h], 0.75[-d, h] enddef;

% Since I thinck that adjust_fit's strategy is too
% complex,  I just cut actual width in three parts:
% ``visible'' width,  ``internal'' adjustment and
% finally ``external'' adjustment. Letter_fit# is
% added automatically (there is no use of appr#'s).

vardef set_width(expr inner_sharp, internal_sharp, external_sharp) =
  internal_adjustment := hround((internal_sharp+letter_fit#)*hppp);
  external_adjustment := hround((external_sharp+letter_fit#)*hppp);
  inner_sharp+internal_sharp+external_sharp+2letter_fit#
enddef;

% PARENTHESIS (look at cm)

def tmp_program(expr orientation, hair, stem, do_top, do_bot) =
  pickup fine.nib;
  pos1(hround hair, 0); pos2(hround stem, 0); pos3(hround hair, 0);
  if orientation = left:
    rt x1r = rt x3r = hround(w-internal_adjustment-0.25u+0.5hair);
    lft x2l = external_adjustment+hround 0.25u;
  else:
    lft x1l = lft x3l = hround(internal_adjustment+0.25u-0.5hair);
    rt x2r = w-external_adjustment-hround 0.25u;
  fi
  if do_top and do_bot:
    top y1 = h; bot y3 = -d; y2 = 0.5[y1, y3];
    filldraw stroke z1e{3(x2e-x1e), y2-y1}...z2e{down}
    ...{3(x3e-x2e), y3-y2}z3e;
  elseif do_top:
    top y1 = h; y2 = -d-eps;
    filldraw stroke z1e{3(x2e-x1e), y2-y1}...z2e{down};
  elseif do_bot:
    y2 = h+eps; bot y3 = -d;
    filldraw stroke z2e{down}...{3(x3e-x2e), y3-y2}z3e;
  else:
    pos2'(hround stem, 0); x2' = x2;
    y2 = h+eps; y2' = -d-eps;
    filldraw stroke z2e..z2'e;
  fi
  penlabels(1, 2, 3, 2');
enddef;

beginchar(paren_left,
    5u#+2appr#, body_height#, paren_depth#);
  "Left parenthesis";
%  italcorr body_height#*slant-0.5u#;
  pickup fine.nib;
  pos1(vair, 0); pos2(0.75[hair, stem], 0); pos3(vair, 0);
  rt x1r = rt x3r = w-appr; lft x2l = hround(x1-4u);
  top y1 = h; y2 = 0.5[y1, y3] = math_axis;
  filldraw stroke z1e{3(x2e-x1e), y2-y1}...z2e{down}
  ...{3(x3e-x2e), y3-y2}z3e;
  penlabels(1, 2, 3);
endchar;

beginchar(paren_left_big, %7u#,
    set_width(5u#, (1-0.25)*u#, (1+1.5)*u#), rth.frac#, 2dh#-rth.frac#);
  "big left parenthesis";
%  adjust_fit(1.5u#, -.25u#);
  tmp_program(left, hair, stem, true, true);
endchar;

beginchar(paren_left_Big, %9u#,
    set_width(7u#, (1-0.25)*u#, (1+2)*u#), rth.frac#, 3dh#-rth.frac#);
  "Big left parenthesis";
%  adjust_fit(2u#, -.25u#);
  tmp_program(left, rth1, .5[stem, bold], true, true);
endchar;

beginchar(paren_left_bigg, %11u#,
    set_width(9u#, (1-0.25)*u#, (1+2.5)*u#), rth.frac#, 4dh#-rth.frac#);
  "bigg left parenthesis";
%  adjust_fit(2.5u#, -.25u#);
  tmp_program(left, rth1+.2dw, bold, true, true);
endchar;

beginchar(paren_left_Bigg, %11.5u#,
    set_width(9.5u#, (1-0.25)*u#, (1+3)*u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg left parenthesis";
%  adjust_fit(3u#, -.25u#);
  tmp_program(left, rth1+.4dw, bold+dw, true, true);
endchar;

beginchar(paren_left_top, %12u#,
    set_width(10u#, (1-0.25)*u#, (1+4)*u#), rth.frac#, 3dh#-rth.frac#);
  "left perenthesis' extension top";
%  adjust_fit(4u#, -.25u#); pickup fine.nib;
  tmp_program(left, rth1+.6dw, bold+2dw, true, false);
endchar;

beginchar(paren_left_bot, %12u#,
    set_width(10u#, (1-0.25)*u#, (1+4)*u#), rth.frac#, 3dh#-rth.frac#);
  "left parenthesis' extension bot";
%  adjust_fit(4u#, -.25u#); pickup fine.nib;
  tmp_program(left, rth1+.6dw, bold+2dw, false, true);
endchar;

beginchar(paren_left_mid, %12u#,
    set_width(10u#, (1-0.25)*u#, (1+4)*u#), 0, dh#);
  "left parenthesis' extension mid";
%  adjust_fit(4u#, -.25u#); pickup fine.nib;
  tmp_program(left, rth1+.6dw, bold+2dw, false, false);
endchar;

beginchar(paren_right,
    5u#+2appr#, body_height#, paren_depth#);
  "Right parenthesis";
%  italcorr math_axis#*slant-0.5u#;
  pickup fine.nib;
  pos1(vair, 0); pos2(0.75[hair, stem], 0); pos3(vair, 0);
  lft x1l = lft x3l = appr; rt x2r = hround(x1+4u);
  top y1 = h; y2 = 0.5[y1, y3] = math_axis;
  filldraw stroke z1e{3(x2e-x1e), y2-y1}...z2e{down}
  ...{3(x3e-x2e), y3-y2}z3e;
  penlabels(1, 2, 3);
endchar;

beginchar(paren_right_big, %7u#,
    set_width(5u#, (1-0.25)*u#, (1+1.5)*u#), rth.frac#, 2dh#-rth.frac#);
  "big right parenthesis";
%  adjust_fit(-.25u#, 1.5u#);
  tmp_program(right, hair, stem, true, true);
endchar;

beginchar(paren_right_Big, %9u#,
    set_width(7u#, (1-0.25)*u#, (1+2)*u#), rth.frac#, 3dh#-rth.frac#);
  "Big right parenthesis";
%  adjust_fit(-.25u#, 2u#);
  tmp_program(right, rth1, .5[stem, bold], true, true);
endchar;

beginchar(paren_right_bigg, %11u#,
    set_width(9u#, (1-0.25)*u#, (1+2.5)*u#), rth.frac#, 4dh#-rth.frac#);
  "bigg right parenthesis";
%  adjust_fit(-.25u#, 2.5u#);
  tmp_program(right, rth1+.2dw, bold, true, true);
endchar;

beginchar(paren_right_Bigg, %11.5u#,
    set_width(9.5u#, (1-0.25)*u#, (1+3)*u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg right parenthesis";
%  adjust_fit(-.25u#, 3u#);
  tmp_program(right, rth1+.4dw, bold+dw, true, true);
endchar;

beginchar(paren_right_top, %12u#,
    set_width(10u#, (1-0.25)*u#, (1.4)*u#), rth.frac#, 3dh#-rth.frac#);
  "right parenthesis' extension top";
%  adjust_fit(-.25u#, 4u#); pickup fine.nib;
  tmp_program(right, rth1+.6dw, bold+2dw, true, false);
endchar;

beginchar(paren_right_bot, %12u#,
    set_width(10u#, (1-0.25)*u#, (1+4)*u#), rth.frac#, 3dh#-rth.frac#);
  "right parenthesis' extension top";
%  adjust_fit(-.25u#, 4u#); pickup fine.nib;
  tmp_program(right, rth1+.6dw, bold+2dw, false, true);
endchar;

beginchar(paren_right_mid, %12u#,
    set_width(10u#, (1-0.25)*u#, (1.4)*u#), 0, dh#);
  "big right parenthesis' extension mid";
%  adjust_fit(-.25u#, 4u#); pickup fine.nib;
  tmp_program(right, rth1+.6dw, bold+2dw, false, false);
endchar;

% BRACKETS

def tmp_program(expr orientation, stem, rth, do_top, do_bot, not_ext) =
  pickup tiny.nib;
  pos1(hround stem, 0); pos2(hround stem, 0);
  pos3(vround rth, 90); pos4(vround rth, 90);
  pos5(vround rth, 90); pos6(vround rth, 90);
  if do_top or not_ext: top y1 = h; else: y1 = h+eps; fi
  if do_bot or not_ext: bot y2 = -d; else: y2 = -d-eps; fi
  y1 = y3r = y4r; y2 = y5l = y6l;
  if orientation = left:
    lft x1l = lft x2l = min(external_adjustment, hround 0.5(w-stem));
    rt x3r = rt x5l = w-internal_adjustment;
    x4r = x1r; x6l = x2r;
  else:
    rt x1r = rt x2r = max(w-external_adjustment, hround 0.5(w+stem));
    lft x4r = lft x6l = internal_adjustment;
    x3r = x1l; x5l = x2l;
  fi
  filldraw stroke z1e--z2e;
  if do_top: filldraw stroke z3e--z4e; fi
  if do_bot: filldraw stroke z5e--z6e; fi
  penlabels(1, 2, 3, 4, 5, 6);
enddef;

% HALF BRACKETS (true heights or depths are to be discussed)

% okay
beginchar(bracket_upper_left,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Upper left bracket";
  a := d; d := -vround 0.75[-d, h];
  tmp_program(left, 0[0.95stem, 0.95cap_stem],
    rth0, true, false, true);
  d := a;
endchar;

% okay
beginchar(bracket_lower_left,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Lower left bracket";
  a := h; h := vround 0.25[-d, h];
  tmp_program(left, 0[0.95stem, 0.95cap_stem],
    rth0, false, true, true);
  h := a;
endchar;

% okay
beginchar(bracket_upper_right,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Upper right bracket";
  a := d; d := -vround 0.75[-d, h];
  tmp_program(right, 0[0.95stem, 0.95cap_stem],
    rth0, true, false, true);
  d := a;
endchar;

% okay
beginchar(bracket_lower_right,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Lower right bracket";
  a := h; h := vround 0.25[-d, h];
  tmp_program(right, 0[0.95stem, 0.95cap_stem],
    rth0, false, true, true);
  h := a;
endchar;

% okay
beginchar(bracket_upper_lower_left,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Upper lower left bracket";
  a := d; d := -vround 0.75[-d, h];
  tmp_program(left, 0[0.95stem, 0.95cap_stem],
    rth0, true, false, true);
  d := a;
  clearxy;
  a := h; h := vround 0.25[-d, h];
  tmp_program(left, 0[0.95stem, 0.95cap_stem],
    rth0, false, true, true);
  h := a;
endchar;

% okay
beginchar(bracket_upper_lower_right,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Upper lower right bracket";
  a := d; d := -vround 0.75[-d, h];
  tmp_program(right, 0[0.95stem, 0.95cap_stem],
    rth0, true, false, true);
  d := a;
  clearxy;
  a := h; h := vround 0.25[-d, h];
  tmp_program(right, 0[0.95stem, 0.95cap_stem],
    rth0, false, true, true);
  h := a;
endchar;

% okay
beginchar(bracket_left,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Left bracket";
  tmp_program(left, 0[0.95stem, 0.95cap_stem],
    rth0, true, true, true);
endchar;

beginchar(bracket_left_big,
    set_width(4.5u#, 0.4u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big left bracket";
  tmp_program(left, 0.125[0.95stem, 0.95cap_stem],
    0.125[rth0, rth1], true, true, true);
endchar;

beginchar(bracket_left_Big,
    set_width(5u#, 0.6u#, 3u#), rth.frac#, 3dh#-rth.frac#);
  "Big left bracket";
  tmp_program(left, 0.25[0.95stem, 0.95cap_stem],
    0.25[rth0, rth1], true, true, true);
endchar;

beginchar(bracket_left_bigg,
    set_width(5.5u#, 0.8u#, 3.5u#), rth.frac#, 4dh#-rth.frac#);
  "bigg left bracket";
  tmp_program(left, 0.5[0.95stem, 0.95cap_stem],
    0.5[rth0, rth1], true, true, true);
endchar;

beginchar(bracket_left_Bigg,
    set_width(6u#, 1.00u#, 4u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg left bracket";
  tmp_program(left, 0.75[0.95stem, 0.95cap_stem],
    0.75[rth0, rth1], true, true, true);
endchar;

beginchar(bracket_left_top,
    set_width(7u#, 1.5u#, 5u#), rth.frac#, 3dh#-rth.frac#);
  "left bracket's extension top";
  tmp_program(left, 0.95cap_stem, rth1, true, false, false);
endchar;

beginchar(bracket_left_bot,
    set_width(7u#, 1.5u#, 5u#), rth.frac#, 3dh#-rth.frac#);
  "left bracket's extension bottom";
  tmp_program(left, 0.95cap_stem, rth1, false, true, false);
endchar;

beginchar(bracket_left_mid,
    set_width(7u#, 1.5u#, 5u#), 0, dh#);
  "left bracket's extension module";
  tmp_program(left, 0.95cap_stem, rth1, false, false, false);
endchar;

% okay
beginchar(bracket_right,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Right bracket";
  tmp_program(right, 0[0.95stem, 0.95cap_stem],
    rth0, true, true, true);
endchar;

beginchar(bracket_right_big,
    set_width(4.5u#, 0.4u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big right bracket";
  tmp_program(right, 0.125[0.95stem, 0.95cap_stem],
    0.125[rth0, rth1], true, true, true);
endchar;

beginchar(bracket_right_Big,
    set_width(5u#, 0.6u#, 3u#), rth.frac#, 3dh#-rth.frac#);
  "Big right bracket";
  tmp_program(right, 0.25[0.95stem, 0.95cap_stem],
    0.25[rth0, rth1], true, true, true);
endchar;

beginchar(bracket_right_bigg,
    set_width(5.5u#, 0.80u#, 3.5u#), rth.frac#, 4dh#-rth.frac#);
  "bigg right bracket";
  tmp_program(right, 0.5[0.95stem, 0.95cap_stem],
    0.5[rth0, rth1], true, true, true);
endchar;

beginchar(bracket_right_Bigg,
    set_width(6u#, 1.00u#, 4u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg right bracket";
  tmp_program(right, 0.75[0.95stem, 0.95cap_stem],
    0.75[rth0, rth1], true, true, true);
endchar;

beginchar(bracket_right_top,
    set_width(7u#, 1.5u#, 5u#), rth.frac#, 3dh#-rth.frac#);
  "right bracket's extension top";
  tmp_program(right, 0.95cap_stem, rth1, true, false, false);
endchar;

beginchar(bracket_right_bot,
    set_width(7u#, 1.5u#, 5u#), rth.frac#, 3dh#-rth.frac#);
  "right bracket's extension bottom";
  tmp_program(right, 0.95cap_stem, rth1, false, true, false);
endchar;

beginchar(bracket_right_mid,
    set_width(7u#, 1.5u#, 5u#), 0, dh#);
  "right bracket's extension module";
  tmp_program(right, 0.95cap_stem, rth1, false, false, false);
endchar;

% okay
beginchar(ceiling_left,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Left ceiling";
  tmp_program(left, 0[0.95stem, 0.95cap_stem],
    rth0, true, false, true);
endchar;

beginchar(ceiling_left_big,
    set_width(4.5u#, 0.4u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big left ceiling";
  tmp_program(left, 0.125[0.95stem, 0.95cap_stem],
    0.125[rth0, rth1], true, false, true);
endchar;

beginchar(ceiling_left_Big,
    set_width(5u#, 0.6u#, 3u#), rth.frac#, 3dh#-rth.frac#);
  "Big left ceiling";
  tmp_program(left, 0.25[0.95stem, 0.95cap_stem],
    0.25[rth0, rth1], true, false, true);
endchar;

beginchar(ceiling_left_bigg,
    set_width(5.5u#, 0.8u#, 3.5u#), rth.frac#, 4dh#-rth.frac#);
  "bigg left ceiling";
  tmp_program(left, 0.5[0.95stem, 0.95cap_stem],
    0.5[rth0, rth1], true, false, true);
endchar;

beginchar(ceiling_left_Bigg,
    set_width(6u#, 1.00u#, 4u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg left ceiling";
  tmp_program(left, 0.75[0.95stem, 0.95cap_stem],
    0.75[rth0, rth1], true, false, true);
endchar;

% okay
beginchar(ceiling_right,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Right ceiling";
  tmp_program(right, 0[0.95stem, 0.95cap_stem], rth0, true, false, true);
endchar;

beginchar(ceiling_right_big,
    set_width(4.5u#, 0.4u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big right ceiling";
  tmp_program(right, 0.125[0.95stem, 0.95cap_stem],
    0.125[rth0, rth1], true, false, true);
endchar;

beginchar(ceiling_right_Big,
    set_width(5u#, 0.6u#, 3u#), rth.frac#, 3dh#-rth.frac#);
  "Big right ceiling";
  tmp_program(right, 0.25[0.95stem, 0.95cap_stem],
    0.25[rth0, rth1], true, false, true);
endchar;

beginchar(ceiling_right_bigg,
    set_width(5.5u#, 0.80u#, 3.5u#), rth.frac#, 4dh#-rth.frac#);
  "bigg right ceiling";
  tmp_program(right, 0.5[0.95stem, 0.95cap_stem],
    0.5[rth0, rth1], true, false, true);
endchar;

beginchar(ceiling_right_Bigg,
    set_width(6u#, 1.00u#, 4u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg right ceiling";
  tmp_program(right, 0.75[0.95stem, 0.95cap_stem],
    0.75[rth0, rth1], true, false, true);
endchar;

% okay
beginchar(floor_left,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Left floor";
  tmp_program(left, 0[0.95stem, 0.95cap_stem],
    rth0, false, true, true);
endchar;

beginchar(floor_left_big,
    set_width(4.5u#, 0.4u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big left floor";
  tmp_program(left, 0.125[0.95stem, 0.95cap_stem],
    0.125[rth0, rth1], false, true, true);
endchar;

beginchar(floor_left_Big,
    set_width(5u#, 0.6u#, 3u#), rth.frac#, 3dh#-rth.frac#);
  "Big left floor";
  tmp_program(left, 0.25[0.95stem, 0.95cap_stem],
    0.25[rth0, rth1], false, true, true);
endchar;

beginchar(floor_left_bigg,
    set_width(5.5u#, 0.8u#, 3.5u#), rth.frac#, 4dh#-rth.frac#);
  "bigg left floor";
  tmp_program(left, 0.5[0.95stem, 0.95cap_stem],
    0.5[rth0, rth1], false, true, true);
endchar;

beginchar(floor_left_Bigg,
    set_width(6u#, 1.00u#, 4u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg left floor";
  tmp_program(left, 0.75[0.95stem, 0.95cap_stem],
    0.75[rth0, rth1], false, true, true);
endchar;

% okay
beginchar(floor_right,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Right floor";
  tmp_program(right, 0[0.95stem, 0.95cap_stem],
    rth0, false, true, true);
endchar;

beginchar(floor_right_big,
    set_width(4.5u#, 0.4u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big right floor";
  tmp_program(right, 0.125[0.95stem, 0.95cap_stem],
    0.125[rth0, rth1], false, true, true);
endchar;

beginchar(floor_right_Big,
    set_width(5u#, 0.6u#, 3u#), rth.frac#, 3dh#-rth.frac#);
  "Big right floor";
  tmp_program(right, 0.25[0.95stem, 0.95cap_stem],
    0.25[rth0, rth1], false, true, true);
endchar;

beginchar(floor_right_bigg,
    set_width(5.5u#, 0.80u#, 3.5u#), rth.frac#, 4dh#-rth.frac#);
  "bigg right floor";
  tmp_program(right, 0.5[0.95stem, 0.95cap_stem],
    0.5[rth0, rth1], false, true, true);
endchar;

beginchar(floor_right_Bigg,
    set_width(6u#, 1.00u#, 4u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg right floor";
  tmp_program(right, 0.75[0.95stem, 0.95cap_stem],
    0.75[rth0, rth1], false, true, true);
endchar;

% BRACES

def tmp_program(expr orientation, stem, hair, factor, superness) =
  pickup fine.nib;
  if orientation = left:
    rt x5l = w-internal_adjustment;
    lft x1 = external_adjustment;
  else:
    lft x5l = internal_adjustment;
    rt x1 = w-external_adjustment;
  fi
  x3 = 0.5[x1, x5l];
  y1+0.5hair = vround(0.5[-d, h]+0.5hair); pos1(hround hair, 90);
  top y5r = h+eps; y3 = 0.5[y1l, y5r]; y2 = y2l = y1l; y1r = y2r;
  x2 = factor[x3, x5l]; a := 0.5[angle(z3-z2), 90]; pos5(hair, a);
  pos3(stem, angle(z3-z2) if orientation = left: + else: - fi 90);
  forsuffixes $ = r, l:
    z2$-z3$ = whatever*(z2-z3);
    z4$-z3$ = whatever*(z2-z3);
    z4$-z5$ = whatever*dir(a+90);
    forsuffixes @ = 1, 2, 3, 4, 5:
      x@'.$ = x@.$; y@'.$-y1 = y1-y@.$;
    endfor
  endfor
  autorounded;
  filldraw stroke z1e{x5e-x1e, 0}...
  (z2e+(1-superness)*(z1e-z2e)+(1-superness)*(z3e-z2e)){z3e-z1e}
  ...z3e{z3e-z2e}...
  (z4e+(1-superness)*(z3e-z4e)+(1-superness)*(z5e-z4e)){z5e-z3e}
  ...z5e{z5e-z4e};
  filldraw stroke z1'e{x5'e-x1'e, 0}...
  (z2'e+(1-superness)*(z1'e-z2'e)+(1-superness)*(z3'e-z2'e)){z3'e-z1'e}
  ...z3'e{z3'e-z2'e}...
  (z4'e+(1-superness)*(z3'e-z4'e)+(1-superness)*(z5'e-z4'e)){z5'e-z3'e}
  ...z5'e{z5'e-z4'e};
%  filldraw stroke z1e{x5e-x1e, 0}..
%  controls 0.5[z1e, z2e] and z2e ..z3e..
%  controls z4e and 0.5[z5e, z4e] ..z5e;
%  filldraw stroke z1'e{x5'e-x1'e, 0}..
%  controls 0.5[z1'e, z2'e] and z2'e ..z3'e..
%  controls z4'e and 0.5[z5'e, z4'e] ..z5'e;
 penlabels(1, 2, 3, 4, 5, 1', 2', 3', 4', 5');
enddef;

beginchar(brace_left,
    set_width(5u#, 1.5u#, 1.5u#), body_height#, paren_depth#);
  "left brace";
  tmp_program(left, 0[stem, cap_stem],
    0[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_left_big,
    set_width(6u#, 1.75*u#, 1.75*u#), rth.frac#, 2dh#-rth.frac#);
  "big left brace";
  tmp_program(left, 0.125[stem, cap_stem],
    0.125[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_left_Big,
    set_width(7u#, 2*u#, 2*u#), rth.frac#, 3dh#-rth.frac#);
  "Big left brace";
  tmp_program(left, 0.25[stem, cap_stem],
    0.25[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_left_bigg,
    set_width(8u#, 2.25*u#, 2.25*u#), rth.frac#, 4dh#-rth.frac#);
  "bigg left brace";
  tmp_program(left, 0.5[stem, cap_stem],
    0.5[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_left_Bigg,
    set_width(9u#, 2.5*u#, 2.5*u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg left brace";
  tmp_program(left, 0.75[stem, cap_stem],
    0.75[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_left_top,
    set_width(10u#, 3*u#, 3*u#), 0, 1.5dh#);
  "left brace's extension top";
  a := cap_stem;
  pickup fine.nib;
  top y1l = h; top y1l-y2 = 0.5(h+d); y3 = -d-eps;
  rt x1 = w-internal_adjustment;
  x2 = x3 = hround(0.5[external_adjustment, w-internal_adjustment]-0.5a)+0.5a;
  pos1(rth1, -90); pos2(a, 0); pos3(a, 0);
  filldraw stroke z1e left_to_down z2e..z3e;
  penlabels(1, 2, 3);
endchar;

beginchar(brace_left_bot,
    set_width(10u#, 3*u#, 3*u#), 0, 1.5dh#);
  "left brace's extension bot";
  a := cap_stem;
  pickup fine.nib;
  y1 = h+eps; y2-bot y3l = 0.5(h+d); bot y3l = -d;
  rt x3 = w-internal_adjustment;
  x1 = x2 = hround(0.5[external_adjustment, w-internal_adjustment]-0.5a)+0.5a;
  pos1(a, 0); pos2(a, 0); pos3(rth1, 90);
  filldraw stroke z1e..z2e down_to_right z3e;
  penlabels(1, 2, 3);
endchar;

beginchar(brace_left_mid,
    set_width(10u#, 3*u#, 3*u#), 0, 3dh#);
  "left brace's extension mid";
  a := cap_stem;
  pickup fine.nib;
  y1 = h+eps;
  y3+0.5rth1 = vround(0.5[-d, h]+0.5rth1);
  y2-bot y3r = top y3l-y4 = 0.25(h+d); y5 = -d-eps;
  x1 = x2 = x4 = x5 = hround(0.5[external_adjustment, w-internal_adjustment]-0.5a)+0.5a;
  lft x3 = external_adjustment;
  pos1(a, 0); pos2(a, 0); pos3(rth1, -90); pos4(a, 180); pos5(a, 180);
  filldraw stroke z1e..z2e down_to_left z3e;
  filldraw stroke z3e right_to_down z4e..z5e;
  penlabels(1, 2, 3, 4, 5);
endchar;

beginchar(brace_left_mod,
    set_width(10u#, 3*u#, 3*u#), 0, 0.5dh#);
  "left brace's extension module";
  a := cap_stem;
  pickup fine.nib; y1 = h+eps; y2 = -d-eps;
  x1 = x2 = hround(0.5[external_adjustment, w-internal_adjustment]-0.5a)+0.5a;
  pos1(a, 0); pos2(a, 0); filldraw stroke z1e..z2e; penlabels(1, 2);
endchar;

beginchar(brace_right,
    set_width(5u#, 1.5u#, 1.5u#), body_height#, paren_depth#);
  "Right brace";
  internal_adjustment := appr+hround 0.5u;
  external_adjustment := appr+hround 0.5u;
  tmp_program(right, 0[stem, cap_stem],
    0[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_right_big,
    set_width(6u#, 1.75*u#, 1.75*u#), rth.frac#, 2dh#-rth.frac#);
  "big right brace";
  tmp_program(right, 0.125[stem, cap_stem],
    0.125[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_right_Big,
    set_width(7u#, 2*u#, 2*u#), rth.frac#, 3dh#-rth.frac#);
  "Big right brace";
  tmp_program(right, 0.25[stem, cap_stem],
    0.25[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_right_bigg,
    set_width(8u#, 2.25*u#, 2.25*u#), rth.frac#, 4dh#-rth.frac#);
  "bigg right brace";
  tmp_program(right, 0.5[stem, cap_stem],
    0.5[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_right_Bigg,
    set_width(9u#, 2.5*u#, 2.5*u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg right brace";
  tmp_program(right, 0.75[stem, cap_stem],
    0.75[hair, rth1], 0.5, superness);
endchar;

beginchar(brace_right_top,
    set_width(10u#, 3*u#, 3*u#), 0, 1.5dh#);
  "right brace's extension top";
  a := cap_stem;
  pickup fine.nib;
  top y1r = h; top y1r-y2 = 0.5(h+d); y3 = -d-eps;
  lft x1 = internal_adjustment;
  x2 = x3 = hround(0.5[internal_adjustment, w-external_adjustment]-0.5a)+0.5a;
  pos1(rth1, 90); pos2(a, 0); pos3(a, 0);
  filldraw stroke z1e right_to_down z2e..z3e;
  penlabels(1, 2, 3);
endchar;

beginchar(brace_right_bot,
    set_width(10u#, 3*u#, 3*u#), 0, 1.5dh#);
  "right brace's extension bot";
  a := cap_stem;
  pickup fine.nib;
  y1 = h+eps; y2-bot y3r = 0.5(h+d); bot y3r = -d;
  lft x3 = internal_adjustment;
  x1 = x2 = hround(0.5[internal_adjustment, w-external_adjustment]-0.5a)+0.5a;
  pos1(a, 0); pos2(a, 0); pos3(rth1, -90);
  filldraw stroke z1e..z2e down_to_left z3e;
  penlabels(1, 2, 3);
endchar;

beginchar(brace_right_mid,
    set_width(10u#, 3*u#, 3*u#), 0, 3dh#);
  "right brace's extension mid";
  a := cap_stem;
  pickup fine.nib;
  y1 = h+eps;
  y3+0.5rth1 = vround(0.5[-d, h]+0.5rth1);
  y2-bot y3l = top y3r-y4 = 0.25(h+d);
  y5 = -d-eps;
  x1 = x2 = x4 = x5 = hround(0.5[internal_adjustment, w-external_adjustment]-0.5a)+0.5a;
  rt x3 = w-external_adjustment;
  pos1(a, 0); pos2(a, 0); pos3(rth1, 90); pos4(a, 180); pos5(a, 180);
  filldraw stroke z1e..z2e down_to_right z3e;
  filldraw stroke z3e right_to_down z4e..z5e;
  penlabels(1, 2, 3, 4, 5);
endchar;

beginchar(brace_right_mod,
    set_width(10u#, 3*u#, 3*u#), 0, 0.5dh#);
  "right brace's extension module";
  a := cap_stem;
  pickup fine.nib; y1 = h+eps; y2 = -d-eps;
  x1 = x2 = hround(0.5[internal_adjustment, w-external_adjustment]-0.5a)+0.5a;
  pos1(a, 0); pos2(a, 0); filldraw stroke z1e..z2e; penlabels(1, 2);
endchar;

% ANGLES

def tmp_program(expr orientation, rth) =
  pickup tiny.nib;
  top y1r = h+eps; y2l = good.y 0.5[-d, h]; y1r-y2l = y2l-y3r;
  if orientation = left:
    rt x1r = rt x3r = w-internal_adjustment+eps;
    lft x2l = external_adjustment-eps;
    adjust_slanted_bar(1r, 2l, 1l, 2a)(max(rth-tiny, 1), -1);
    adjust_slanted_bar(3r, 2l, 3l, 2b)(max(rth-tiny, 1), 1);
  else:
    lft x1r = lft x3r = internal_adjustment-eps;
    rt x2l = w-external_adjustment+eps;
    adjust_slanted_bar(1r, 2l, 1l, 2a)(max(rth-tiny, 1), 1);
    adjust_slanted_bar(3r, 2l, 3l, 2b)(max(rth-tiny, 1), -1);
  fi
  z2r = whatever[z1r, z2a]; z2r = whatever[z3r, z2b];
  filldraw stroke z1e--z2e--z3e;
  penlabels(1, 2, 3); labels(2a, 2b);
enddef;

% almost okay
beginchar(angle_left,
    set_width(6.5u#, 0.5u#, 0.5u#), body_height#, paren_depth#);
  "Left angle";
  tmp_program(left, rth0);
endchar;

beginchar(angle_left_big,
    set_width(8u#, 0.75u#, 0.75u#), rth.frac#, 2dh#-rth.frac#);
  "big left angle";
  tmp_program(left, 0.125[rth0, rth2]);
endchar;

beginchar(angle_left_Big,
    set_width(10u#, 1.0u#, 1.0u#), rth.frac#, 3dh#-rth.frac#);
  "Big left angle";
  tmp_program(left, 0.25[rth0, rth2]);
endchar;

beginchar(angle_left_bigg,
    set_width(12u#, 1.25u#, 1.25u#), rth.frac#, 4dh#-rth.frac#);
  "bigg left angle";
  tmp_program(left, 0.5[rth0, rth2]);
endchar;

beginchar(angle_left_Bigg,
    set_width(14u#, 1.5u#, 1.5u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg left angle";
  tmp_program(left, 0.75[rth0, rth2]);
endchar;

% almost okay
beginchar(angle_right,
    set_width(6.5u#, 0.5u#, 0.5u#), body_height#, paren_depth#);
  "Right angle";
  tmp_program(right, rth0);
endchar;

beginchar(angle_right_big,
    set_width(8u#, 0.75u#, 0.75u#), rth.frac#, 2dh#-rth.frac#);
  "big right angle";
  tmp_program(right, 0.125[rth0, rth2]);
endchar;

beginchar(angle_right_Big,
    set_width(10u#, 1.0u#, 1.0u#), rth.frac#, 3dh#-rth.frac#);
  "Big right angle";
  tmp_program(right, 0.25[rth0, rth2]);
endchar;

beginchar(angle_right_bigg,
    set_width(12u#, 1.25u#, 1.25u#), rth.frac#, 4dh#-rth.frac#);
  "bigg right angle";
  tmp_program(right, 0.5[rth0, rth2]);
endchar;

beginchar(angle_right_Bigg,
    set_width(14u#, 1.5u#, 1.5u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg right angle";
  tmp_program(right, 0.75[rth0, rth2]);
endchar;

% SLASHES

vardef tmp_program(expr orientation, thickness, slash_slant) =
  pickup tiny.nib;
  top y1 = h; y1 = y1l = y1r; bot y2 = -d; y2 = y2l = y2r;
  0.5[x1, x2] = 0.5w;
  x1-x2 = if orientation = left: - fi slash_slant*(y1-y2);
  x1r-x1l = x2r-x2l = diag_width(thickness-tiny, z1-z2);
  0.5[x1l, x1r] = x1; 0.5[x2l, x2r] = x2;
  filldraw stroke z1e..z2e;
  penlabels(1, 2);
enddef;

beginchar(backslash,
    set_width((body_height#+paren_depth#)*0.375
      +(0[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      0.2u#, 0.2u#),
    body_height#, paren_depth#);
  "backslash";
  tmp_program(left, 0[rth0, rth2], 0.375);
endchar;

beginchar(backslash_thick,
    set_width((body_height#+paren_depth#)*0.375
      +(0.95stem#-tiny#)*(1++0.375)+tiny#,
      0.2u#, 0.2u#),
    body_height#, paren_depth#);
  "Thick backslash";
  tmp_program(left, 0.95stem, 0.375);
endchar;

beginchar(backslash_big,
    set_width(2dh#*0.375
      +(0.125[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      0.4u#, 0.4u#),
    rth.frac#, 2dh#-rth.frac#);
  "big backslash";
  tmp_program(left, 0.125[rth0, rth2], 0.375);
endchar;

beginchar(backslash_Big,
    set_width(3dh#*0.375
      +(0.25[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      0.7u#, 0.7u#),
    rth.frac#, 3dh#-rth.frac#);
  "Big backslash";
  tmp_program(left, 0.25[rth0, rth2], 0.375);
endchar;

beginchar(backslash_bigg,
    set_width(4dh#*0.375
      +(0.5[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      1.0u#, 1.0u#),
    rth.frac#, 4dh#-rth.frac#);
  "bigg backslash";
  tmp_program(left, 0.5[rth0, rth2], 0.375);
endchar;

beginchar(backslash_Bigg,
    set_width(5dh#*0.375
      +(0.75[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      1.2u#, 1.2u#),
    rth.frac#, 5dh#-rth.frac#);
  "Bigg backslash";
  tmp_program(left, 0.75[rth0, rth2], 0.375);
endchar;

beginchar(slash,
    set_width((body_height#+paren_depth#)*0.375
      +(0[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      0.2u#, 0.2u#),
    body_height#, paren_depth#);
  "slash";
  tmp_program(right, 0[rth0, rth2], 0.375);
endchar;

beginchar(slash_thick,
    set_width((body_height#+paren_depth#)*0.375
      +(0.95stem#-tiny#)*(1++0.375)+tiny#,
      0.2u#, 0.2u#),
    body_height#, paren_depth#);
  "Thick slash";
  tmp_program(right, 0.95stem, 0.375);
endchar;

beginchar(slash_big,
    set_width(2dh#*0.375
      +(0.125[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      0.4u#, 0.4u#),
    rth.frac#, 2dh#-rth.frac#);
  "big slash";
  tmp_program(right, 0.125[rth0, rth2], 0.375);
endchar;

beginchar(slash_Big,
    set_width(3dh#*0.375
      +(0.25[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      0.7u#, 0.7u#),
    rth.frac#, 3dh#-rth.frac#);
  "Big slash";
  tmp_program(right, 0.25[rth0, rth2], 0.375);
endchar;

beginchar(slash_bigg,
    set_width(4dh#*0.375
      +(0.5[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      1.0u#, 1.0u#),
    rth.frac#, 4dh#-rth.frac#);
  "bigg slash";
  tmp_program(right, 0.5[rth0, rth2], 0.375);
endchar;

beginchar(slash_Bigg,
    set_width(5dh#*0.375
      +(0.75[rth0#, rth2#]-tiny#)*(1++0.375)+tiny#,
      1.2u#, 1.2u#),
    rth.frac#, 5dh#-rth.frac#);
  "Bigg slash";
  tmp_program(right, 0.75[rth0, rth2], 0.375);
endchar;

%
% blackboard bold brackets
%

def tmp_program(expr orientation, rth, thick,
    do_top, do_bot, not_ext) =
  save a, b;
  a = hround(rth*(1++slant)); b = hround(thick*(1++slant));
  y5r = y6r = h if do_top or not_ext: else: +eps fi;
  y7r = y8r = -d if do_bot or not_ext: else: -eps fi;
  if orientation = left:
    forsuffixes @# = 1, 2, 3, 4: x@#r-x@# = x@#-x@#l = -0.5a; endfor
    x1r = x2r = x5r = x7r = min(external_adjustment,
      hround 0.5(w-a-b));
    x1-x3 = x2-x4 = -b; x6r = x8r = w-internal_adjustment;
  else:
    forsuffixes @# = 1, 2, 3, 4: x@#r-x@# = x@#-x@#l = 0.5a; endfor
    x1r = x2r = x5r = x7r = max(w-external_adjustment,
      hround 0.5(w+a+b));
    x1-x3 = x2-x4 = b; x6r = x8r = internal_adjustment;
  fi
  forsuffixes @ = 1, 1r, 1l, 3, 3r, 3l: z@ = whatever[z5r, z6r]; endfor
  forsuffixes @ = 2, 2r, 2l, 4, 4r, 4l: z@ = whatever[z7r, z8r]; endfor
  penpos5(rth, 90); penpos6(rth, 90);
  penpos7(rth, -90); penpos8(rth, -90);
  penstroke z1e..z2e; penstroke z3e..z4e;
  if do_top: penstroke z5e..z6e; fi
  if do_bot: penstroke z7e..z8e; fi
  penlabels(1, 2, 3, 4, 5, 6, 7, 8);
enddef;

beginchar(bbbracket_left,
    set_width(5u#, 0.5u#, 2u#), body_height#, paren_depth#);
  "Left bbbracket";
  tmp_program(left, rth0, 2.2u, true, true, true);
endchar;

beginchar(bbbracket_left_big,
    set_width(5.5u#, 0.75u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big left bbbracket";
  tmp_program(left, 0.125[rth0, rth1], 0.125[2.2u, 3.0u], true, true, true);
endchar;

beginchar(bbbracket_left_Big,
    set_width(6.0u#, 1.0u#, 3u#), rth.frac#, 3dh#-rth.frac#);
  "Big left bbbracket";
  tmp_program(left, 0.25[rth0, rth1], 0.25[2.2u, 3.0u], true, true, true);
endchar;

beginchar(bbbracket_left_bigg,
    set_width(6.5u#, 1.25u#, 3.5u#), rth.frac#, 4dh#-rth.frac#);
  "bigg left bbbracket";
  tmp_program(left, 0.5[rth0, rth1], 0.5[2.2u, 3.0u], true, true, true);
endchar;

beginchar(bbbracket_left_Bigg,
    set_width(7.0u#, 1.5u#, 4u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg left bbbracket";
  tmp_program(left, 0.75[rth0, rth1], 0.75[2.2u, 3.0u], true, true, true);
endchar;

beginchar(bbbracket_left_top,
    set_width(8u#, 2u#, 5u#), rth.frac#, 3dh#-rth.frac#);
  "Left bbbracket's extension top";
  tmp_program(left, rth1, 3.0u, true, false, false);
endchar;

beginchar(bbbracket_left_bot,
    set_width(8u#, 2u#, 5u#), rth.frac#, 3dh#-rth.frac#);
  "Left bbbracket's extension bottom";
  tmp_program(left, rth1, 3.0u, false, true, false);
endchar;

beginchar(bbbracket_left_mid,
    set_width(8u#, 2u#, 5u#), 0, dh#);
  "Left bbbracket's extension module";
  tmp_program(left, rth1, 3.0u, false, false, false);
endchar;

beginchar(bbbracket_right,
    set_width(5u#, 0.5u#, 2u#), body_height#, paren_depth#);
  "Right bbbracket";
  tmp_program(right, rth0, 2.2u, true, true, true);
endchar;

beginchar(bbbracket_right_big,
    set_width(5.5u#, 0.75u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big right bbbracket";
  tmp_program(right, 0.125[rth0, rth1], 0.125[2.2u, 3.0u], true, true, true);
endchar;

beginchar(bbbracket_right_Big,
    set_width(6.0u#, 1.0u#, 3u#), rth.frac#, 3dh#-rth.frac#);
  "Big right bbbracket";
  tmp_program(right, 0.25[rth0, rth1], 0.25[2.2u, 3.0u], true, true, true);
endchar;

beginchar(bbbracket_right_bigg,
    set_width(6.5u#, 1.25u#, 3.5u#), rth.frac#, 4dh#-rth.frac#);
  "bigg right bbbracket";
  tmp_program(right, 0.5[rth0, rth1], 0.5[2.2u, 3.0u], true, true, true);
endchar;

beginchar(bbbracket_right_Bigg,
    set_width(7.0u#, 1.5u#, 4u#), rth.frac#, 5dh#-rth.frac#);
  "Bigg right bbbracket";
  tmp_program(right, 0.75[rth0, rth1], 0.75[2.2u, 3.0u], true, true, true);
endchar;

beginchar(bbbracket_right_top,
    set_width(8u#, 2.0u#, 5u#), rth.frac#, 3dh#-rth.frac#);
  "Right bbbracket's extension top";
  tmp_program(right, rth1, 3.0u, true, false, false);
endchar;

beginchar(bbbracket_right_bot,
    set_width(8u#, 2.0u#, 5u#), rth.frac#, 3dh#-rth.frac#);
  "Right bbbracket's extension bottom";
  tmp_program(right, rth1, 3.0u, false, true, false);
endchar;

beginchar(bbbracket_right_mid,
    set_width(8u#, 2.0u#, 5u#), 0, dh#);
  "Right bbbracket's extension module";
  tmp_program(right, rth1, 3.0u, false, false, false);
endchar;

%
% A poursuivre
%

beginchar(vert_sign, 3u#+2appr#, body_height#, paren_depth#);
  "Vertical line";
  ensure_centering_of(rth1);
  pickup tiny.nib;
  pos1(rth1, 0); pos2(rth1, 0); x1 = x2 = 0.5w;
  top y1 = h; bot y2 = -d; filldraw stroke z1e..z2e;
  penlabels(1, 2);
endchar;

beginchar(vert_mod, 3u#+2appr#, 0, dh#);
  "Vertical line's module";
  ensure_centering_of(rth1);
  pickup tiny.nib;
  pos1(rth1, 0); pos2(rth1, 0); x1 = x2 = 0.5w;
  y1 = h+eps; y2 = -d-eps; filldraw stroke z1e..z2e;
  penlabels(1, 2);
endchar;

beginchar(vert_thick, 3u#+2appr#, body_height#, paren_depth#);
  "Thick vertical line";
  ensure_centering_of(0.95stem);
  pickup tiny.nib;
  pos1(hround 0.95stem, 0); pos2(hround 0.95stem, 0); x1 = x2 = 0.5w;
  top y1 = h; bot y2 = -d; filldraw stroke z1e..z2e;
  penlabels(1, 2);
endchar;

beginchar(vert_thick_mod, 3u#+2appr#, 0, dh#);
  "Thick vertical line's module";
  ensure_centering_of(0.95stem);
  pickup tiny.nib;
  pos1(hround 0.95stem, 0); pos2(hround 0.95stem, 0);
  x1 = x2 = 0.5w; y1 = h+eps; y2 = -d-eps; filldraw stroke z1e..z2e;
  penlabels(1, 2);
endchar;

beginchar(vvert_sign, 5.5u#+2appr#, body_height#, paren_depth#);
  "Double vertical line";
  numeric a; a = max(2.5u-rth0, 2rth0);% blank space between bars
  pickup tiny.nib;
  pos1(rth0, 0); pos2(rth0, 0); pos3(rth0, 0); pos4(rth0, 0);
  rt x1r = rt x2r = hround 0.5(w-a);
  w-rt x3r = lft x1l; x3 = x4;
  top y1 = top y3 = h; bot y2 = bot y4 = -d;
  filldraw stroke z1e..z2e;
  filldraw stroke z3e..z4e;
  penlabels(1, 2, 3, 4);
endchar;

beginchar(vvert_mod, 5.5u#+2appr#, 0, dh#);
  "Double vertical line's module";
  numeric a; a = max(2.5u-rth0, 2rth0);% blank space between bars
  pickup tiny.nib;
  pos1(rth0, 0); pos2(rth0, 0); pos3(rth0, 0); pos4(rth0, 0);
  rt x1r = rt x2r = hround 0.5(w-a);
  w-rt x3r = lft x1l; x3 = x4;
  y1 = y3 = h+eps; y2 = y4 = -d-eps;
  filldraw stroke z1e..z2e;
  filldraw stroke z3e..z4e;
  penlabels(1, 2, 3, 4);
endchar;

beginchar(vvvert_sign, 9u#+2appr#, body_height#, paren_depth#);
  "Triple vertical line";
  ensure_centering_of(rth0);
  numeric a; a = max(2.75u-rth0, 2rth0);% blank space between bars
  pickup tiny.nib;
  pos1(rth0, 0); pos2(rth0, 0);
  pos3(rth0, 0); pos4(rth0, 0);
  pos5(rth0, 0); pos6(rth0, 0);
  x3 = x4 = 0.5w; x1 = x2; x5 = x6;
  lft x5l-rt x3r = lft x3l-rt x1r = hround a;
  top y1 = top y3 = top y5 = h;
  bot y2 = bot y4 = bot y6 = -d;
  filldraw stroke z1e..z2e;
  filldraw stroke z3e..z4e;
  filldraw stroke z5e..z6e;
  penlabels(1, 2, 3, 4, 5, 6);
endchar;

beginchar(vvvert_mod, 9u#+2appr#, 0, dh#);
  "Triple vertical line's module";
  ensure_centering_of(rth0);
  numeric a; a = max(2.75u-rth0, 2rth0);% blank space between bars
  pickup tiny.nib;
  pos1(rth0, 0); pos2(rth0, 0);
  pos3(rth0, 0); pos4(rth0, 0);
  pos5(rth0, 0); pos6(rth0, 0);
  x3 = x4 = 0.5w; x1 = x2; x5 = x6;
  lft x5l-rt x3r = lft x3l-rt x1r = hround a;
  y1 = y3 = y5 = h+eps; y2 = y4 = y6 = -d-eps;
  filldraw stroke z1e..z2e;
  filldraw stroke z3e..z4e;
  filldraw stroke z5e..z6e;
  penlabels(1, 2, 3, 4, 5, 6);
endchar;

beginchar(left_filet, 4stem#+2appr#, 0, dh#);
  "extensible left filet";
  pickup fine.nib;
  y1r = y1l = 0; y5r = y5l = -d;
  forsuffixes $ = r, l: y2$ = 0.25[y1r, y5r];
    y3$ = 0.5[y1r, y5r]; y4$ = 0.75[y1r, y5r]; endfor
  x1l = x5l = x4r = good.x 0.5w;
  x1l-lft x3l = rt x2r-x4r = 2stem;
  x2l = x4l = 0.5[x1l, x3l]; x1r = x3r = x5r = 0.5[x2r, x4r];
  filldraw z1l{down}...z2l{(z3l-z1l)xscaled 2}...z3l{down}
  ...z4l{(z5l-z3l)xscaled 2}...z5l{down}--
  z5r{(z4r-z5r)xscaled 2}...z4r{up}...
  z3r{(z2r-z3r)xscaled 2}...z2r{up}...
  z1r{(z1r-z2r)xscaled 2}--cycle;
  penlabels(1, 2, 3, 4, 5);
endchar;

beginchar(right_filet, 4stem#+2appr#, 0, dh#);
  "extensible right filet";
  pickup fine.nib;
  y1r = y1l = 0; y5r = y5l = -d;
  forsuffixes $ = r, l: y2$ = 0.25[y1r, y5r];
    y3$ = 0.5[y1r, y5r]; y4$ = 0.75[y1r, y5r]; endfor
  x1r = x5r = x2l = good.x 0.5w;
  x2l-lft x4l = rt x3r-x1r = 2stem;
  x1l = x3l = x5l = 0.5[x2l, x4l]; x2r = x4r = 0.5[x1r, x3r];
  filldraw z1r{down}...z2r{(z3r-z1r)xscaled 2}...z3r{down}
  ...z4r{(z5r-z3r)xscaled 2}...z5r{down}--
  z5l{(z4l-z5l)xscaled 2}...z4l{up}...
  z3l{(z2l-z3l)xscaled 2}...z2l{up}...
  z1l{(z1l-z2l)xscaled 2}--cycle;
  penlabels(1, 2, 3, 4, 5);
endchar;

% HORIZONTAL BRACES (almost okay,  check xdvi problems)

beginchar(overbrace_left, 0.75dh#+appr#, cap_stem#, dh#);
  "overbrace's left piece";
  pickup fine.nib;
  pos1(rth1, 180); pos2(cap_stem, 90);
  bot y2l = vround (0.5[-d, h]-0.5cap_stem);
  bot y1r = vround(y2-min(5u, 0.4dh+0.5cap_stem));
  lft x1r = appr; x2 = w+eps;
  filldraw stroke z1e up_to_right z2e;
  penlabels(1, 2);
endchar;

beginchar(overbrace_mid, 1.5dh#, cap_stem#, dh#);
  "overbrace's middle piece";
  pickup fine.nib;
  pos1(cap_stem, -90); pos2(rth1, 0); pos3(cap_stem, 90);
  bot y1r = bot y3l = vround (0.5[-d, h]-0.5cap_stem);
  top y2 = vround(y3+min(5u, 0.4dh+0.5cap_stem));
  x2 = hround 0.5(w-rth1); x1 = -eps; x3 = w+eps;
  filldraw stroke z1e right_to_down z2e;
  filldraw stroke z3e left_to_down z2e;
  penlabels(1, 2, 3);
endchar;

beginchar(overbrace_right, 0.75dh#+appr#, cap_stem#, dh#);
  "overbrace's right piece";
  pickup fine.nib;
  pos1(rth1, 0); pos2(cap_stem, 90);
  bot y2l = vround (0.5[-d, h]-0.5cap_stem);
  bot y1r = vround(y2-min(5u, 0.4dh+0.5cap_stem));
  rt x1r = w-appr; x2 = -eps;
  filldraw stroke z1e up_to_left z2e;
  penlabels(1, 2);
endchar;

% 4u# ???
beginchar(overbrace_mod, 0.5dh#, cap_stem#, dh#);
  "overbrace's module piece";
  pickup fine.nib;
  pos1(cap_stem, 90); pos2(cap_stem, 90);
  bot y1l = bot y2l = vround (0.5[-d, h]-0.5cap_stem);
  x1 = -eps; x2 = w+eps;
  filldraw stroke z1e..z2e; penlabels(1, 2);
endchar;

beginchar(underbrace_left, 0.75dh#+appr#, cap_stem#, dh#);
  "underbrace's left piece";
  pickup fine.nib;
  pos1(rth1, 0); pos2(cap_stem, 90);
  bot y2l = vround (0.5[-d, h]-0.5cap_stem);
  top y1l = vround(y2+min(5u, 0.4dh+0.5cap_stem));
  lft x1l = appr; x2 = w+eps;
  filldraw stroke z1e down_to_right z2e;
  penlabels(1, 2);
endchar;

beginchar(underbrace_mid, 1.5dh#, cap_stem#, dh#);
  "underbrace's middle piece";
  pickup fine.nib;
  pos1(cap_stem, 90); pos2(rth1, 0); pos3(cap_stem, -90);
  bot y1l = bot y3r = vround (0.5[-d, h]-0.5cap_stem);
  bot y2 = vround(y3-min(5u, 0.4dh+0.5cap_stem));
  x2 = hround 0.5(w-rth1); x1 = -eps; x3 = w+eps;
  filldraw stroke z1e right_to_down z2e;
  filldraw stroke z3e left_to_down z2e;
  penlabels(1, 2, 3);
endchar;

beginchar(underbrace_right, 0.75dh#+appr#, cap_stem#, dh#);
  "underbrace's right piece";
  pickup fine.nib;
  pos1(rth1, 180); pos2(cap_stem, 90);
  bot y2l = vround (0.5[-d, h]-0.5cap_stem);
  top y1l = vround(y2+min(5u, 0.4dh+0.5cap_stem));
  rt x1l = w-appr; x2 = -eps;
  filldraw stroke z1e down_to_left z2e;
  penlabels(1, 2);
endchar;

% 4u# ???
beginchar(underbrace_mod, 0.5dh#, cap_stem#, dh#);
  "underbrace's module piece";
  pickup fine.nib;
  pos1(cap_stem, 90); pos2(cap_stem, 90);
  bot y1l = bot y2l = vround (0.5[-d, h]-0.5cap_stem);
  x1 = -eps; x2 = w+eps;
  filldraw stroke z1e..z2e; penlabels(1, 2);
endchar;

% RADICALS
rth := ceiling(rth.frac#*hppp);

vardef tmp_program =
% imperative coordinates
  save a, b, c, f, sl; a = 2.75; b = 1.25;% slope factors
  pickup crisp.nib; x1' = w; lft x5l = appr;
  top y1r = h; y1' = h-0.5rth; bot y2r = bot y3r = -d-eps;
  top y4l = vround 0.5[-d, h]+o; y5l = good.y 0.75[y2r, y4l];
% numerical calculus
  c = a*(y4l-y5l)+b*(y4l-y2r)+y1'-y2r;
  vardef f(expr sl) =
    sl*c-(1++(b*sl))*(curve-crisp)+0.5(rth-crisp)*(1+(1++sl))<x1'-x5l
  enddef;
  sl = solve f(0, (x1'-x5l)/(y1'-y5l));
% setting other key points
  x4l = good.x(x5l+a*sl*(y4l-y5l));
  x2r = good.x(x1'-sl*(y1'-y2r)+0.5(rth-crisp)*(1++sl));
  penpos1((rth-crisp)*(1++sl), 0);
  pos5(min(hair, rth), angle(z4l-z5l)-90);
  rt x2r-lft x3r = rth; z1r-z2r = whatever*(sl, 1);
  adjust_slanted_bar(3r, 4l, 3, 4)(curve-crisp, -1);
  z1l-z2l = whatever*(z1r-z2r); z2l = whatever[z3, z4l];
  z4r-z5r = whatever*(z4l-z5l); z4r = whatever[z3r, z4];
  z3l = 0.5[z2l, z4l];% it's not an interesting point
  filldraw stroke z1e--z2e--z3e--z4e--z5e;
  penlabels(1, 2, 3, 4, 5); labels(1');
enddef;

beginchar(radical_sign,
    15u#+letter_fit#, rth.frac#, body_height#+paren_depth#-rth.frac#);
  "radical sign";
  tmp_program;
endchar;

beginchar(radical_big,
    18u#+letter_fit#, rth.frac#, 2dh#-rth.frac#);
  "big radical sign";
  tmp_program;
endchar;

beginchar(radical_Big,
    18u#+letter_fit#, rth.frac#, 3dh#-rth.frac#);
  "Big radical sign";
  tmp_program;
endchar;

beginchar(radical_bigg,
    18u#+letter_fit#, rth.frac#, 4dh#-rth.frac#);
  "bigg radical sign";
  tmp_program;
endchar;

beginchar(radical_Bigg,
    18u#+letter_fit#, rth.frac#, 5dh#-rth.frac#);
  "Bigg radical sign";
  tmp_program;
endchar;

beginchar(radical_bot, 19u#+letter_fit#, 0, 3dh#);
  "Extensible radical sign---bottom";
  % imperative coordinates
  save a, b, c, f, sl; a = 1; b = 1;% slope factors
  pickup crisp.nib;
  rt x1r = rt x2r = hround(w-6u+0.5rth); lft x5l = appr;
  top y1r = h+1+eps; bot y2r = bot y3r = -d-eps;
  top y4l = vround 0.9[-d, h]+o; y5l = good.y 0.75[y2r, y4l];
% numerical calculus
  c = a*(y4l-y5l)+b*(y4l-y2r);
  vardef f(expr sl) =
    sl*c-(1++(b*sl))*(curve-crisp)+0.5(rth-crisp)<x1r-x5l
  enddef;
  sl = solve f(0, (x1r-x5l)/(y1r-y5l));
% setting other key points
  x4l = good.x(x5l+a*sl*(y4l-y5l)); x3r = x1l;
  pos1(rth, 0); pos5(min(hair, rth), angle(z4l-z5l)-90);
  adjust_slanted_bar(3r, 4l, 3, 4)(curve-crisp, -1);
  z1l-z2l = whatever*(z1r-z2r); z2l = whatever[z3, z4l];
  z4r-z5r = whatever*(z4l-z5l); z4r = whatever[z3r, z4];
  z3l = 0.5[z2l, z4l];% it's not an interesting point
  filldraw stroke z1e--z2e--z3e--z4e--z5e;
  penlabels(1, 2, 3, 4, 5);
endchar;

beginchar(radical_mod, 19u#+letter_fit#, 0, dh#);
  "Extensible radical sign---module";
  pickup crisp.nib; rt x1r = rt x2r = hround(w-6u+0.5rth);
  y1 = h+1+eps; y2 = -d-1-eps; pos1(rth, 0); pos2(rth, 0);
  filldraw stroke z1e..z2e; penlabels(1, 2);
endchar;

beginchar(radical_top, 19u#+letter_fit#, rth.frac#, dh#-rth.frac#);
  "Extensible radical sign---top";
  pickup crisp.nib; rt x3r = rt x2r = hround(w-6u+0.5rth);
  x1 = good.x(w+0.5); bot y1r = bot y2r = 0; y3 = -d-1-eps;
  x2l = x3l; y1l = y2l; pos1(rth, -90); pos3(rth, 0);
  filldraw stroke z1e--z2e--z3e; penlabels(1, 2, 3);
endchar;

beginchar(group_left,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Left group";
  a := hround 0[0.95stem, 0.95cap_stem];
  pickup fine.nib;
  top y1l = h; bot y4l = -d;
  y2 = 0.75[y4r, y1r]; y3 = 0.25[y4r, y1r];
  rt x1 = rt x4 = w-internal_adjustment;
  lft x2l = lft x3l = external_adjustment;
  pos1(rth0, -90); pos2(a, 0); pos3(a, 0); pos4(rth0, 90);
  filldraw stroke z1e left_to_down
  z2e..z3e down_to_right z4e;
  penlabels(1, 2, 3, 4);
endchar;

beginchar(group_left_big,
    set_width(4.5u#, 0.4u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big left group";
  a := hround 0.125[0.95stem, 0.95cap_stem];
  pickup fine.nib;
  top y1l = h; bot y4l = -d;
  y2 = 0.75[y4r, y1r]; y3 = 0.25[y4r, y1r];
  rt x1 = rt x4 = w-internal_adjustment;
  lft x2l = lft x3l = external_adjustment;
  pos1(rth0, -90); pos2(a, 0); pos3(a, 0); pos4(rth0, 90);
  filldraw stroke z1e left_to_down
  z2e..z3e down_to_right z4e;
  penlabels(1, 2, 3, 4);
endchar;

beginchar(group_right,
    set_width(4u#, 0.2u#, 2u#), body_height#, paren_depth#);
  "Right group";
  a := hround 0[0.95stem, 0.95cap_stem];
  pickup fine.nib;
  top y1r = h; bot y4r = -d;
  y2 = 0.75[y4l, y1l]; y3 = 0.25[y4l, y1l];
  lft x1 = lft x4 = internal_adjustment;
  rt x2r = rt x3r = w-external_adjustment;
  pos1(rth0, 90); pos2(a, 0); pos3(a, 0); pos4(rth0, -90);
  filldraw stroke z1e right_to_down
  z2e..z3e down_to_left z4e;
  penlabels(1, 2, 3, 4);
endchar;

beginchar(group_right_big,
    set_width(4.5u#, 0.4u#, 2.5u#), rth.frac#, 2dh#-rth.frac#);
  "big right group";
  a := hround 0.125[0.95stem, 0.95cap_stem];
  pickup fine.nib;
  top y1r = h; bot y4r = -d;
  y2 = 0.75[y4l, y1l]; y3 = 0.25[y4l, y1l];
  lft x1 = lft x4 = internal_adjustment;
  rt x2r = rt x3r = w-external_adjustment;
  pos1(rth0, 90); pos2(a, 0); pos3(a, 0); pos4(rth0, -90);
  filldraw stroke z1e right_to_down
  z2e..z3e down_to_left z4e;
  penlabels(1, 2, 3, 4);
endchar;