%PDF- %PDF-
Mini Shell

Mini Shell

Direktori : /data/old/usr/share/texlive/texmf-dist/fonts/source/public/mnsymbol/
Upload File :
Create Path :
Current File : //data/old/usr/share/texlive/texmf-dist/fonts/source/public/mnsymbol/Sym-Order.mf

% There are some additional order glyphs in Sym-Geometric. Keep them consistent!

vardef ifneg(text values) =
  select(negated)(values)
enddef;

% equal signs

if negated < 2:
  beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + rule_thickness#); "equal";
    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    draw z0 -- z2;
    draw z1 -- z3;

    if negated = 1:
      stroke_through(centre, 3equal_spread);
    fi;
  endchar;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#, ifneg(2,4) * equal_spread# + rule_thickness#); "equiv";
    pickup rule_pen;

    z2 - z1 = z1 - z0 = equal_spread * dir 90;
    z5 - z4 = z4 - z3 = equal_spread * dir 90;

    1/2[z0, z2] = left_point;
    1/2[z3, z5] = right_point;

    draw z0 -- z3;
    draw z1 -- z4;
    draw z2 -- z5;

    if negated = 1:
      stroke_through(centre, 4equal_spread);
    fi;
  endchar;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#, ifneg(2/3, 8/3)*equal_spread# + rule_thickness#); "sim";
      pickup rule_pen;

      draw sim(left_point, right_point);

      if negated = 1:
        stroke_through(centre, 8/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#);
      "approx";

      pickup rule_pen;

      draw sim(left_point + 1/2equal_spread * dir 90, right_point + 1/2equal_spread * dir 90);
      draw sim(left_point - 1/2equal_spread * dir 90, right_point - 1/2equal_spread * dir 90);

      if negated = 1:
        stroke_through(centre, 11/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
      "triple sim";

      pickup rule_pen;

      draw sim(left_point + equal_spread * dir 90, right_point + equal_spread * dir 90);
      draw sim(left_point,                         right_point);
      draw sim(left_point - equal_spread * dir 90, right_point - equal_spread * dir 90);

      if negated = 1:
        stroke_through(centre, 14/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#);
      "sim equal";

      pickup rule_pen;

      draw sim(left_point + 1/2equal_spread * dir 90, right_point + 1/2equal_spread * dir 90);
      draw (left_point - 5/6equal_spread * dir 90) -- (right_point - 5/6equal_spread * dir 90);

      if negated = 1:
        stroke_through(centre, 11/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#); "equal sim";
      pickup rule_pen;

      draw (left_point + 5/6equal_spread * dir 90) -- (right_point + 5/6equal_spread * dir 90);
      draw sim(left_point - 1/2equal_spread * dir 90, right_point - 1/2equal_spread * dir 90);

      if negated = 1:
        stroke_through(centre, 11/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#); "cong";
      pickup rule_pen;

      draw sim(left_point + equal_spread * dir 90, right_point + equal_spread * dir 90);
      draw (left_point - 1/3equal_spread * dir 90) -- (right_point - 1/3equal_spread * dir 90);
      draw (left_point - 4/3equal_spread * dir 90) -- (right_point - 4/3equal_spread * dir 90);

      if negated = 1:
        stroke_through(centre, 14/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
      "approx equal";

      pickup rule_pen;

      draw sim(left_point + equal_spread * dir 90, right_point + equal_spread * dir 90);
      draw sim(left_point,                         right_point);
      draw (left_point - 4/3equal_spread * dir 90) -- (right_point - 4/3equal_spread * dir 90);

      if negated = 1:
        stroke_through(centre, 14/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + 2/5order_width# + rule_thickness#);
    "bump equal";

    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    draw z0 -- z2;
    draw z3 -- half_circle(1/2[z1,z3], order_width/5, 0) -- z1;

    if negated = 1:
      stroke_through(centre, 3equal_spread + 2/5order_width);
    fi;
  endchar;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + 2/5order_width# + rule_thickness#);
    "equal bump";

    pickup rule_pen;

    z0 - z1 = equal_spread * dir 90;
    z2 - z3 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    draw z0 -- z2;
    draw z1 -- half_circle(1/2[z1,z3], order_width/5, 180) -- z3;

    if negated = 1:
      stroke_through(centre, 3equal_spread + 2/5order_width);
    fi;
  endchar;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + 2/5order_width# + rule_thickness#);
    "double bump equal";

    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    draw z0 -- half_circle(1/2[z0,z2], order_width/5, 180) -- z2;
    draw z3 -- half_circle(1/2[z1,z3], order_width/5, 0) -- z1;

    if negated = 1:
      stroke_through(centre, 3equal_spread + 2/5order_width);
    fi;
  endchar;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#,
                3equal_spread# + ifneg(2dot_size#, equal_spread# + rule_thickness#));
    "dot equal";

    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    draw z0 -- z2;
    draw z1 -- z3;
    fill circle(centre + 3/2equal_spread * dir 90, dot_size);

    if negated = 1:
      stroke_through(centre, 4equal_spread);
    fi;
  endchar;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#,
                3equal_spread# + ifneg(2dot_size#, equal_spread# + rule_thickness#));
    "equal dot";

    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    draw z0 -- z2;
    draw z1 -- z3;
    fill circle(centre - 3/2equal_spread * dir 90, dot_size);

    if negated = 1:
      stroke_through(centre, 4equal_spread);
    fi;
  endchar;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#,
                3equal_spread# + ifneg(2dot_size#, equal_spread# + rule_thickness#));
    "dot equal dot";

    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    draw z0 -- z2;
    draw z1 -- z3;
    fill circle(centre + 3/2equal_spread * dir 90, dot_size);
    fill circle(centre - 3/2equal_spread * dir 90, dot_size);

    if negated = 1:
      stroke_through(centre, 4equal_spread);
    fi;
  endchar;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     3equal_spread# + ifneg(2dot_size#, equal_spread# + rule_thickness#));
      "falling dot equal";

      pickup rule_pen;

      z1 - z0 = equal_spread * dir 90;
      z3 - z2 = equal_spread * dir 90;

      1/2[z0, z1] = left_point;
      1/2[z2, z3] = right_point;

      draw z0 -- z2;
      draw z1 -- z3;
      fill circle(left_point  + 3/2equal_spread * dir 90, dot_size);
      fill circle(right_point - 3/2equal_spread * dir 90, dot_size);

      if negated = 1:
        stroke_through(centre, 4equal_spread);
      fi;
    endchar;
  endfor;
fi;

for round_smile = true, false:

  if negated < 2:
    for sign = 1, -1:
      beginorder(1, order_width# + rule_thickness#, ifneg(2/3, 8/3) * equal_spread# + rule_thickness#);
        "smile";

        pickup rule_pen;

        draw smile(sign, left_point, right_point, 2/3equal_spread, round_smile);

        if negated = 1:
          stroke_through(centre, 8/3equal_spread);
        fi;
      endchar;
    endfor;
  fi;

  if negated < 2:
    for sign = 1, -1:
      beginorder(1, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#); "double smile";
        pickup rule_pen;

        s := 1/2equal_spread;

        draw smile(sign, left_point + s * dir 90, right_point + s * dir 90, 2/3equal_spread, round_smile);
        draw smile(sign, left_point - s * dir 90, right_point - s * dir 90, 2/3equal_spread, round_smile);

        if negated = 1:
          stroke_through(centre, 11/3equal_spread);
        fi;
      endchar;
    endfor;
  fi;

  if negated < 2:
    for sign = 1, -1:
      beginorder(1, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#); "triple smile";
        pickup rule_pen;

        s := equal_spread;

        draw smile(sign, left_point + s * dir 90, right_point + s * dir 90, 2/3equal_spread, round_smile);
        draw smile(sign, left_point,              right_point,              2/3equal_spread, round_smile);
        draw smile(sign, left_point - s * dir 90, right_point - s * dir 90, 2/3equal_spread, round_smile);

        if negated = 1:
          stroke_through(centre, 14/3equal_spread);
        fi;
      endchar;
    endfor;
  fi;

  if negated < 2:
    for sign = 1, -1:
      beginorder(1, order_width# + rule_thickness#, ifneg(7/3, 13/3) * equal_spread# + rule_thickness#); "smile frown";
        pickup rule_pen;

        s := 5/6equal_spread;

        draw smile(sign,  left_point + s * dir 90, right_point + s * dir 90, 2/3equal_spread, round_smile);
        draw smile(-sign, left_point - s * dir 90, right_point - s * dir 90, 2/3equal_spread, round_smile);

        if negated = 1:
          stroke_through(centre, 13/3equal_spread);
        fi;
      endchar;
    endfor;
  fi;

  if negated < 2:
    for sign = 1, -1:
      beginorder(1, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#); "smile equal";
        pickup rule_pen;

        s := 1/6equal_spread;

        draw smile(sign, left_point + 3s * dir 90, right_point + 3s * dir 90, 2/3equal_spread, round_smile);
        draw (left_point - 5s * dir 90) -- (right_point - 5s * dir 90);

        if negated = 1:
          stroke_through(centre, 11/3equal_spread);
        fi;
      endchar;
    endfor;
  fi;

  if negated < 2:
    for sign = 1, -1:
      beginorder(1, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#); "equal smile";
        pickup rule_pen;

        s := 1/6equal_spread;

        draw (left_point + 5s * dir 90) -- (right_point + 5s * dir 90);
        draw smile(sign, left_point - 3s * dir 90, right_point - 3s * dir 90, 2/3equal_spread, round_smile);

        if negated = 1:
          stroke_through(centre, 11/3equal_spread);
        fi;
      endchar;
    endfor;
  fi;

  if negated < 2:
    for sign = 1, -1:
      beginorder(1, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
        "double smile equal";

        pickup rule_pen;

        s := 1/6equal_spread;

        draw smile(sign, left_point + 6s * dir 90, right_point + 6s * dir 90, 2/3equal_spread, round_smile);
        draw smile(sign, left_point,               right_point,               2/3equal_spread, round_smile);
        draw (left_point - 8s * dir 90) -- (right_point - 8s * dir 90);

        if negated = 1:
          stroke_through(centre, 14/3equal_spread);
        fi;
      endchar;
    endfor;
  fi;

  if negated < 2:
    for sign = 1, -1:
      beginorder(1, order_width# + rule_thickness#, ifneg(10/3, 16/3) * equal_spread# + rule_thickness#);
        "smile equal frown";

        pickup rule_pen;

        s := 4/3equal_spread;

        draw smile(sign,  left_point + s * dir 90, right_point + s * dir 90, 2/3equal_spread, round_smile);
        draw left_point -- right_point;
        draw smile(-sign, left_point - s * dir 90, right_point - s * dir 90, 2/3equal_spread, round_smile);

        if negated = 1:
          stroke_through(centre, 16/3equal_spread);
        fi;
      endchar;
    endfor;
  fi;

  % Only the round version since we have no free glyphs left.
  if round_smile and (negated < 2):
    for sign = 1, -1:
      beginorder(1, order_width# + rule_thickness#, ifneg(10/3, 16/3) * equal_spread# + rule_thickness#);
        "smile frown equal";

        pickup rule_pen;

        s := 1/6equal_spread;

        draw smile(sign,  left_point + 8s * dir 90, right_point + 8s * dir 90, 2/3equal_spread, round_smile);
        draw smile(-sign, left_point - 1s * dir 90, right_point - 1s * dir 90, 2/3equal_spread, round_smile);
        draw (left_point - 10s * dir 90) -- (right_point - 10s * dir 90);

        if negated = 1:
          stroke_through(centre, 16/3equal_spread);
        fi;
      endchar;
    endfor;
fi;

endfor;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + rule_thickness#);
    "equal circled";

    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    draw z0 -- z2;
    draw z1 -- z3;

    pickup pencircle scaled 3/4rule_thickness;

    draw circle(centre, 1/2equal_spread);

    if negated = 1:
      stroke_through(centre, 3equal_spread);
    fi;
  endchar;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#, 3equal_spread# + 7/2dot_size# + rule_thickness#);
    "circ equal";

    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    draw z0 -- z2;
    draw z1 -- z3;

    pickup pencircle scaled 3/4rule_thickness;

    draw circle(centre + 3/2equal_spread * dir 90,
                min (7/4dot_size, equal_spread - 3/4rule_thickness));

    if negated = 1:
      stroke_through(centre, 3equal_spread + 7/2dot_size);
    fi;
  endchar;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#, 3equal_spread# + 7/2dot_size# + rule_thickness#);
    "triangle equal";

    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    x4 = xpart centre;
    y4 = y5 + sind 60 * (x6 - x5) = h - 1/2rule_thickness;

    y5 = y6;
    1/2[x5, x6] = xpart centre;

    y5 - y1 = 2/3equal_spread;

    draw z0 -- z2;
    draw z1 -- z3;

    pickup pencircle scaled 3/4rule_thickness;

    draw z4 -- z5 -- z6 -- cycle;

    if negated = 1:
      stroke_through(centre, 3equal_spread + 7/2dot_size);
    fi;
  endchar;
fi;

if negated < 2:
  beginorder(1, order_width# + rule_thickness#, 5/2equal_spread# + 7/2dot_size# + rule_thickness#);
    "hat equal";

    pickup rule_pen;

    z1 - z0 = equal_spread * dir 90;
    z3 - z2 = equal_spread * dir 90;

    1/2[z0, z1] = left_point;
    1/2[z2, z3] = right_point;

    x4 = xpart centre;
    y4 = y5 + sind 30 * (x6 - x5) = h - 1/2rule_thickness;

    y5 = y6;
    1/2[x5, x6] = xpart centre;

    y5 - y1 = 2/3equal_spread;

    draw z0 -- z2;
    draw z1 -- z3;
    draw z6 -- z4 -- z5;

    if negated = 1:
      stroke_through(centre, 3equal_spread + 7/2dot_size);
    fi;
  endchar;
fi;

% element signs

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, 17/24order_width# + rule_thickness#,
                     ifneg(0,2) * equal_spread# + 8/9[equal_spread#, greater_spread#] + rule_thickness#);
      "element";

      pickup rule_pen;

      s := 8/9[equal_spread, greater_spread];

      z1 - z0 = s * dir 90;
      1/2[z0, z1] = right_point;
      z3 - z2 = s * dir 90;
      1/2[z2, z3] = 7/10[left_point,right_point];

      draw z0 -- z2{left_point - right_point} .. left_point .. {right_point - left_point}z3 -- z1;
      draw left_point -- right_point;

      if negated = 1:
        stroke_through(centre, 2equal_spread + 8/9[equal_spread, greater_spread]);
      fi;
    endchar;
  endfor;
fi;

% orderings

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
      "less than";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;

      1/2[z0, z1] = right_point;

      draw z0 -- left_point -- z1;

      if negated = 1:
        stroke_through(centre, 2equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     greater_spread# + ifneg(2/3, 8/3) * equal_spread# + rule_thickness#);
      "less than or equal";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;
      y2 = 1/2[y0, y1];
      x2 = x3 = xpart left_point;
      y3 = y4;
      z0 - z4 = 2/3equal_spread * dir 90;

      1/2[z1, z4] = right_point;

      draw z0 -- z2 -- z1;
      draw z3 -- z4;

      if negated = 1:
        stroke_through(centre, 8/3equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
      greater_spread# + ifneg(1,3) * equal_spread# + rule_thickness#);
      "less than or slanted equal";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;
      z2 - z3 = equal_spread * dir 90;
      z0 - z4 = equal_spread * dir 90;

      1/2[z2, z3] = left_point;
      1/2[z1, z4] = right_point;

      draw z0 -- z2 -- z1;
      draw z3 -- z4;

      if negated = 1:
        stroke_through(centre, 3equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 3:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
      greater_spread# + ifneg(5/3, 11/3, 11/3) * equal_spread# + rule_thickness#);
      "less than or double equal";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;
      y2 = 1/2[y0, y1];
      x2 = x3 = x5 = xpart left_point;
      y3 = y4;
      z0 - z4 = 2/3equal_spread * dir 90;
      y5 = y6;
      z4 - z6 = equal_spread * dir 90;

      1/2[z1, z6] = right_point;

      draw z0 -- z2 -- z1;
      draw z3 -- z4;
      draw z5 -- z6;

      if negated = 1:
        stroke_through(centre, 11/3equal_spread + greater_spread);
      elseif negated = 2:
        stroke_through(1/2[1/2[z3,z4], 1/2[z5,z6]], 3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
      3/2greater_spread# + ifneg(1,3) * equal_spread# + rule_thickness#);
      "less greater";

      pickup rule_pen;

      y1 - y0 = greater_spread;
      y2 - y3 = equal_spread;
      y0 - y4 = equal_spread;
      y3 - y5 = greater_spread;

      x2 = x3 = x5 = xpart left_point;
      x0 = x1 = x4 = xpart right_point;

      y2 = 1/2[y0, y1];

      1/2[y1, y5] = ypart centre;

      draw z0 -- z2 -- z1;
      draw z3 -- z4 -- z5;

      if negated = 1:
        stroke_through(centre, 3equal_spread + 3/2greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     2greater_spread# + ifneg(4/3, 10/3) * equal_spread# + rule_thickness#);
      "less equal greater";

      pickup rule_pen;

      y2 - y0 = greater_spread;
      x0 = x2 = xpart right_point;

      y1 = 1/2[y0, y2];
      x1 = xpart left_point;

      y5 - y3 = greater_spread;
      x3 = x5 = xpart left_point;

      y4 = 1/2[y3, y5];
      x4 = xpart right_point;

      y0 - y5 = 4/3equal_spread;

      1/2[y0, y5] = ypart centre;

      draw z0 -- z1 -- z2;
      draw z3 -- z4 -- z5;
      draw left_point -- right_point;

      if negated = 1:
        stroke_through(centre, 10/3equal_spread + 2greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 3:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     2greater_spread# + ifneg(7/3, 13/3, 13/3) * equal_spread# + rule_thickness#);
      "less double equal greater";

      pickup rule_pen;

      y2 - y0 = greater_spread;
      x0 = x2 = xpart right_point;

      y1 = 1/2[y0, y2];
      x1 = xpart left_point;

      y5 - y3 = greater_spread;
      x3 = x5 = xpart left_point;

      y4 = 1/2[y3, y5];
      x4 = xpart right_point;

      y0 - y5 = 7/3equal_spread;

      1/2[y0, y5] = ypart centre;

      1/2[z6, z7] = left_point;
      1/2[z8, z9] = right_point;

      z7 - z6 = equal_spread * dir 90;
      z9 - z8 = equal_spread * dir 90;

      draw z0 -- z1 -- z2;
      draw z3 -- z4 -- z5;
      draw z6 -- z8;
      draw z7 -- z9;

      if negated = 1:
        stroke_through(centre, 13/3equal_spread + 2greater_spread);
      elseif negated = 2:
        stroke_through(centre, 3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     3/2greater_spread# + ifneg(2,4) * equal_spread# + rule_thickness#);
      "less slanted equal greater";

      pickup rule_pen;

      y2 - y0 = greater_spread;
      x0 = x2 = xpart right_point;

      y1 = 1/2[y0, y2];
      x1 = xpart left_point;

      y5 - y3 = greater_spread;
      x3 = x5 = xpart left_point;

      y4 = 1/2[y3, y5];
      x4 = xpart right_point;

      z6 = 1/2[z1, z5];
      z7 = 1/2[z0, z4];

      y1 - y6 = equal_spread;

      1/2[y6, y7] = ypart centre;

      draw z0 -- z1 -- z2;
      draw z3 -- z4 -- z5;
      draw z6 -- z7;

      if negated = 1:
        stroke_through(centre, 4equal_spread + 3/2greater_spread);
      fi;
    endchar;
  endfor;
fi;


if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + 2equal_spread# + rule_thickness#,
                     ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
      "less less";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;
      z3 - z5 = greater_spread * dir 90;
      z2 = left_point;
      z4 - z2 = sign * 2equal_spread * dir 0;
      z3 - z1 = sign * 2equal_spread * dir 0;

      1/2[z3, z5] = right_point;

      draw z0 -- z2 -- z1;
      draw z3 -- z4 -- z5;

      if negated = 1:
        stroke_through(centre, 2equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + 4equal_spread# + rule_thickness#,
                     ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
      "less less less";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;
      z3 - z5 = greater_spread * dir 90;
      z6 - z8 = greater_spread * dir 90;
      z2 = left_point;
      z4 - z2 = sign * 2equal_spread * dir 0;
      z3 - z1 = sign * 2equal_spread * dir 0;
      z7 - z4 = sign * 2equal_spread * dir 0;
      z6 - z3 = sign * 2equal_spread * dir 0;

      1/2[z6, z8] = right_point;

      draw z0 -- z2 -- z1;
      draw z3 -- z4 -- z5;
      draw z6 -- z7 -- z8;

      if negated = 1:
        stroke_through(centre, 2equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
      "closed less than";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;

      1/2[z0, z1] = right_point;

      draw z0 -- left_point -- z1 -- cycle;

      if negated = 1:
        stroke_through(centre, 2equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     greater_spread# + ifneg(2/3, 8/3) * equal_spread# + rule_thickness#);
      "closed less than or equal";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;
      y2 = 1/2[y0, y1];
      x2 = x3 = xpart left_point;
      y3 = y4;
      z0 - z4 = 2/3equal_spread * dir 90;

      1/2[z1, z4] = right_point;

      draw z0 -- z2 -- z1 -- cycle;
      draw z3 -- z4;

      if negated = 1:
        stroke_through(centre, 8/3equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     1/2[equal_spread#, greater_spread#] + ifneg(0,2) * equal_spread# + rule_thickness#);
      "square subset";

      pickup rule_pen;

      z1 - z0 = 1/2[equal_spread, greater_spread] * dir 90;
      z3 - z2 = 1/2[equal_spread, greater_spread] * dir 90;

      1/2[z0, z1] = left_point;
      1/2[z2, z3] = right_point;

      draw z3 -- z1 -- z0 -- z2;

      if negated = 1:
        stroke_through(centre, 2equal_spread + 1/2[equal_spread, greater_spread]);
      fi;
    endchar;
  endfor;
fi;

if negated < 3:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     ifneg(1,3,3) * equal_spread# + 1/2[equal_spread#, greater_spread#] + rule_thickness#);
      "square subset equal";

      pickup rule_pen;

      z1 - z0 = 1/2[equal_spread, greater_spread] * dir 90;
      z3 - z2 = 1/2[equal_spread, greater_spread] * dir 90;

      1/2[z1, z4] = left_point;
      1/2[z3, z5] = right_point;

      y4 = y5 = y0 - equal_spread;
      x4 = x0;
      x5 = x2;

      draw z3 -- z1 -- z0 -- z2;
      draw z4 -- z5;

      if negated = 1:
        stroke_through(centre, 3equal_spread + 1/2[equal_spread, greater_spread]);
      elseif negated = 2:
        stroke_through(1/2[1/2[z0,z2], 1/2[z4,z5]], 3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 3:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     ifneg(2,4,4) * equal_spread# + 1/2[equal_spread#, greater_spread#] + rule_thickness#);
      "square subset double equal";

      pickup rule_pen;

      z1 - z0 = 1/2[equal_spread, greater_spread] * dir 90;
      z3 - z2 = 1/2[equal_spread, greater_spread] * dir 90;

      1/2[z1, z6] = left_point;
      1/2[z3, z7] = right_point;

      y4 = y5 = y0 - equal_spread;
      y6 = y7 = y4 - equal_spread;
      x4 = x6 = x0;
      x5 = x7 = x2;

      draw z3 -- z1 -- z0 -- z2;
      draw z4 -- z5;
      draw z6 -- z7;

      if negated = 1:
        stroke_through(centre, 4equal_spread + 1/2[equal_spread, greater_spread]);
      elseif negated = 2:
        stroke_through(1/2[1/2[z4,z5], 1/2[z6,z7]], 3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
      "double square subset";

      pickup rule_pen;

      z1 - z0 = equal_spread * dir 90;
      z3 - z2 = equal_spread * dir 90;

      1/2[z1, z0] = left_point + 3/4equal_spread * dir (90 - sign * 90);
      1/2[z3, z2] = right_point;

      z5 - z4 = 8/3equal_spread * dir 90;
      z7 - z6 = 8/3equal_spread * dir 90;

      1/2[z5, z4] = left_point;
      1/2[z7, z6] = right_point;

      draw z3 -- z1 -- z0 -- z2;
      draw z7 -- z5 -- z4 -- z6;

      if negated = 1:
        stroke_through(centre, 14/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     ifneg(0,2) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
      "subset";

      pickup rule_pen;

      draw subset(left_point, right_point, 2/3[equal_spread, greater_spread]);

      if negated = 1:
        stroke_through(centre, 2equal_spread + 2/3[equal_spread, greater_spread]);
      fi;
    endchar;
  endfor;
fi;

if negated < 3:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
               ifneg(1,3,3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
      "subset or equal";

      pickup rule_pen;

      t := 2/3[equal_spread, greater_spread];
      s := 1/2equal_spread + 1/2t;

      z1 - z0 = z3 - z2 = (t/2 + equal_spread) * dir 90;
      y0 = y2 = ypart centre - s;
      x0 = xpart left_point;
      x2 = xpart right_point;

      draw subset(z1, z3, t);
      draw z0 -- z2;

      if negated = 1:
        stroke_through(centre, 3equal_spread + 2/3[equal_spread, greater_spread]);
      elseif negated = 2:
        stroke_through(1/2[z0,z2] + 1/2equal_spread * dir 90, 3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 3:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
               ifneg(2,4,4) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
      "subset or double equal";

      pickup rule_pen;

      t := 2/3[equal_spread, greater_spread];
      s := 1/2t;

      z1 - z0 = z3 - z2 = (t/2 + equal_spread) * dir 90;
      y0 = y2 = ypart centre - s;
      x0 = xpart left_point;
      x2 = xpart right_point;

      z0 - z4 = z2 - z5 = equal_spread * dir 90;

      draw subset(z1, z3, t);
      draw z0 -- z2;
      draw z4 -- z5;

      if negated = 1:
        stroke_through(centre, 4equal_spread + 2/3[equal_spread, greater_spread]);
      elseif negated = 2:
        stroke_through(1/2[1/2[z0,z2], 1/2[z4,z5]], 3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
      "double subset";

      pickup rule_pen;

      draw subset(left_point + 3/4equal_spread * dir (90 - sign * 90), right_point,
                  equal_spread);
      draw subset(left_point, right_point, 8/3equal_spread);

      if negated = 1:
        stroke_through(centre, 14/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     ifneg(0,2) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
      "curly less than";

      pickup rule_pen;

      draw prec(left_point, right_point, 2/3[equal_spread, greater_spread]);

      if negated = 1:
        stroke_through(centre, 2equal_spread + 2/3[equal_spread, greater_spread]);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
               ifneg(2/3, 8/3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
      "curly less than or equal";

      pickup rule_pen;

      t := 2/3[equal_spread, greater_spread];
      s := 1/3equal_spread + 1/2t;

      z1 - z0 = z3 - z2 = (t/2 + 2/3equal_spread) * dir 90;
      y0 = y2 = ypart centre - s;
      x0 = xpart left_point;
      x2 = xpart right_point;

      draw prec(z1, z3, t);
      draw z0 -- z2;

      if negated = 1:
        stroke_through(centre, 8/3equal_spread + 2/3[equal_spread, greater_spread]);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
               ifneg(1,3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
      "curly less than or curly equal";

      pickup rule_pen;

      t := 2/3[equal_spread, greater_spread];

      z1 - z0 = equal_spread * dir 90;
      z4 - z2 = 7/5equal_spread * dir 90;
      z3 - z4 = t/2 * dir 90;
      y1 = y3;
      y4 = ypart centre - 1/2(t - equal_spread);
      x0 = xpart left_point;
      x2 = xpart right_point;

      path p;

      p = z0{z3 - z1} .. z2;

      v := xpart (p intersectiontimes (z4 -- (z4 + h * dir (270 - sign * 20))));

      draw prec(z1, z3, t);
      draw subpath (0,v) of p;

      if negated = 1:
        stroke_through(centre, 3equal_spread + 2/3[equal_spread, greater_spread]);
      fi;
    endchar;
  endfor;
fi;

if negated < 3:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
               ifneg(4/3, 10/3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
      "curly less sim";

      pickup rule_pen;

      t := 2/3[equal_spread, greater_spread];
      s := 1/3equal_spread + t/2;

      z1 - z0 = z3 - z2 = (t/2 + equal_spread) * dir 90;
      y0 = y2 = ypart centre - s;
      x0 = xpart left_point;
      x2 = xpart right_point;

      draw prec(z1, z3, t);

      if sign > 0:
        draw sim(z0, z2);
      else:
        draw sim(z2, z0);
      fi

      if negated = 1:
        stroke_through(centre, 10/3equal_spread + 2/3[equal_spread, greater_spread]);
      elseif negated = 2:
        stroke_through(1/2[z0,z2], 8/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 3:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
               ifneg(7/3, 13/3, 13/3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
      "curly less approx";

      pickup rule_pen;

      t := 2/3[equal_spread, greater_spread];
      s := -1/6equal_spread + t/2;

      z1 - z0 = z3 - z2 = (t/2 + equal_spread) * dir 90;
      y0 = y2 = ypart centre - s;
      x0 = xpart left_point;
      x2 = xpart right_point;

      z0 - z4 = z2 - z5 = equal_spread * dir 90;

      draw prec(z1, z3, t);

      if sign > 0:
        draw sim(z0, z2);
        draw sim(z4, z5);
      else:
        draw sim(z2, z0);
        draw sim(z5, z4);
      fi

      if negated = 1:
        stroke_through(centre, 13/3equal_spread + 2/3[equal_spread, greater_spread]);
      elseif negated = 2:
        stroke_through(1/2[1/2[z0,z2], 1/2[z4,z5]], 11/3equal_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
      "less than dot";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;

      1/2[z0, z1] = right_point;

      draw z0 -- left_point -- z1;
      fill circle(right_point - sign * dot_size * dir 0, dot_size);

      if negated = 1:
        stroke_through(centre, 2equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     greater_spread# + ifneg(2/3, 10/3) * equal_spread# + rule_thickness#);
      "less than or equal dot";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;
      y2 = 1/2[y0, y1];
      x2 = x3 = xpart left_point;
      y3 = y4;
      z0 - z4 = 2/3equal_spread * dir 90;

      1/2[z1, z4] = right_point;

      draw z0 -- z2 -- z1;
      draw z3 -- z4;
      fill circle(1/2[z0,z1] - sign * dot_size * dir 0, dot_size);

      if negated = 1:
        stroke_through(centre, 10/3equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

if negated < 2:
  for sign = 1, -1:
    beginorder(sign, order_width# + rule_thickness#,
                     greater_spread# + ifneg(1,3) * equal_spread# + rule_thickness#);
      "less than or slanted equal dot";

      pickup rule_pen;

      z1 - z0 = greater_spread * dir 90;
      z2 - z3 = equal_spread * dir 90;
      z0 - z4 = equal_spread * dir 90;

      1/2[z2, z3] = left_point;
      1/2[z1, z4] = right_point;

      draw z0 -- z2 -- z1;
      draw z3 -- z4;
      fill circle(1/2[z0,z1] - sign * dot_size * dir 0, dot_size);

      if negated = 1:
        stroke_through(centre, 3equal_spread + greater_spread);
      fi;
    endchar;
  endfor;
fi;

Zerion Mini Shell 1.0