%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-Arrows.mf

def ifneg(expr a,b) =
  if negated: a else: b fi
enddef;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "single arrow (" & decimal alpha & ")";
    pickup rule_pen;
    draw foot -- head;
    draw arrowhead(head, arrow_dir, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - 1/2arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 6/5, ifneg(19/10, 13/10) * arrow_spread#); "double arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = equal_spread * dir (arrow_dir + 90);

    1/2[z0,z1] = foot;
    1/2[z2,z3] = head;

    draw z0 -- arrowhead_intersection(head, arrow_dir, 13/10arrow_spread, z0 -- z2);
    draw z1 -- arrowhead_intersection(head, arrow_dir, 13/10arrow_spread, z1 -- z3);

    draw arrowhead(head, arrow_dir, 13/10arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - arrow_spread * dir arrow_dir], alpha, 19/10arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 6/5, ifneg(3/2, 1) * arrow_spread#); "bidirectinal arrow (" & decimal alpha & ")";
    pickup rule_pen;
    draw foot -- head;
    draw arrowhead(head, arrow_dir,     arrow_spread);
    draw arrowhead(foot, arrow_dir+180, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 7/5, ifneg(19/10, 13/10) * arrow_spread#); "double bidirectional arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = equal_spread * dir (arrow_dir + 90);

    1/2[z0,z1] = foot;
    1/2[z2,z3] = head;

    draw arrowhead_intersection(foot, arrow_dir+180, 13/10arrow_spread, z0 -- z2)
      -- arrowhead_intersection(head, arrow_dir,     13/10arrow_spread, z0 -- z2);
    draw arrowhead_intersection(foot, arrow_dir+180, 13/10arrow_spread, z1 -- z3)
      -- arrowhead_intersection(head, arrow_dir,     13/10arrow_spread, z1 -- z3);
    draw arrowhead(head, arrow_dir,     13/10arrow_spread);
    draw arrowhead(foot, arrow_dir+180, 13/10arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 19/10arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 5/4, ifneg(3/2, 1) * arrow_spread#); "double-head arrow (" & decimal alpha & ")";
    pickup rule_pen;
    draw foot -- head;
    draw arrowhead(head, arrow_dir, arrow_spread);
    draw arrowhead(head - 1/4arrow_len * dir arrow_dir, arrow_dir, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - (1/2arrow_spread + 1/4arrow_len) * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "tailed arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = foot + 3/4arrow_spread * dir arrow_dir;

    draw z0 -- head;
    draw arrowhead(head, arrow_dir, arrow_spread);
    draw arrowhead(z0,   arrow_dir, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "arrow with foot (" & decimal alpha & ")";
    pickup rule_pen;

    draw foot + 1/4rule_thickness * dir arrow_dir -- head;
    draw (foot - 1/2arrow_spread * dir (arrow_dir + 90)) --
         (foot + 1/2arrow_spread * dir (arrow_dir + 90));
    draw arrowhead(head, arrow_dir, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - 1/2arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "left embedding (" & decimal alpha & ")";
    pickup rule_pen;

    draw arrowhead(head, arrow_dir, arrow_spread);
    draw half_circle(foot + 1/4arrow_spread * (dir (arrow_dir + 90) + dir arrow_dir),
                     1/4arrow_spread, arrow_dir + 90)
         -- head;

    if negated:
      stroke_through_arrow(1/2[foot, head - 1/2arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "right embedding (" & decimal alpha & ")";
    pickup rule_pen;

    draw arrowhead(head, arrow_dir, arrow_spread);
    draw head -- half_circle(foot + 1/4arrow_spread * (dir (arrow_dir - 90) + dir arrow_dir),
                             1/4arrow_spread, arrow_dir + 90);

    if negated:
      stroke_through_arrow(1/2[foot, head - 1/2arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "left harpoon (" & decimal alpha & ")";
    pickup rule_pen;
    draw foot -- head;
    draw arrowhead_left(head, arrow_dir, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - 1/2arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "right harpoon (" & decimal alpha & ")";
    pickup rule_pen;
    draw foot -- head;
    draw arrowhead_right(head, arrow_dir, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - 1/2arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "left left harpoon (" & decimal alpha & ")";
    pickup rule_pen;
    draw foot -- head;
    draw arrowhead_left(head, arrow_dir,     arrow_spread);
    draw arrowhead_left(foot, arrow_dir+180, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread)
                          (80, 80, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "right right harpoon (" & decimal alpha & ")";
    pickup rule_pen;
    draw foot -- head;
    draw arrowhead_right(head, arrow_dir,     arrow_spread);
    draw arrowhead_right(foot, arrow_dir+180, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread)
                          (70, 70, 100, 100);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread# + equal_spread#); "double left left harpoon (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = equal_spread * dir (arrow_dir + 90);

    0.5[z0,z1] = foot;
    0.5[z2,z3] = head;

    draw z0 -- z2;
    draw z1 -- z3;
    draw arrowhead_left(z3, arrow_dir,     arrow_spread);
    draw arrowhead_left(z0, arrow_dir+180, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread + equal_spread)
                          (80, 80, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread# + equal_spread#); "double right right harpoon (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = equal_spread * dir (arrow_dir + 90);

    0.5[z0,z1] = foot;
    0.5[z2,z3] = head;

    draw z0 -- z2;
    draw z1 -- z3;
    draw arrowhead_right(z2, arrow_dir,     arrow_spread);
    draw arrowhead_right(z1, arrow_dir+180, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread + equal_spread)
                          (70, 70, 100, 100);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "broken arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = ifneg( 2/10, 3/10)[foot,head];
    z1 = ifneg(13/20,11/20)[foot,head];

    draw foot -- z0;
    draw z1 -- head;
    draw arrowhead(head, arrow_dir, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[z0, z1], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 6/5, ifneg(3/2, 1) * arrow_spread#); "multi map (" & decimal alpha & ")";
    pickup rule_pen;

    draw foot -- head - (4/5arrow_spread + 1/4rule_thickness) * dir arrow_dir;
    draw circle(head - 2/5arrow_spread * dir arrow_dir, 2/5arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - 4/5arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 6/5, ifneg(3/2, 1) * arrow_spread#); "filled multi map (" & decimal alpha & ")";
    pickup rule_pen;

    draw foot -- head - 2/5arrow_spread * dir arrow_dir;
    fill circle(head - 2/5arrow_spread * dir arrow_dir, 2/5arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - 4/5arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "line with foot (" & decimal alpha & ")";
    pickup rule_pen;

    draw foot -- head - 1/4rule_thickness * dir arrow_dir;
    draw (head - 1/2arrow_spread * dir (arrow_dir + 90)) --
         (head + 1/2arrow_spread * dir (arrow_dir + 90));

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, 2/3med_op_size#); "arrow with round head (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = head - 1/3equal_spread * dir arrow_dir;

    draw foot -- head - 1/4rule_thickness * dir arrow_dir;
    draw smile(1, z0 - 1/3med_op_size * dir (arrow_dir + 90),
                  z0 + 1/3med_op_size * dir (arrow_dir + 90),
                  2/3equal_spread, true);

    if negated:
      stroke_through_arrow(1/2[foot, head - 2/3equal_spread * dir arrow_dir], alpha, 2/3med_op_size)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, 3/4plus_size# + ifneg(1,0) * arrow_spread#); "pitchfork (" & decimal alpha & ")";
    pickup rule_pen;

    draw foot -- head;
    draw subset(foot + 3/4plus_size * dir arrow_dir, foot, 3/4plus_size);

    if negated:
      stroke_through_arrow(1/2[foot, head - 3/8plus_size * dir arrow_dir],
                           alpha, 3/4plus_size + arrow_spread)
                          (80, 80, 100, 100, 80, 80, 100, 100);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, 2arrow_spread#); "parallel arrows (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = arrow_spread * dir (arrow_dir + 90);

    0.5[z0,z1] = foot;
    0.5[z2,z3] = head;

    draw z0 -- z2;
    draw z1 -- z3;
    draw arrowhead(z2, arrow_dir, arrow_spread);
    draw arrowhead(z3, arrow_dir, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - 1/2arrow_spread * dir arrow_dir], alpha, 2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 1, 2arrow_spread#); "anti-parallel arrows right left (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = arrow_spread * dir (arrow_dir + 90);

    0.5[z0,z1] = foot;
    0.5[z2,z3] = head;

    draw z0 -- z2;
    draw z1 -- z3;
    draw arrowhead(z3, arrow_dir,     arrow_spread);
    draw arrowhead(z0, arrow_dir+180, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 2arrow_spread)
                          (80, 80, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 1, 2arrow_spread#); "anti-parallel arrows left right (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = arrow_spread * dir (arrow_dir + 90);

    0.5[z0,z1] = foot;
    0.5[z2,z3] = head;

    draw z0 -- z2;
    draw z1 -- z3;
    draw arrowhead(z2, arrow_dir,     arrow_spread);
    draw arrowhead(z1, arrow_dir+180, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 2arrow_spread)
                          (70, 70, 100, 100);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "left right wave arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = foot            - 1/10arrow_spread * dir (arrow_dir + 90);
    z1 = 15/80[foot,head] + 1/4arrow_spread * dir (arrow_dir + 90);
    z2 = 30/80[foot,head];
    z3 = 45/80[foot,head] - 1/4arrow_spread * dir (arrow_dir + 90);
    z4 = 60/80[foot,head];
    z5 = head            + 1/10arrow_spread * dir (arrow_dir + 90);

    draw z0{dir (arrow_dir + 45)} .. z1 .. z2{dir (arrow_dir - 45)} .. z3 .. z4 ... {dir (arrow_dir+15)}z5;
    draw arrowhead(z5, arrow_dir+15, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - 1/2arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (70, 70, 70, 70, 70, 70, 70, 70);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2, 1) * arrow_spread#); "right left wave arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = foot            + 1/10arrow_spread * dir (arrow_dir + 90);
    z1 = 15/80[foot,head] - 1/4arrow_spread * dir (arrow_dir + 90);
    z2 = 30/80[foot,head];
    z3 = 45/80[foot,head] + 1/4arrow_spread * dir (arrow_dir + 90);
    z4 = 60/80[foot,head];
    z5 = head            - 1/10arrow_spread * dir (arrow_dir + 90);

    draw z0{dir (arrow_dir - 45)} .. z1 .. z2{dir (arrow_dir + 45)} .. z3 .. z4 ... {dir (arrow_dir-15)}z5;
    draw arrowhead(z5, arrow_dir-15, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head - 1/2arrow_spread * dir arrow_dir], alpha, 3/2arrow_spread)
                          (110, 110, 110, 110, 110, 110, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 19/16, ifneg(3/2, 1) * arrow_spread#); "left right bidirectional wave arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = foot            - 1/10arrow_spread * dir (arrow_dir + 90);
    z1 =  4/20[foot,head];
    z2 =  7/20[foot,head] + 1/4arrow_spread * dir (arrow_dir + 90);
    z3 = 10/20[foot,head];
    z4 = 13/20[foot,head] - 1/4arrow_spread * dir (arrow_dir + 90);
    z5 = 16/20[foot,head];
    z6 = head            + 1/10arrow_spread * dir (arrow_dir + 90);

    draw z0{dir (arrow_dir + 15)} .. z1 .. z2 .. z3{dir (arrow_dir - 45)} .. z4 .. z5 ... {dir (arrow_dir+15)}z6;
    draw arrowhead(z0, arrow_dir + 195, arrow_spread);
    draw arrowhead(z6, arrow_dir +  15, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread)
                          (70, 70, 70, 70);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 19/16, ifneg(3/2, 1) * arrow_spread#); "right left bidirectional wave arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = foot            + 1/10arrow_spread * dir (arrow_dir + 90);
    z1 =  4/20[foot,head];
    z2 =  7/20[foot,head] - 1/4arrow_spread * dir (arrow_dir + 90);
    z3 = 10/20[foot,head];
    z4 = 13/20[foot,head] + 1/4arrow_spread * dir (arrow_dir + 90);
    z5 = 16/20[foot,head];
    z6 = head            - 1/10arrow_spread * dir (arrow_dir + 90);

    draw z0{dir (arrow_dir - 15)} .. z1 .. z2 .. z3{dir (arrow_dir + 45)} .. z4 .. z5 ... {dir (arrow_dir-15)}z6;
    draw arrowhead(z0, arrow_dir - 195, arrow_spread);
    draw arrowhead(z6, arrow_dir -  15, arrow_spread);

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread)
                          (110, 110, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2,10/9) * arrow_spread#); "right bend arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = foot           - 1/3arrow_spread * dir (arrow_dir + 90);
    z1 = 2/5[foot,head] + 1/3arrow_spread * dir (arrow_dir + 90);
    z2 = head           - 5/9arrow_spread * dir (arrow_dir + 90);

    draw z0 .. z1 .. z2;
    draw arrowhead(z2, arrow_dir - 55, arrow_spread);

    if negated:
      stroke_through_arrow(1/10[z1,z2], alpha, 3/2arrow_spread)
                          (80, 80, 80, 80, 80, 80, 80, 80);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2,10/9)*arrow_spread#); "left bend arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = foot           + 1/3arrow_spread * dir (arrow_dir + 90);
    z1 = 2/5[foot,head] - 1/3arrow_spread * dir (arrow_dir + 90);
    z2 = head           + 5/9arrow_spread * dir (arrow_dir + 90);

    draw z0 .. z1 .. z2;
    draw arrowhead(z2, arrow_dir + 55, arrow_spread);

    if negated:
      stroke_through_arrow(1/10[z1,z2], alpha, 3/2arrow_spread)
                          (110, 110, 110, 110, 110, 110, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(3/2,10/9)*arrow_spread#); "bend arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = foot           - 5/9arrow_spread * dir (arrow_dir + 90);
    z1 = 1/2[foot,head] + 1/3arrow_spread * dir (arrow_dir + 90);
    z2 = head           - 5/9arrow_spread * dir (arrow_dir + 90);

    draw z0 .. z1 .. z2;
    draw arrowhead(z0, arrow_dir + 240, arrow_spread);
    draw arrowhead(z2, arrow_dir -  60, arrow_spread);

    if negated:
      stroke_through_arrow(z1, alpha, 3/2arrow_spread)
                          (80, 80, 100, 100, 80, 80, 100, 100);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 1, ifneg(3/2,1) * arrow_spread#); "headless arrow (" & decimal alpha & ")";
    pickup rule_pen;
    draw foot -- head;

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 3/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 45, 135:
  beginarrow(alpha, 6/5, ifneg(19/10, 13/10) * arrow_spread#); "double headless arrow (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = equal_spread * dir (arrow_dir + 90);

    0.5[z0,z1] = foot;
    0.5[z2,z3] = head;

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

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 19/10arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 2/3, ifneg(2, 3/2) * arrow_spread#); "derives (" & decimal alpha & ")";
    pickup rule_pen;
    draw foot + 1/4rule_thickness * dir arrow_dir -- head;
    draw (foot - 3/4arrow_spread * dir (arrow_dir + 90)) --
         (foot + 3/4arrow_spread * dir (arrow_dir + 90));

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 2/3, ifneg(9/4, 7/4) * arrow_spread#); "models (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = equal_spread * dir (arrow_dir + 90);

    0.5[z0,z1] = foot;
    0.5[z2,z3] = head;

    draw z0 + 1/4rule_thickness * dir arrow_dir -- z2;
    draw z1 + 1/4rule_thickness * dir arrow_dir -- z3;
    draw (foot - 7/8arrow_spread * dir (arrow_dir + 90)) --
         (foot + 7/8arrow_spread * dir (arrow_dir + 90));

    if negated:
      stroke_through_arrow(1/2[foot, head], alpha, 9/4arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 5/6, ifneg(9/4, 7/4) * arrow_spread#); "forces (" & decimal alpha & ")";
    pickup rule_pen;

    z0 = foot + equal_spread * dir arrow_dir;

    draw z0 + 1/4rule_thickness * dir arrow_dir -- head;
    draw (foot - 7/8arrow_spread * dir (arrow_dir + 90)) --
         (foot + 7/8arrow_spread * dir (arrow_dir + 90));
    draw (z0   - 7/8arrow_spread * dir (arrow_dir + 90)) --
         (z0   + 7/8arrow_spread * dir (arrow_dir + 90));

    if negated:
      stroke_through_arrow(1/2[z0, head], alpha, 9/4arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for alpha = 0, 90, 180, 270, 45, 135, 225, 315:
  beginarrow(alpha, 1, ifneg(5/2, 2) * arrow_spread#); "double models (" & decimal alpha & ")";
    pickup rule_pen;

    z1 - z0 = z3 - z2 = equal_spread * dir (arrow_dir + 90);

    z4 = foot + equal_spread * dir arrow_dir;

    0.5[z0,z1] = z4;
    0.5[z2,z3] = head;

    draw z0 + 1/4rule_thickness * dir arrow_dir -- z2;
    draw z1 + 1/4rule_thickness * dir arrow_dir -- z3;
    draw (foot - arrow_spread * dir (arrow_dir + 90)) --
         (foot + arrow_spread * dir (arrow_dir + 90));
    draw (z4   - arrow_spread * dir (arrow_dir + 90)) --
         (z4   + arrow_spread * dir (arrow_dir + 90));

    if negated:
      stroke_through_arrow(1/2[z4, head], alpha, 5/2arrow_spread)
                          (70, 70, 110, 110, 70, 70, 110, 110);
    fi
  endchar;
endfor;

for sign = 1, -1:
  for alpha = 0, 90, 180, 270:
    beginoperator(large_op_size#, 1);
      if sign > 0: "right" else: "left" fi & " circle arrow (" & decimal alpha & ")";

      pickup rule_pen;

      r := 0.8(w/2-u) - 1.1rule_thickness;

      reg_poly_points(a)(8, centre, r, alpha);

      z0 = centre + r * dir (alpha + 10);
      z1 = centre + r * dir (alpha - 10);

      draw z0{dir (alpha + 100)} .. z.a1 .. z.a2 .. z.a3 .. z.a4 .. z.a5 .. z.a6 .. z.a7 ..
          {dir (alpha + 80)}z1;

      if sign > 0:
        draw arrowhead(z1, (alpha + 65), arrow_spread);
      else:
        draw arrowhead(z0, (alpha - 65), arrow_spread);
      fi;

      if negated:
         1/2[z2,z3] = centre;
         y2 - y3 = large_op_size;
         z2 - z3 = whatever * dir 80;

         pickup stroke_pen;
         draw z2 -- z3;
      fi
    endchar;
  endfor;
endfor;

%for alpha = 0, 90, 180, 270:
%  beginoperator(large_op_size#, 1); "left circle arrow (" & decimal alpha & ")";
%    pickup rule_pen;
%
%    r := 0.8(w/2-u) - 1.1rule_thickness;
%
%    reg_poly_points(a)(8, centre, r, alpha);
%
%    z0 = centre + r * dir (alpha + 10);
%    z1 = centre + r * dir (alpha - 10);
%
%    draw z0{dir (alpha + 100)} .. z.a1 .. z.a2 .. z.a3 .. z.a4 .. z.a5 .. z.a6 .. z.a7 ..
%        {dir (alpha + 80)}z1;
%    draw arrowhead(z0, (alpha - 65), arrow_spread);
%
%    if negated:
%       1/2[z2,z3] = centre;
%       y2 - y3 = large_op_size;
%       z2 - z3 = whatever * dir 80;
%
%       pickup stroke_pen;
%       draw z2 -- z3;
%    fi
%  endchar;
%endfor;

Zerion Mini Shell 1.0