| 1 |
|
| 2 |
beginsymbol(dot_size# + 2side_bearing#, vcentre(2dot_size#)); "centre dot"; |
| 3 |
pickup rule_pen; |
| 4 |
|
| 5 |
fill circle((w/2, (h-d)/2), dot_size); |
| 6 |
endchar; |
| 7 |
|
| 8 |
for alpha = 0, 90, 45, 135: |
| 9 |
beginarrow(alpha, (3dot_size# + equal_spread#)/arrow_horiz_len#, dot_size#); |
| 10 |
"colon (" & decimal alpha & ")"; |
| 11 |
pickup rule_pen; |
| 12 |
|
| 13 |
z1 - z0 = (2dot_size + equal_spread) * dir alpha; |
| 14 |
1/2[z0,z1] = centre; |
| 15 |
|
| 16 |
fill circle(z0, dot_size); |
| 17 |
fill circle(z1, dot_size); |
| 18 |
endchar; |
| 19 |
endfor; |
| 20 |
|
| 21 |
for alpha = 0, 90, 45, 135: |
| 22 |
beginarrow(alpha, (5dot_size# + 2equal_spread#)/arrow_horiz_len#, dot_size#); |
| 23 |
"triple colon (" & decimal alpha & ")"; |
| 24 |
pickup rule_pen; |
| 25 |
|
| 26 |
z1 - z0 = (2dot_size + equal_spread) * dir alpha; |
| 27 |
z2 - z1 = (2dot_size + equal_spread) * dir alpha; |
| 28 |
z1 = centre; |
| 29 |
|
| 30 |
fill circle(z0, dot_size); |
| 31 |
fill circle(z1, dot_size); |
| 32 |
fill circle(z2, dot_size); |
| 33 |
endchar; |
| 34 |
endfor; |
| 35 |
|
| 36 |
for alpha = 0, 90, 180, 270: |
| 37 |
beginoperator(plus_size#, 1); "therefore (" & decimal alpha & ")"; |
| 38 |
pickup rule_pen; |
| 39 |
|
| 40 |
r := plus_size/2; % - 11/10rule_thickness; |
| 41 |
r := r * 1/3[1, sqrt 2]; |
| 42 |
|
| 43 |
fill circle(centre + r * dir alpha, dot_size); |
| 44 |
fill circle(centre + r * dir (alpha + 120), dot_size); |
| 45 |
fill circle(centre + r * dir (alpha + 240), dot_size); |
| 46 |
endchar; |
| 47 |
endfor; |
| 48 |
|
| 49 |
for alpha = 0, 45: |
| 50 |
beginoperator(plus_size#, 1); "quad dot (" & decimal alpha & ")"; |
| 51 |
pickup rule_pen; |
| 52 |
|
| 53 |
r := plus_size/2; % - 11/10rule_thickness; |
| 54 |
r := r * 1/3[1, sqrt 2]; |
| 55 |
|
| 56 |
fill circle(centre + r * dir alpha, dot_size); |
| 57 |
fill circle(centre + r * dir (alpha + 90), dot_size); |
| 58 |
fill circle(centre + r * dir (alpha + 180), dot_size); |
| 59 |
fill circle(centre + r * dir (alpha + 270), dot_size); |
| 60 |
endchar; |
| 61 |
endfor; |
| 62 |
|
| 63 |
beginoperator(plus_size#, 1); "five dots"; |
| 64 |
pickup rule_pen; |
| 65 |
|
| 66 |
r := plus_size/2; % - 11/10rule_thickness; |
| 67 |
r := r * 1/3[1, sqrt 2]; |
| 68 |
|
| 69 |
fill circle(centre, dot_size); |
| 70 |
fill circle(centre + r * dir 0, dot_size); |
| 71 |
fill circle(centre + r * dir 90, dot_size); |
| 72 |
fill circle(centre + r * dir 180, dot_size); |
| 73 |
fill circle(centre + r * dir 270, dot_size); |
| 74 |
endchar; |
| 75 |
|
| 76 |
beginoperator(plus_size#, 1); "minus"; |
| 77 |
pickup rule_pen; |
| 78 |
|
| 79 |
r := plus_size/2; % - 11/10rule_thickness; |
| 80 |
|
| 81 |
draw (centre + r * dir 0) -- (centre + r * dir 180); |
| 82 |
endchar; |
| 83 |
|
| 84 |
beginoperator(plus_size#, 1); "bar"; |
| 85 |
pickup rule_pen; |
| 86 |
|
| 87 |
r := plus_size/2; % - 11/10rule_thickness; |
| 88 |
|
| 89 |
draw (centre + r * dir 90) -- (centre + r * dir 270); |
| 90 |
endchar; |
| 91 |
|
| 92 |
beginoperator(plus_size#, 1); "medium slash"; |
| 93 |
pickup rule_pen; |
| 94 |
|
| 95 |
r := plus_size/2; % - 11/10rule_thickness; |
| 96 |
r := r * 1/3[1, sqrt 2]; |
| 97 |
|
| 98 |
draw (centre + r * dir 45) -- (centre + r * dir 225); |
| 99 |
endchar; |
| 100 |
|
| 101 |
beginoperator(plus_size#, 1); "medium backslash"; |
| 102 |
pickup rule_pen; |
| 103 |
|
| 104 |
r := plus_size/2; % - 11/10rule_thickness; |
| 105 |
r := r * 1/3[1, sqrt 2]; |
| 106 |
|
| 107 |
draw (centre + r * dir 135) -- (centre + r * dir 315); |
| 108 |
endchar; |
| 109 |
|
| 110 |
beginoperator(plus_size#, 1); "plus"; |
| 111 |
pickup rule_pen; |
| 112 |
|
| 113 |
r := plus_size/2; % - 11/10rule_thickness; |
| 114 |
|
| 115 |
draw (centre + r * dir 0) -- (centre + r * dir 180); |
| 116 |
draw (centre + r * dir 90) -- (centre + r * dir 270); |
| 117 |
endchar; |
| 118 |
|
| 119 |
beginoperator(plus_size#, 1); "times"; |
| 120 |
pickup rule_pen; |
| 121 |
|
| 122 |
r := plus_size/2; % - 11/10rule_thickness; |
| 123 |
r := r * 1/3[1, sqrt 2]; |
| 124 |
|
| 125 |
draw (centre + r * dir 45) -- (centre + r * dir 225); |
| 126 |
draw (centre + r * dir 135) -- (centre + r * dir 315); |
| 127 |
endchar; |
| 128 |
|
| 129 |
beginoperator(plus_size#, 1); "plus minus"; |
| 130 |
pickup rule_pen; |
| 131 |
|
| 132 |
r := plus_size/2; % - 11/10rule_thickness; |
| 133 |
|
| 134 |
draw (centre + r * dir 0) -- (centre + r * dir 180); |
| 135 |
draw (centre + r * dir 90) -- (centre + (r - 1/4rule_thickness) * dir 270); |
| 136 |
|
| 137 |
draw (centre + r * (dir 0 - dir 90)) -- (centre + r * (dir 180 - dir 90)); |
| 138 |
endchar; |
| 139 |
|
| 140 |
beginoperator(plus_size#, 1); "minus plus"; |
| 141 |
pickup rule_pen; |
| 142 |
|
| 143 |
r := plus_size/2; % - 11/10rule_thickness; |
| 144 |
|
| 145 |
draw (centre + r * dir 0) -- (centre + r * dir 180); |
| 146 |
draw (centre + (r - 1/4rule_thickness) * dir 90) -- (centre + r * dir 270); |
| 147 |
|
| 148 |
draw (centre + r * (dir 0 + dir 90)) -- (centre + r * (dir 180 + dir 90)); |
| 149 |
endchar; |
| 150 |
|
| 151 |
for angle = 0, 90, 180, 270: |
| 152 |
beginoperator(plus_size#, 1); "dot minus (" & decimal angle & ")"; |
| 153 |
pickup rule_pen; |
| 154 |
|
| 155 |
r := plus_size/2; % - 11/10rule_thickness; |
| 156 |
|
| 157 |
draw (centre - r * dir angle) -- (centre + r * dir angle); |
| 158 |
fill circle(centre + equal_spread * dir (angle + 90), dot_size); |
| 159 |
endchar; |
| 160 |
endfor; |
| 161 |
|
| 162 |
for angle = 0, 45, 90, 135: |
| 163 |
beginoperator(plus_size#, 1); "divides"; |
| 164 |
pickup rule_pen; |
| 165 |
|
| 166 |
r := plus_size/2; % - 11/10rule_thickness; |
| 167 |
|
| 168 |
draw (centre - r * dir angle) -- (centre + r * dir angle); |
| 169 |
fill circle(centre + equal_spread * dir (angle + 90), dot_size); |
| 170 |
fill circle(centre - equal_spread * dir (angle + 90), dot_size); |
| 171 |
endchar; |
| 172 |
endfor; |
| 173 |
|
| 174 |
% Warning: The other two orientations are below. |
| 175 |
% They should stay consistent. |
| 176 |
|
| 177 |
beginoperator(plus_size#, 1); "logical not"; |
| 178 |
pickup rule_pen; |
| 179 |
|
| 180 |
r := plus_size/2; % - 11/10rule_thickness; |
| 181 |
|
| 182 |
draw (centre + r * dir 180) -- (centre + r * dir 0) |
| 183 |
-- (centre + r * dir 0 - equal_spread * dir 90); |
| 184 |
endchar; |
| 185 |
|
| 186 |
beginoperator(plus_size#, 1); "reversed logical not"; |
| 187 |
pickup rule_pen; |
| 188 |
|
| 189 |
r := plus_size/2; % - 11/10rule_thickness; |
| 190 |
|
| 191 |
draw (centre + r * dir 180 - equal_spread * dir 90) |
| 192 |
-- (centre + r * dir 180) -- (centre + r * dir 0) |
| 193 |
endchar; |
| 194 |
|
| 195 |
for alpha = 0, 90, 180, 270: |
| 196 |
beginoperator(plus_size#, 1); "times (" & decimal alpha & ")"; |
| 197 |
pickup rule_pen; |
| 198 |
|
| 199 |
r := plus_size/2; % - 11/10rule_thickness; |
| 200 |
r := r * 1/3[1, sqrt 2]; |
| 201 |
|
| 202 |
draw (centre + r * dir (alpha + 45)) -- (centre + r * dir (alpha + 225)) -- |
| 203 |
(centre + r * dir (alpha + 315)) -- (centre + r * dir (alpha + 135)); |
| 204 |
endchar; |
| 205 |
endfor; |
| 206 |
|
| 207 |
for alpha = 0, 90: |
| 208 |
beginoperator(plus_size#, 1); "bowtie (" & decimal alpha & ")"; |
| 209 |
pickup rule_pen; |
| 210 |
|
| 211 |
r := plus_size/2; % - 11/10rule_thickness; |
| 212 |
r := r * 1/3[1, sqrt 2]; |
| 213 |
|
| 214 |
draw (centre + r * dir (alpha + 45)) -- (centre + r * dir (alpha + 225)) -- |
| 215 |
(centre + r * dir (alpha + 135)) -- (centre + r * dir (alpha + 315)) -- cycle; |
| 216 |
endchar; |
| 217 |
endfor; |
| 218 |
|
| 219 |
for alpha = 0, 90, 180, 270: |
| 220 |
beginoperator(plus_size#, 1); "Y (" & decimal alpha & ")"; |
| 221 |
pickup rule_pen; |
| 222 |
|
| 223 |
r := plus_size/2; % - 11/10rule_thickness; |
| 224 |
r := r * 1/3[1, sqrt 2]; |
| 225 |
|
| 226 |
draw centre -- (centre + r * dir alpha); |
| 227 |
draw centre -- (centre + r * dir (alpha + 120)); |
| 228 |
draw centre -- (centre + r * dir (alpha + 240)); |
| 229 |
endchar; |
| 230 |
endfor; |
| 231 |
|
| 232 |
% operators |
| 233 |
|
| 234 |
for sign = 1, -1: |
| 235 |
beginoperator(plus_size#, 1); "wedge"; |
| 236 |
pickup rule_pen; |
| 237 |
|
| 238 |
z2 - z0 = plus_size * dir 0; |
| 239 |
|
| 240 |
x1 = 1/2[x0, x2] = w/2; |
| 241 |
|
| 242 |
y1 - y0 = sign * plus_size; |
| 243 |
1/2[y0,y1] = ypart centre; |
| 244 |
|
| 245 |
draw z0 -- z1 -- z2; |
| 246 |
endchar; |
| 247 |
endfor; |
| 248 |
|
| 249 |
for sign = 1, -1: |
| 250 |
beginoperator(plus_size#, 1); "wedge dot"; |
| 251 |
pickup rule_pen; |
| 252 |
|
| 253 |
z2 - z0 = plus_size * dir 0; |
| 254 |
|
| 255 |
x1 = 1/2[x0, x2] = w/2; |
| 256 |
|
| 257 |
y1 - y0 = sign * plus_size; |
| 258 |
1/2[y0,y1] = ypart centre; |
| 259 |
|
| 260 |
draw z0 -- z1 -- z2; |
| 261 |
fill circle(centre - sign * 1/3plus_size * dir 90, dot_size); |
| 262 |
endchar; |
| 263 |
endfor; |
| 264 |
|
| 265 |
for sign = 1, -1: |
| 266 |
beginsymbol(13/9plus_size# + 2side_bearing#, vcentre(plus_size# + rule_thickness#)); |
| 267 |
"double wedge"; |
| 268 |
|
| 269 |
pickup rule_pen; |
| 270 |
|
| 271 |
z2 - z0 = plus_size * dir 0; |
| 272 |
|
| 273 |
x1 = 1/2[x0, x2] = w/2; |
| 274 |
|
| 275 |
y1 - y0 = sign * plus_size; |
| 276 |
1/2[y0,y1] = ypart centre; |
| 277 |
|
| 278 |
1/2[z0a,z0b] = z0; |
| 279 |
1/2[z1a,z1b] = z1; |
| 280 |
1/2[z2a,z2b] = z2; |
| 281 |
z0b - z0a = z1b - z1a = z2b - z2a = 4/9plus_size * dir 0; |
| 282 |
|
| 283 |
draw z0a -- z1a -- z2a; |
| 284 |
draw z0b -- z1b -- z2b; |
| 285 |
endchar; |
| 286 |
endfor; |
| 287 |
|
| 288 |
for sign = 1, -1: |
| 289 |
beginoperator(plus_size#, 1); "curly wedge"; |
| 290 |
pickup rule_pen; |
| 291 |
|
| 292 |
draw prec(centre + sign * 1/2plus_size * dir 90, |
| 293 |
centre - sign * 1/2plus_size * dir 90, |
| 294 |
plus_size); |
| 295 |
endchar; |
| 296 |
endfor; |
| 297 |
|
| 298 |
for sign = 1, -1: |
| 299 |
beginoperator(plus_size#, 1); "curly wedge dot"; |
| 300 |
pickup rule_pen; |
| 301 |
|
| 302 |
draw prec(centre + sign * 1/2plus_size * dir 90, |
| 303 |
centre - sign * 1/2plus_size * dir 90, |
| 304 |
plus_size); |
| 305 |
fill circle(centre - sign * 5/12plus_size * dir 90, dot_size); |
| 306 |
endchar; |
| 307 |
endfor; |
| 308 |
|
| 309 |
for sign = 1, -1: |
| 310 |
beginsymbol(13/9plus_size# + 2side_bearing#, vcentre(plus_size# + rule_thickness#)); |
| 311 |
"double wedge"; |
| 312 |
|
| 313 |
pickup rule_pen; |
| 314 |
|
| 315 |
1/2[z0,z1] = (w/2, (h-d)/2); |
| 316 |
z1 - z0 = 4/9plus_size * dir 0; |
| 317 |
|
| 318 |
draw prec(z0 + sign * 1/2plus_size * dir 90, |
| 319 |
z0 - sign * 1/2plus_size * dir 90, |
| 320 |
plus_size); |
| 321 |
draw prec(z1 + sign * 1/2plus_size * dir 90, |
| 322 |
z1 - sign * 1/2plus_size * dir 90, |
| 323 |
plus_size); |
| 324 |
endchar; |
| 325 |
endfor; |
| 326 |
|
| 327 |
for sign = 1, -1: |
| 328 |
beginoperator(plus_size#, 1); "union"; |
| 329 |
pickup rule_pen; |
| 330 |
|
| 331 |
draw subset(centre - sign * 1/2plus_size * dir 90, |
| 332 |
centre + sign * 1/2plus_size * dir 90, |
| 333 |
plus_size); |
| 334 |
endchar; |
| 335 |
endfor; |
| 336 |
|
| 337 |
for sign = 1, -1: |
| 338 |
beginoperator(4/3plus_size#, 1); "double union"; |
| 339 |
pickup rule_pen; |
| 340 |
|
| 341 |
draw subset(centre - sign * 5/18plus_size * dir 90, |
| 342 |
centre + sign * 2/3plus_size * dir 90, |
| 343 |
5/9plus_size); |
| 344 |
draw subset(centre - sign * 2/3plus_size * dir 90, |
| 345 |
centre + sign * 2/3plus_size * dir 90, |
| 346 |
4/3plus_size); |
| 347 |
endchar; |
| 348 |
endfor; |
| 349 |
|
| 350 |
for sign = 1, -1: |
| 351 |
beginoperator(plus_size#, 1); "union dot"; |
| 352 |
pickup rule_pen; |
| 353 |
|
| 354 |
draw subset(centre - sign * 1/2plus_size * dir 90, |
| 355 |
centre + sign * 1/2plus_size * dir 90, |
| 356 |
plus_size); |
| 357 |
fill circle(centre + sign * 1/6plus_size * dir 90, dot_size); |
| 358 |
endchar; |
| 359 |
endfor; |
| 360 |
|
| 361 |
for sign = 1, -1: |
| 362 |
beginoperator(plus_size#, 1); "union plus"; |
| 363 |
pickup rule_pen; |
| 364 |
|
| 365 |
draw subset(centre - sign * 1/2plus_size * dir 90, |
| 366 |
centre + sign * 1/2plus_size * dir 90, |
| 367 |
plus_size); |
| 368 |
|
| 369 |
t := 22/10rule_thickness; |
| 370 |
r := 1/2plus_size - t; |
| 371 |
|
| 372 |
draw (centre + sign * 1/6plus_size * dir 90 + r * dir 0) |
| 373 |
-- (centre + sign * 1/6plus_size * dir 90 + r * dir 180); |
| 374 |
draw (centre + (r + sign * 1/6plus_size) * dir 90) |
| 375 |
-- (centre + (r - sign * 1/6plus_size) * dir 270); |
| 376 |
endchar; |
| 377 |
endfor; |
| 378 |
|
| 379 |
for sign = 1, -1: |
| 380 |
beginoperator(plus_size#, 1); "square union"; |
| 381 |
pickup rule_pen; |
| 382 |
|
| 383 |
z3 - z0 = z2 - z1 = plus_size * dir 0; |
| 384 |
z0 - z1 = sign * plus_size * dir 90; |
| 385 |
|
| 386 |
1/2[1/2[z0,z1], 1/2[z2,z3]] = centre; |
| 387 |
|
| 388 |
draw z0 -- z1 -- z2 -- z3; |
| 389 |
endchar; |
| 390 |
endfor; |
| 391 |
|
| 392 |
for sign = 1, -1: |
| 393 |
beginoperator(4/3plus_size#, 1); "double square union"; |
| 394 |
pickup rule_pen; |
| 395 |
|
| 396 |
z3a - z0a = z2a - z1a = 4/3plus_size * dir 0; |
| 397 |
z0a - z1a = sign * 4/3plus_size * dir 90; |
| 398 |
|
| 399 |
1/2[1/2[z0a,z1a], 1/2[z2a,z3a]] = centre; |
| 400 |
|
| 401 |
z3b - z0b = z2b - z1b = 5/9plus_size * dir 0; |
| 402 |
z0b - z1b = sign * 17/18plus_size * dir 90; |
| 403 |
|
| 404 |
y0b = y0a; |
| 405 |
1/2[x0b, x3b] = xpart centre; |
| 406 |
|
| 407 |
draw z0a -- z1a -- z2a -- z3a; |
| 408 |
draw z0b -- z1b -- z2b -- z3b; |
| 409 |
endchar; |
| 410 |
endfor; |
| 411 |
|
| 412 |
for sign = 1, -1: |
| 413 |
beginoperator(plus_size#, 1); "square union dot"; |
| 414 |
pickup rule_pen; |
| 415 |
|
| 416 |
z3 - z0 = z2 - z1 = plus_size * dir 0; |
| 417 |
z0 - z1 = sign * plus_size * dir 90; |
| 418 |
|
| 419 |
1/2[1/2[z0,z1], 1/2[z2,z3]] = centre; |
| 420 |
|
| 421 |
draw z0 -- z1 -- z2 -- z3; |
| 422 |
|
| 423 |
fill circle(centre + sign * 1/6plus_size * dir 90, dot_size); |
| 424 |
endchar; |
| 425 |
endfor; |
| 426 |
|
| 427 |
for sign = 1, -1: |
| 428 |
beginoperator(plus_size#, 1); "square union plus"; |
| 429 |
pickup rule_pen; |
| 430 |
|
| 431 |
z3 - z0 = z2 - z1 = plus_size * dir 0; |
| 432 |
z0 - z1 = sign * plus_size * dir 90; |
| 433 |
|
| 434 |
1/2[1/2[z0,z1], 1/2[z2,z3]] = centre; |
| 435 |
|
| 436 |
draw z0 -- z1 -- z2 -- z3; |
| 437 |
|
| 438 |
t := 22/10rule_thickness; |
| 439 |
r := 1/2plus_size - t; |
| 440 |
|
| 441 |
draw (centre + sign * 1/6plus_size * dir 90 + r * dir 0) |
| 442 |
-- (centre + sign * 1/6plus_size * dir 90 + r * dir 180); |
| 443 |
draw (centre + (r + sign * 1/6plus_size) * dir 90) |
| 444 |
-- (centre + (r - sign * 1/6plus_size) * dir 270); |
| 445 |
endchar; |
| 446 |
endfor; |
| 447 |
|
| 448 |
|
| 449 |
% triangles |
| 450 |
|
| 451 |
for alpha = 0, 90, 180, 270: |
| 452 |
beginoperator(small_op_size#, 1); "small triangle (" & decimal alpha & ")"; |
| 453 |
pickup rule_pen; |
| 454 |
draw triangle(centre, w/2-side_bearing, alpha); |
| 455 |
endchar; |
| 456 |
endfor; |
| 457 |
|
| 458 |
for alpha = 0, 90, 180, 270: |
| 459 |
beginoperator(small_op_size#, 1); "small filled triangle (" & decimal alpha & ")"; |
| 460 |
pickup rule_pen; |
| 461 |
draw triangle(centre, w/2-side_bearing, alpha); |
| 462 |
fill triangle(centre, w/2-side_bearing, alpha); |
| 463 |
endchar; |
| 464 |
endfor; |
| 465 |
|
| 466 |
for alpha = 0, 90, 180, 270: |
| 467 |
beginoperator(med_op_size#, 1); "medium triangle (" & decimal alpha & ")"; |
| 468 |
pickup rule_pen; |
| 469 |
draw triangle(centre, w/2-side_bearing, alpha); |
| 470 |
endchar; |
| 471 |
endfor; |
| 472 |
|
| 473 |
for alpha = 0, 90, 180, 270: |
| 474 |
beginoperator(large_op_size#, 1); "large triangle (" & decimal alpha & ")"; |
| 475 |
pickup rule_pen; |
| 476 |
draw triangle(centre, w/2-side_bearing, alpha); |
| 477 |
endchar; |
| 478 |
endfor; |
| 479 |
|
| 480 |
% circles |
| 481 |
|
| 482 |
beginoperator(4/5small_op_size#, 1); "small circle"; |
| 483 |
pickup rule_pen; |
| 484 |
draw circle(centre, 4/10small_op_size); |
| 485 |
endchar; |
| 486 |
|
| 487 |
beginoperator(4/5small_op_size#, 1); "small filled circle"; |
| 488 |
pickup rule_pen; |
| 489 |
draw circle(centre, 4/10small_op_size); |
| 490 |
fill circle(centre, 4/10small_op_size); |
| 491 |
endchar; |
| 492 |
|
| 493 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle"; |
| 494 |
pickup rule_pen; |
| 495 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 496 |
endchar; |
| 497 |
|
| 498 |
beginoperator(4/5large_op_size#, 1); "large circle"; |
| 499 |
pickup rule_pen; |
| 500 |
draw circle(centre, 4/10large_op_size); |
| 501 |
endchar; |
| 502 |
|
| 503 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle minus"; |
| 504 |
pickup rule_pen; |
| 505 |
|
| 506 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 507 |
draw (centre + plus_size/2 * left) -- (centre + plus_size/2 * right); |
| 508 |
endchar; |
| 509 |
|
| 510 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle bar"; |
| 511 |
pickup rule_pen; |
| 512 |
|
| 513 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 514 |
draw (centre + plus_size/2 * up) -- (centre + plus_size/2 * down); |
| 515 |
endchar; |
| 516 |
|
| 517 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle slash"; |
| 518 |
pickup rule_pen; |
| 519 |
|
| 520 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 521 |
draw (centre + plus_size/2 * dir 45) -- (centre + plus_size/2 * dir 225); |
| 522 |
endchar; |
| 523 |
|
| 524 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle backslash"; |
| 525 |
pickup rule_pen; |
| 526 |
|
| 527 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 528 |
draw (centre + plus_size/2 * dir 135) -- (centre + plus_size/2 * dir 315); |
| 529 |
endchar; |
| 530 |
|
| 531 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle plus"; |
| 532 |
pickup rule_pen; |
| 533 |
|
| 534 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 535 |
draw (centre + plus_size/2 * left) -- (centre + plus_size/2 * right); |
| 536 |
draw (centre + plus_size/2 * up) -- (centre + plus_size/2 * down); |
| 537 |
endchar; |
| 538 |
|
| 539 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle times"; |
| 540 |
pickup rule_pen; |
| 541 |
|
| 542 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 543 |
draw (centre + plus_size/2 * dir 45) -- (centre + plus_size/2 * dir 225); |
| 544 |
draw (centre + plus_size/2 * dir 135) -- (centre + plus_size/2 * dir 315); |
| 545 |
endchar; |
| 546 |
|
| 547 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle dot"; |
| 548 |
pickup rule_pen; |
| 549 |
|
| 550 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 551 |
fill circle(centre, 1.3dot_size); |
| 552 |
endchar; |
| 553 |
|
| 554 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle circle"; |
| 555 |
pickup rule_pen; |
| 556 |
|
| 557 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 558 |
draw circle(centre, (plus_size + 11/5rule_thickness)/5); |
| 559 |
endchar; |
| 560 |
|
| 561 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle triangle"; |
| 562 |
pickup rule_pen; |
| 563 |
|
| 564 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 565 |
draw triangle(centre, small_op_size/2, 90); |
| 566 |
endchar; |
| 567 |
|
| 568 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle asterisk"; |
| 569 |
pickup rule_pen; |
| 570 |
|
| 571 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 572 |
|
| 573 |
penpos a0(4/3rule_thickness, 0 - 7); |
| 574 |
penpos a1(4/3rule_thickness, 72 - 7); |
| 575 |
penpos a2(4/3rule_thickness, 144 - 7); |
| 576 |
penpos a3(4/3rule_thickness, 216 - 7); |
| 577 |
penpos a4(4/3rule_thickness, 288 - 7); |
| 578 |
|
| 579 |
penpos b0(2/3rule_thickness, 0 - 7); |
| 580 |
penpos b1(2/3rule_thickness, 72 - 7); |
| 581 |
penpos b2(2/3rule_thickness, 144 - 7); |
| 582 |
penpos b3(2/3rule_thickness, 216 - 7); |
| 583 |
penpos b4(2/3rule_thickness, 288 - 7); |
| 584 |
|
| 585 |
reg_poly_points(a)(5, centre, plus_size/2, 77); |
| 586 |
|
| 587 |
z.b0 = z.b1 = z.b2 = z.b3 = z.b4 = centre; |
| 588 |
|
| 589 |
fill stroke z.a0e -- z.b0e; |
| 590 |
fill stroke z.a1e -- z.b1e; |
| 591 |
fill stroke z.a2e -- z.b2e; |
| 592 |
fill stroke z.a3e -- z.b3e; |
| 593 |
fill stroke z.a4e -- z.b4e; |
| 594 |
endchar; |
| 595 |
|
| 596 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "medium circle star"; |
| 597 |
pickup rule_pen; |
| 598 |
|
| 599 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 600 |
|
| 601 |
reg_poly_points(a)(5, centre, plus_size/2, 90); |
| 602 |
reg_poly_points(b)(5, centre, plus_size/20, 126); |
| 603 |
|
| 604 |
draw z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 605 |
fill z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 606 |
endchar; |
| 607 |
|
| 608 |
beginoperator(plus_size# + 11/5rule_thickness#, 1); "negated medium circle"; |
| 609 |
pickup rule_pen; |
| 610 |
|
| 611 |
r := 3/4(plus_size + 11/5rule_thickness); |
| 612 |
|
| 613 |
draw circle(centre, plus_size/2 + 11/10rule_thickness); |
| 614 |
draw (centre + r * dir 45) -- (centre + r * dir 225); |
| 615 |
endchar; |
| 616 |
|
| 617 |
% squares |
| 618 |
|
| 619 |
beginoperator(small_op_size#/sqrt(2), 1); "small square"; |
| 620 |
pickup rule_pen; |
| 621 |
draw square(centre, w/2 - side_bearing, 0); |
| 622 |
endchar; |
| 623 |
beginoperator(small_op_size#/sqrt(2), 1); "small filled square"; |
| 624 |
pickup rule_pen; |
| 625 |
draw square(centre, w/2 - side_bearing, 0); |
| 626 |
fill square(centre, w/2 - side_bearing, 0); |
| 627 |
endchar; |
| 628 |
beginoperator(med_op_size#/sqrt(2), 1); "medium square"; |
| 629 |
pickup rule_pen; |
| 630 |
draw square(centre, w/2 - side_bearing, 0); |
| 631 |
endchar; |
| 632 |
beginoperator(large_op_size#/sqrt(2), 1); "large square"; |
| 633 |
pickup rule_pen; |
| 634 |
draw square(centre, w/2 - side_bearing, 0); |
| 635 |
endchar; |
| 636 |
|
| 637 |
beginoperator(small_op_size#, 1); "small diamond"; |
| 638 |
pickup rule_pen; |
| 639 |
draw square(centre, (w/2 - side_bearing) / sqrt(2), 45); |
| 640 |
endchar; |
| 641 |
beginoperator(small_op_size#, 1); "small filled diamond"; |
| 642 |
pickup rule_pen; |
| 643 |
draw square(centre, (w/2 - side_bearing) / sqrt(2), 45); |
| 644 |
fill square(centre, (w/2 - side_bearing) / sqrt(2), 45); |
| 645 |
endchar; |
| 646 |
beginoperator(med_op_size#, 1); "medium diamond"; |
| 647 |
pickup rule_pen; |
| 648 |
draw square(centre, (w/2 - side_bearing) / sqrt(2), 45); |
| 649 |
endchar; |
| 650 |
beginoperator(large_op_size#, 1); "large diamond"; |
| 651 |
pickup rule_pen; |
| 652 |
draw square(centre, (w/2 - side_bearing) / sqrt(2), 45); |
| 653 |
endchar; |
| 654 |
|
| 655 |
beginoperator(med_op_size#/sqrt(2), 1); "medium square minus"; |
| 656 |
pickup rule_pen; |
| 657 |
r := w/2 - side_bearing; |
| 658 |
draw square(centre, r, 0); |
| 659 |
draw (centre + sqrt .5 * r * dir 0) -- (centre + sqrt .5 * r * dir 180); |
| 660 |
endchar; |
| 661 |
beginoperator(med_op_size#/sqrt(2), 1); "medium square vert"; |
| 662 |
pickup rule_pen; |
| 663 |
r := w/2 - side_bearing; |
| 664 |
draw square(centre, r, 0); |
| 665 |
draw (centre + sqrt .5 * r * dir 90) -- (centre + sqrt .5 * r * dir 270); |
| 666 |
endchar; |
| 667 |
beginoperator(med_op_size#/sqrt(2), 1); "medium square slash"; |
| 668 |
pickup rule_pen; |
| 669 |
r := w/2 - side_bearing; |
| 670 |
draw square(centre, r, 0); |
| 671 |
draw (centre + r * dir 45) -- (centre + r * dir 225); |
| 672 |
endchar; |
| 673 |
beginoperator(med_op_size#/sqrt(2), 1); "medium square backslash"; |
| 674 |
pickup rule_pen; |
| 675 |
r := w/2 - side_bearing; |
| 676 |
draw square(centre, r, 0); |
| 677 |
draw (centre + r * dir 135) -- (centre + r * dir 315); |
| 678 |
endchar; |
| 679 |
beginoperator(med_op_size#/sqrt(2), 1); "medium square plus"; |
| 680 |
pickup rule_pen; |
| 681 |
r := w/2 - side_bearing; |
| 682 |
draw square(centre, r, 0); |
| 683 |
draw (centre + sqrt .5 * r * dir 0) -- (centre + sqrt .5 * r * dir 180); |
| 684 |
draw (centre + sqrt .5 * r * dir 90) -- (centre + sqrt .5 * r * dir 270); |
| 685 |
endchar; |
| 686 |
beginoperator(med_op_size#/sqrt(2), 1); "medium square times"; |
| 687 |
pickup rule_pen; |
| 688 |
r := w/2 - side_bearing; |
| 689 |
draw square(centre, r, 0); |
| 690 |
draw (centre + r * dir 45) -- (centre + r * dir 225); |
| 691 |
draw (centre + r * dir 135) -- (centre + r * dir 315); |
| 692 |
endchar; |
| 693 |
beginoperator(med_op_size#/sqrt(2), 1); "medium square dot"; |
| 694 |
pickup rule_pen; |
| 695 |
r := w/2 - side_bearing; |
| 696 |
draw square(centre, r, 0); |
| 697 |
fill circle(centre, 1.3dot_size); |
| 698 |
endchar; |
| 699 |
beginoperator(med_op_size#/sqrt(2), 1); "medium square square"; |
| 700 |
pickup rule_pen; |
| 701 |
r := w/2 - side_bearing; |
| 702 |
draw square(centre, r, 0); |
| 703 |
draw square(centre, .4r, 0); |
| 704 |
endchar; |
| 705 |
|
| 706 |
beginoperator(med_op_size#, 1); "medium diamond minus"; |
| 707 |
pickup rule_pen; |
| 708 |
r := w/2 - side_bearing; |
| 709 |
draw square(centre, r / sqrt(2), 45); |
| 710 |
draw (centre + r * dir 0) -- (centre + r * dir 180); |
| 711 |
endchar; |
| 712 |
beginoperator(med_op_size#, 1); "medium diamond vert"; |
| 713 |
pickup rule_pen; |
| 714 |
r := w/2 - side_bearing; |
| 715 |
draw square(centre, r / sqrt(2), 45); |
| 716 |
draw (centre + r * dir 90) -- (centre + r * dir 270); |
| 717 |
endchar; |
| 718 |
beginoperator(med_op_size#, 1); "medium diamond slash"; |
| 719 |
pickup rule_pen; |
| 720 |
r := w/2 - side_bearing; |
| 721 |
draw square(centre, r / sqrt(2), 45); |
| 722 |
draw (centre + sqrt .5 * r * dir 45) -- (centre + sqrt .5 * r * dir 225); |
| 723 |
endchar; |
| 724 |
beginoperator(med_op_size#, 1); "medium diamond backslash"; |
| 725 |
pickup rule_pen; |
| 726 |
r := w/2 - side_bearing; |
| 727 |
draw square(centre, r / sqrt(2), 45); |
| 728 |
draw (centre + sqrt .5 * r * dir 135) -- (centre + sqrt .5 * r * dir 315); |
| 729 |
endchar; |
| 730 |
beginoperator(med_op_size#, 1); "medium diamond plus"; |
| 731 |
pickup rule_pen; |
| 732 |
r := w/2 - side_bearing; |
| 733 |
draw square(centre, r / sqrt(2), 45); |
| 734 |
draw (centre + r * dir 0) -- (centre + r * dir 180); |
| 735 |
draw (centre + r * dir 90) -- (centre + r * dir 270); |
| 736 |
endchar; |
| 737 |
beginoperator(med_op_size#, 1); "medium diamond times"; |
| 738 |
pickup rule_pen; |
| 739 |
r := w/2 - side_bearing; |
| 740 |
draw square(centre, r / sqrt(2), 45); |
| 741 |
draw (centre + sqrt .5 * r * dir 45) -- (centre + sqrt .5 * r * dir 225); |
| 742 |
draw (centre + sqrt .5 * r * dir 135) -- (centre + sqrt .5 * r * dir 315); |
| 743 |
endchar; |
| 744 |
beginoperator(med_op_size#, 1); "medium diamond dot"; |
| 745 |
pickup rule_pen; |
| 746 |
r := w/2 - side_bearing; |
| 747 |
draw square(centre, r / sqrt(2), 45); |
| 748 |
fill circle(centre, 1.3dot_size); |
| 749 |
endchar; |
| 750 |
beginoperator(med_op_size#, 1); "medium diamond diamond"; |
| 751 |
pickup rule_pen; |
| 752 |
r := w/2 - side_bearing; |
| 753 |
draw square(centre, r / sqrt(2), 45); |
| 754 |
draw square(centre, .4r, 45); |
| 755 |
endchar; |
| 756 |
|
| 757 |
beginoperator(small_op_size#, 1); "small star"; |
| 758 |
pickup rule_pen; |
| 759 |
r := w/2 - side_bearing; |
| 760 |
reg_poly_points(a)(5, centre, r, 90); |
| 761 |
reg_poly_points(b)(5, centre, .4r, 126); |
| 762 |
draw z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 763 |
endchar; |
| 764 |
beginoperator(small_op_size#, 1); "small filled star"; |
| 765 |
pickup rule_pen; |
| 766 |
r := w/2 - side_bearing; |
| 767 |
reg_poly_points(a)(5, centre, r, 90); |
| 768 |
reg_poly_points(b)(5, centre, .4r, 126); |
| 769 |
draw z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 770 |
fill z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 771 |
endchar; |
| 772 |
beginoperator(med_op_size#, 1); "medium star"; |
| 773 |
pickup rule_pen; |
| 774 |
r := w/2 - side_bearing; |
| 775 |
reg_poly_points(a)(5, centre, r, 90); |
| 776 |
reg_poly_points(b)(5, centre, .4r, 126); |
| 777 |
draw z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 778 |
endchar; |
| 779 |
beginoperator(large_op_size#, 1); "large star"; |
| 780 |
pickup rule_pen; |
| 781 |
r := w/2 - side_bearing; |
| 782 |
reg_poly_points(a)(5, centre, r, 90); |
| 783 |
reg_poly_points(b)(5, centre, .4r, 126); |
| 784 |
draw z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 785 |
endchar; |
| 786 |
beginoperator(med_op_size#, 1); "medium pentagram"; |
| 787 |
pickup rule_pen; |
| 788 |
r := w/2 - side_bearing; |
| 789 |
reg_poly_points(a)(5, centre, r, 90); |
| 790 |
draw z.a0 -- z.a2 -- z.a4 -- z.a1 -- z.a3 -- cycle; |
| 791 |
endchar; |
| 792 |
beginoperator(large_op_size#, 1); "large pentagram"; |
| 793 |
pickup rule_pen; |
| 794 |
r := w/2 - side_bearing; |
| 795 |
reg_poly_points(a)(5, centre, r, 90); |
| 796 |
draw z.a0 -- z.a2 -- z.a4 -- z.a1 -- z.a3 -- cycle; |
| 797 |
endchar; |
| 798 |
|
| 799 |
beginoperator(small_op_size#, 1); "medium thin filled star"; |
| 800 |
pickup pencircle scaled 1/2rule_thickness; |
| 801 |
|
| 802 |
r := w/2 - side_bearing; |
| 803 |
|
| 804 |
reg_poly_points(a)(5, centre, r, 90); |
| 805 |
reg_poly_points(b)(5, centre, .2r, 126); |
| 806 |
|
| 807 |
draw z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 808 |
fill z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 809 |
endchar; |
| 810 |
|
| 811 |
beginoperator(small_op_size#, 1); "asterisk"; |
| 812 |
r := w/2 - side_bearing; |
| 813 |
|
| 814 |
penpos a0(4/3rule_thickness, 0 - 7); |
| 815 |
penpos a1(4/3rule_thickness, 72 - 7); |
| 816 |
penpos a2(4/3rule_thickness, 144 - 7); |
| 817 |
penpos a3(4/3rule_thickness, 216 - 7); |
| 818 |
penpos a4(4/3rule_thickness, 288 - 7); |
| 819 |
|
| 820 |
penpos b0(2/3rule_thickness, 0 - 7); |
| 821 |
penpos b1(2/3rule_thickness, 72 - 7); |
| 822 |
penpos b2(2/3rule_thickness, 144 - 7); |
| 823 |
penpos b3(2/3rule_thickness, 216 - 7); |
| 824 |
penpos b4(2/3rule_thickness, 288 - 7); |
| 825 |
|
| 826 |
reg_poly_points(a)(5, centre, r, 77); |
| 827 |
|
| 828 |
z.b0 = z.b1 = z.b2 = z.b3 = z.b4 = centre; |
| 829 |
|
| 830 |
fill stroke z.a0e -- z.b0e; |
| 831 |
fill stroke z.a1e -- z.b1e; |
| 832 |
fill stroke z.a2e -- z.b2e; |
| 833 |
fill stroke z.a3e -- z.b3e; |
| 834 |
fill stroke z.a4e -- z.b4e; |
| 835 |
endchar; |
| 836 |
|
| 837 |
for alpha = 0, 45, 90, 135: |
| 838 |
beginsymbol(2order_width# * abs (cosd (alpha)) + 5/3equal_spread# * abs (sind (alpha)) + 2side_bearing#, |
| 839 |
vcentre(2order_width# * abs (sind (alpha)) + 5/3equal_spread# * abs (cosd (alpha)) + rule_thickness#)); |
| 840 |
"infinity"; |
| 841 |
pickup rule_pen; |
| 842 |
|
| 843 |
pair centre; |
| 844 |
centre := (w/2, (h-d)/2); |
| 845 |
|
| 846 |
z0 = centre - (order_width - 1/2rule_thickness) * dir alpha; |
| 847 |
z1 = centre + (order_width - 1/2rule_thickness) * dir alpha; |
| 848 |
|
| 849 |
z6 = 1/5[z0,z1]; |
| 850 |
z7 = 4/5[z0,z1]; |
| 851 |
|
| 852 |
z2 = z6 + 5/6equal_spread * dir (alpha + 90); |
| 853 |
z3 = z6 - 5/6equal_spread * dir (alpha + 90); |
| 854 |
z4 = z7 + 5/6equal_spread * dir (alpha + 90); |
| 855 |
z5 = z7 - 5/6equal_spread * dir (alpha + 90); |
| 856 |
|
| 857 |
draw z4{dir (alpha + 180)} |
| 858 |
.. {dir (alpha + 225)}1/2[z0,z1]{dir (alpha + 225)} |
| 859 |
.. {dir (alpha + 180)}z3{dir (alpha + 180)} |
| 860 |
.. {dir (alpha + 90)}z0{dir (alpha + 90)} |
| 861 |
.. {dir (alpha + 0)}z2{dir (alpha + 0)} |
| 862 |
.. {dir (alpha + -45)}1/2[z0,z1]{dir (alpha + -45)} |
| 863 |
.. {dir (alpha + 0)}z5{dir (alpha + 0)} |
| 864 |
.. {dir (alpha + 90)}z1{dir (alpha + 90)} |
| 865 |
.. cycle; |
| 866 |
labels (0,1,2,3,4,5,6,7); |
| 867 |
endchar; |
| 868 |
endfor |
| 869 |
|
| 870 |
for alpha = 0, 90, 180, 270: |
| 871 |
beginsymbol(17/10order_width# * abs (cosd (alpha)) + 5/3equal_spread# * abs (sind (alpha)) + 2side_bearing#, |
| 872 |
vcentre(17/10order_width# * abs (sind (alpha)) + 5/3equal_spread# * abs (cosd (alpha)) + rule_thickness#)); |
| 873 |
"proportional"; |
| 874 |
pickup rule_pen; |
| 875 |
|
| 876 |
pair centre; |
| 877 |
centre := (w/2, (h-d)/2); |
| 878 |
|
| 879 |
z0 = centre - (17/20order_width - 1/2rule_thickness) * dir alpha; |
| 880 |
z1 = centre + (15/20order_width - 1/2rule_thickness) * dir alpha; |
| 881 |
|
| 882 |
z4 = z1 + 5/6equal_spread * dir (alpha + 90); |
| 883 |
z5 = z1 - 5/6equal_spread * dir (alpha + 90); |
| 884 |
|
| 885 |
z6 - z4 = z7 - z5 = 1/10order_width * dir alpha; |
| 886 |
|
| 887 |
z8 = 1/4[z0,z1]; |
| 888 |
|
| 889 |
z2 = z8 + 5/6equal_spread * dir (alpha + 90); |
| 890 |
z3 = z8 - 5/6equal_spread * dir (alpha + 90); |
| 891 |
|
| 892 |
draw z6 -- z4{dir (alpha + 180)} |
| 893 |
.. {dir (alpha + 225)}5/8[z0,z1]{dir (alpha + 225)} |
| 894 |
.. {dir (alpha + 180)}z3{dir (alpha + 180)} |
| 895 |
.. {dir (alpha + 90)}z0{dir (alpha + 90)} |
| 896 |
.. {dir (alpha + 0)}z2{dir (alpha + 0)} |
| 897 |
.. {dir (alpha + -45)}5/8[z0,z1]{dir (alpha + -45)} |
| 898 |
.. {dir (alpha + 0)}z5 -- z7; |
| 899 |
labels (0,1,2,3,4,5,6,7); |
| 900 |
endchar; |
| 901 |
endfor; |
| 902 |
|
| 903 |
for alpha = 0, 45, 90, 135: |
| 904 |
beginsymbol(14/10order_width# * abs (cosd (alpha)) + 5/3equal_spread# * abs (sind (alpha)) + 2side_bearing#, |
| 905 |
vcentre(14/10order_width# * abs (sind (alpha)) + 5/3equal_spread# * abs (cosd (alpha)) + rule_thickness#)); |
| 906 |
"crossing"; |
| 907 |
pickup rule_pen; |
| 908 |
|
| 909 |
pair centre; |
| 910 |
centre := (w/2, (h-d)/2); |
| 911 |
|
| 912 |
z0 = centre - (14/20order_width - 1/2rule_thickness) * dir alpha; |
| 913 |
z1 = centre + (14/20order_width - 1/2rule_thickness) * dir alpha; |
| 914 |
|
| 915 |
z2 = z0 + 5/6equal_spread * dir (alpha + 90); |
| 916 |
z3 = z0 - 5/6equal_spread * dir (alpha + 90); |
| 917 |
z4 = z1 + 5/6equal_spread * dir (alpha + 90); |
| 918 |
z5 = z1 - 5/6equal_spread * dir (alpha + 90); |
| 919 |
|
| 920 |
z6 - z4 = z7 - z5 = 1/10order_width * dir alpha; |
| 921 |
z2 - z8 = z3 - z9 = 1/10order_width * dir alpha; |
| 922 |
|
| 923 |
draw z6 -- z4{dir (alpha + 180)} |
| 924 |
.. {dir (alpha + 225)}1/2[z0,z1]{dir (alpha + 225)} |
| 925 |
.. {dir (alpha + 180)}z3 -- z9; |
| 926 |
draw z8 -- z2{dir (alpha + 0)} |
| 927 |
.. {dir (alpha + -45)}1/2[z0,z1]{dir (alpha + -45)} |
| 928 |
.. {dir (alpha + 0)}z5 -- z7; |
| 929 |
labels (0,1,2,3,4,5,6,7,8,9); |
| 930 |
endchar; |
| 931 |
endfor; |
| 932 |
|
| 933 |
beginoperator(med_op_size#, 1); "between"; |
| 934 |
pickup rule_pen; |
| 935 |
|
| 936 |
r := w/2 - side_bearing; |
| 937 |
|
| 938 |
draw smile( 1, centre - r * dir 90, centre + r * dir 90, equal_spread, true); |
| 939 |
draw smile(-1, centre - r * dir 90, centre + r * dir 90, equal_spread, true); |
| 940 |
endchar; |
| 941 |
|
| 942 |
beginoperator(med_op_size#, 1); "reversed between"; |
| 943 |
pickup rule_pen; |
| 944 |
|
| 945 |
r := w/2 - side_bearing; |
| 946 |
|
| 947 |
draw smile( 1, centre - 2/3equal_spread * dir 0 - r * dir 90, |
| 948 |
centre - 2/3equal_spread * dir 0 + r * dir 90, |
| 949 |
2/3equal_spread, true); |
| 950 |
draw smile(-1, centre + 2/3equal_spread * dir 0 - r * dir 90, |
| 951 |
centre + 2/3equal_spread * dir 0 + r * dir 90, |
| 952 |
2/3equal_spread, true); |
| 953 |
endchar; |
| 954 |
|
| 955 |
for sign = 1, -1: |
| 956 |
beginsymbol(order_width# + 2side_bearing#, 2math_axis# + rule_thickness#, rule_thickness#); "top"; |
| 957 |
pickup rule_pen; |
| 958 |
|
| 959 |
z1 - z0 = z3 - z2 = order_width * dir 0; |
| 960 |
z2 - z0 = sign * 2math_axis * dir 90; |
| 961 |
|
| 962 |
1/2[1/2[z0,z1], 1/2[z2,z3]] = (w/2, (h-d)/2); |
| 963 |
|
| 964 |
draw z0 -- z1; |
| 965 |
draw 1/2[z0,z1] -- 1/2[z2,z3]; |
| 966 |
endchar; |
| 967 |
endfor; |
| 968 |
|
| 969 |
beginsymbol(2/3equal_spread# + 2side_bearing#, vcentre(plus_size#+rule_thickness#)); "wreath"; |
| 970 |
pickup rule_pen; |
| 971 |
|
| 972 |
z0 = (w/2, (h-d)/2); |
| 973 |
|
| 974 |
draw sim(z0 + 1/2plus_size * dir 90, z0 - 1/2plus_size * dir 90); |
| 975 |
endchar; |
| 976 |
|
| 977 |
beginoperator(med_op_size#, 1); "angle"; |
| 978 |
pickup rule_pen; |
| 979 |
|
| 980 |
z0 = centre - 1/3plus_size * dir 90; |
| 981 |
|
| 982 |
z1 = z0 + 1/2plus_size * dir 0; |
| 983 |
z2 = z0 - 1/2plus_size * dir 0; |
| 984 |
x3 = xpart centre + 1/2plus_size; |
| 985 |
y3 = ypart centre + 2/3plus_size; |
| 986 |
|
| 987 |
draw z1 -- z2 -- 5/6[z2,z3]; |
| 988 |
endchar; |
| 989 |
|
| 990 |
beginoperator(med_op_size#, 1); "measured angle"; |
| 991 |
pickup rule_pen; |
| 992 |
|
| 993 |
z0 = centre - 1/3plus_size * dir 90; |
| 994 |
|
| 995 |
z1 = z0 + 1/2plus_size * dir 0; |
| 996 |
z2 = z0 - 1/2plus_size * dir 0; |
| 997 |
x3 = xpart centre + 1/2plus_size; |
| 998 |
y3 = ypart centre + 2/3plus_size; |
| 999 |
|
| 1000 |
z4 = 2/3 [z2,z1]; |
| 1001 |
z5 = z2 + (z4 - z2) rotated angle (z3 - z2); |
| 1002 |
|
| 1003 |
draw z1 -- z2 -- 5/6[z2,z3]; |
| 1004 |
draw z4{dir 90} .. {dir (angle (z3 - z2) + 90)}z5; |
| 1005 |
endchar; |
| 1006 |
|
| 1007 |
beginoperator(med_op_size#, 1); "spherical angle"; |
| 1008 |
pickup rule_pen; |
| 1009 |
|
| 1010 |
z0 = centre - 1/2plus_size * dir 0; |
| 1011 |
|
| 1012 |
z1 = z0 + plus_size * dir 25; |
| 1013 |
z2 = z0 + plus_size * dir -25; |
| 1014 |
z3 = z0 + 2/3plus_size * dir 25; |
| 1015 |
z4 = z0 + 2/3plus_size * dir -25; |
| 1016 |
|
| 1017 |
draw z1 -- z0 -- z2; |
| 1018 |
draw z4{dir 65} .. {dir 115}z3; |
| 1019 |
endchar; |
| 1020 |
|
| 1021 |
beginsymbol(5.5u#, 4/5asc_height#, 0); "prime"; |
| 1022 |
pickup penrazor; |
| 1023 |
|
| 1024 |
z0 = (w, h); |
| 1025 |
|
| 1026 |
z1 = z0 + 7/3u * dir 183; |
| 1027 |
|
| 1028 |
z2 = (1u, 1/9h); |
| 1029 |
z3 = z2 + u * dir -20; |
| 1030 |
|
| 1031 |
fill z0 -- z1 -- z2 -- z3 -- cycle; |
| 1032 |
endchar; |
| 1033 |
|
| 1034 |
beginsymbol(5.5u#, 4/5asc_height#, 0); "backprime"; |
| 1035 |
pickup penrazor; |
| 1036 |
|
| 1037 |
z0 = (0, h); |
| 1038 |
|
| 1039 |
z1 = z0 + 7/3u * dir -3; |
| 1040 |
|
| 1041 |
z2 = (w - 1u, 1/9h); |
| 1042 |
z3 = z2 + u * dir 200; |
| 1043 |
|
| 1044 |
fill z0 -- z1 -- z2 -- z3 -- cycle; |
| 1045 |
endchar; |
| 1046 |
|
| 1047 |
for sign = 1, -1: |
| 1048 |
beginoperator(plus_size#, 1); "product"; |
| 1049 |
draw_product(centre, plus_size, plus_size, sign, rule_thickness); |
| 1050 |
endchar; |
| 1051 |
endfor; |
| 1052 |
|
| 1053 |
beginsymbol(13u# + 2side_bearing#, asc_height#, 0); "check mark"; |
| 1054 |
pickup pencircle |
| 1055 |
xscaled 3/2rule_thickness |
| 1056 |
yscaled 3/4rule_thickness |
| 1057 |
rotated 30; |
| 1058 |
|
| 1059 |
lft x1 = hround(1.5u); |
| 1060 |
x2 = hround(w/3); |
| 1061 |
x3 = w - x1; |
| 1062 |
x4 = w - 3/2x2; |
| 1063 |
|
| 1064 |
y1 = math_axis; |
| 1065 |
y2 = -d; |
| 1066 |
y3 = y4 = h; |
| 1067 |
|
| 1068 |
draw z1 -- z2{z4 - z2} .. z3; |
| 1069 |
|
| 1070 |
penlabels(1,2,3,4); |
| 1071 |
endchar; |
| 1072 |
|
| 1073 |
beginsymbol(6u# + 2side_bearing#, 5/4asc_height#, 1/8asc_height#); "lightning"; |
| 1074 |
|
| 1075 |
penpos1 (2rule_thickness, -20); |
| 1076 |
penpos4 (5/6rule_thickness, -20); |
| 1077 |
|
| 1078 |
x3r = w - side_bearing; |
| 1079 |
x2l = side_bearing; |
| 1080 |
x4 = 1/4w; |
| 1081 |
|
| 1082 |
y1l = h; |
| 1083 |
y3r = 14/24h; |
| 1084 |
y4 = -d + 1/2rule_thickness; |
| 1085 |
|
| 1086 |
z2'l = z2l; |
| 1087 |
z3'r = z3r; |
| 1088 |
|
| 1089 |
z3'l = z2l + whatever * dir 15; |
| 1090 |
z2'r = z3r + whatever * dir 15; |
| 1091 |
|
| 1092 |
z2r - z2l = 3/2rule_thickness * dir 15; |
| 1093 |
z3r - z3l = 2rule_thickness * dir 15; |
| 1094 |
z3'l = z3r + rule_thickness * dir (angle (z4r - z3r)); |
| 1095 |
|
| 1096 |
z1l - z2l = whatever * (z4r - z3r); |
| 1097 |
z2'r = whatever[z1l,z2l]; |
| 1098 |
|
| 1099 |
fill stroke z1e -- z2e -- z2'e -- z3'e -- z3e -- z4e; |
| 1100 |
|
| 1101 |
pickup rule_pen; |
| 1102 |
|
| 1103 |
draw arrowhead(z4, angle (z4l - z3l), 4/5arrow_spread); |
| 1104 |
|
| 1105 |
penlabels(1,2,2',3',3,4); |
| 1106 |
endchar; |
| 1107 |
|
| 1108 |
beginsymbol(11u#, 1/2[x_height#,asc_height#], 0) |
| 1109 |
"diamond suit"; |
| 1110 |
|
| 1111 |
x0 = x2 = w/2; |
| 1112 |
1/2[y0,y2] = h/2; |
| 1113 |
y2 - y0 = h; |
| 1114 |
|
| 1115 |
1/2[x1,x3] = w/2; |
| 1116 |
x3 - x1 = w - 2side_bearing; |
| 1117 |
y1 = y3 = h/2; |
| 1118 |
|
| 1119 |
pickup pencircle scaled rule_thickness; |
| 1120 |
|
| 1121 |
draw z0{dir (90+30)} .. {dir (180-30)}z1{dir (0+30)} |
| 1122 |
.. {dir (90-30)}z2{dir (270+30)} |
| 1123 |
.. {dir (0-30)}z3{dir (180+30)} |
| 1124 |
.. {dir (270-30)}z0 & cycle; |
| 1125 |
endchar; |
| 1126 |
|
| 1127 |
beginsymbol(11u#, 1/2[x_height#,asc_height#], 0) |
| 1128 |
"heart suit"; |
| 1129 |
|
| 1130 |
x0 = x1 = w/2; |
| 1131 |
y0 = 0; |
| 1132 |
|
| 1133 |
1/2[x2,x3] = w/2; |
| 1134 |
x3 - x2 = w - 2side_bearing; |
| 1135 |
|
| 1136 |
y1 = y2 = y3; |
| 1137 |
|
| 1138 |
x4 = 1/2[x1,x2]; |
| 1139 |
x5 = 1/2[x1,x3]; |
| 1140 |
|
| 1141 |
y4 = y5 = h; |
| 1142 |
|
| 1143 |
h - y1 = x4 - x2; |
| 1144 |
|
| 1145 |
pickup pencircle scaled rule_thickness; |
| 1146 |
|
| 1147 |
draw z0{dir (90+20)} .. z2 .. z4 .. {dir (270+20)}z1{dir (90-20)} .. z5 .. z3 .. {dir (270-20)}z0 & cycle; |
| 1148 |
endchar; |
| 1149 |
|
| 1150 |
beginsymbol(11u#, 1/2[x_height#,asc_height#], 0) |
| 1151 |
"spade suit"; |
| 1152 |
|
| 1153 |
x0 = x1 = w/2; |
| 1154 |
y0 = h + 1/2rule_thickness; |
| 1155 |
|
| 1156 |
1/2[x2,x3] = w/2; |
| 1157 |
x3 - x2 = w - 2side_bearing; |
| 1158 |
|
| 1159 |
y2 = y3; |
| 1160 |
|
| 1161 |
x4 = 1/2[x1,x2]; |
| 1162 |
x5 = 1/2[x1,x3]; |
| 1163 |
|
| 1164 |
y4 = y5 = 1/6h; |
| 1165 |
|
| 1166 |
y2 - y4 = x4 - x2; |
| 1167 |
|
| 1168 |
y1 = 1/3[y2,y4]; |
| 1169 |
|
| 1170 |
x6 = x0; |
| 1171 |
y6 = 0; |
| 1172 |
penpos1(1/2rule_thickness, 0); |
| 1173 |
penpos6(3/2rule_thickness, 0); |
| 1174 |
|
| 1175 |
pickup pencircle scaled rule_thickness; |
| 1176 |
|
| 1177 |
fill z0{dir (270-20)} .. z2 .. z4 .. {dir (90-20)}(z1 + 1/2rule_thickness*left) |
| 1178 |
-- (z1 + 1/2rule_thickness*right){dir (270+20)} .. z5 .. z3 .. {dir (90+20)}z0 -- cycle; |
| 1179 |
|
| 1180 |
fill stroke z1e -- z6e; |
| 1181 |
|
| 1182 |
labels (0,1,2,3,4,5,6); |
| 1183 |
endchar; |
| 1184 |
|
| 1185 |
beginsymbol(11u#, 1/2[x_height#,asc_height#], 0) |
| 1186 |
"club suit"; |
| 1187 |
|
| 1188 |
radius := 5/11(w - 4side_bearing); |
| 1189 |
|
| 1190 |
x0 = w/2; |
| 1191 |
y0 = h - 2.5radius; |
| 1192 |
|
| 1193 |
x1 = w - x3 = 3/5x0; |
| 1194 |
y1 = y3 = y0; |
| 1195 |
x2 = x4 = x0; |
| 1196 |
y2 = h - radius; |
| 1197 |
y4 = 0; |
| 1198 |
|
| 1199 |
penpos0(2/3rule_thickness, 0); |
| 1200 |
penpos1(2/3rule_thickness, 90); |
| 1201 |
penpos2(2/3rule_thickness, 0); |
| 1202 |
penpos3(2/3rule_thickness, 90); |
| 1203 |
penpos4(3/2rule_thickness, 0); |
| 1204 |
|
| 1205 |
fill circle(z1, radius); |
| 1206 |
fill circle(z2, radius); |
| 1207 |
fill circle(z3, radius); |
| 1208 |
|
| 1209 |
fill stroke z2e -- z0e{down} .. z4e; |
| 1210 |
fill stroke z1e -- z3e; |
| 1211 |
|
| 1212 |
labels (0,1,2,3,4); |
| 1213 |
endchar; |
| 1214 |
|
| 1215 |
beginsymbol(5/4order_width# + 2side_bearing#, asc_height#, 0); |
| 1216 |
"forall"; |
| 1217 |
pickup rule_pen; |
| 1218 |
|
| 1219 |
lft x0 = side_bearing; |
| 1220 |
rt x1 = w - side_bearing; |
| 1221 |
x2 = w/2; |
| 1222 |
|
| 1223 |
top y0 = top y1 = h; |
| 1224 |
bot y2 = 0; |
| 1225 |
|
| 1226 |
z4 = whatever [z0,z2]; |
| 1227 |
z5 = whatever [z1,z2]; |
| 1228 |
|
| 1229 |
y4 = y5 = x_height; |
| 1230 |
|
| 1231 |
draw z0 -- z2 -- z1; |
| 1232 |
|
| 1233 |
pickup pencircle scaled 8/9rule_thickness; |
| 1234 |
|
| 1235 |
draw z4 -- z5; |
| 1236 |
endchar; |
| 1237 |
|
| 1238 |
for negated = 0, 1: |
| 1239 |
beginsymbol(order_width# + 2side_bearing#, |
| 1240 |
if negated = 0: asc_height# else: asc_height# + 2/3equal_spread# fi, |
| 1241 |
if negated = 0: 0 else: 2/3equal_spread# fi); |
| 1242 |
"exists"; |
| 1243 |
|
| 1244 |
pickup rule_pen; |
| 1245 |
|
| 1246 |
lft x0 = lft x2 = side_bearing; |
| 1247 |
rt x1 = rt x3 = w - side_bearing; |
| 1248 |
|
| 1249 |
top y0 = top y1 = asc_height; |
| 1250 |
bot y2 = bot y3 = 0; |
| 1251 |
|
| 1252 |
z4 = 1/8[1/2[z0,z2], 1/2[z1,z3]]; |
| 1253 |
|
| 1254 |
draw z0 -- z1 -- z3 -- z2; |
| 1255 |
draw z4 -- 1/2[z1,z3]; |
| 1256 |
|
| 1257 |
if negated = 1: |
| 1258 |
stroke_through(1/2[1/2[z0,z2], 1/2[z1,z3]], h + d - stroke_through_thickness) |
| 1259 |
fi; |
| 1260 |
endchar; |
| 1261 |
endfor; |
| 1262 |
|
| 1263 |
beginsymbol(3/2order_width# + 2side_bearing#, vcentre(med_op_size#)); "nabla"; |
| 1264 |
pickup pencircle scaled 2/3rule_thickness; |
| 1265 |
|
| 1266 |
top y0 = top y1 = h; |
| 1267 |
bot y2 = -d; |
| 1268 |
|
| 1269 |
x0 = side_bearing; |
| 1270 |
x1 = w - side_bearing; |
| 1271 |
x2 = w/2; |
| 1272 |
|
| 1273 |
y3 = y4 = y0 - 2/3rule_thickness; |
| 1274 |
|
| 1275 |
z3 = whatever[z0,z2]; |
| 1276 |
z4 = whatever[z1,z2]; |
| 1277 |
z5 = whatever[z0,z1]; |
| 1278 |
z6 = whatever[z1,z2]; |
| 1279 |
|
| 1280 |
x5 - x0 = -2/3rule_thickness / sind (angle (z2 - z0)); |
| 1281 |
|
| 1282 |
z6 = z5 + whatever * (z2 - z0); |
| 1283 |
|
| 1284 |
draw z0 -- z1 -- z2 -- cycle; |
| 1285 |
filldraw z0 -- z3 -- z4 -- z1 -- cycle; |
| 1286 |
filldraw z0 -- z5 -- z6 -- z2 -- cycle; |
| 1287 |
endchar; |
| 1288 |
|
| 1289 |
beginsymbol(2order_width# + 2side_bearing#, x_height#, 0); "infinity"; |
| 1290 |
pickup rule_pen; |
| 1291 |
|
| 1292 |
lft x0 = side_bearing; |
| 1293 |
rt x1 = w - side_bearing; |
| 1294 |
|
| 1295 |
top y2 = top y4 = h; |
| 1296 |
bot y3 = bot y5 = d + rule_thickness; |
| 1297 |
|
| 1298 |
y0 = y1 = 1/2[y2,y3]; |
| 1299 |
|
| 1300 |
x2 = x3 = 1/5[x0,x1]; |
| 1301 |
x4 = x5 = 4/5[x0,x1]; |
| 1302 |
|
| 1303 |
penpos0 (rule_thickness, 180); |
| 1304 |
penpos1 (rule_thickness, 180); |
| 1305 |
penpos2 (3/2rule_thickness * cosd 30, 75); |
| 1306 |
penpos5 (3/2rule_thickness * cosd 30, 75); |
| 1307 |
penpos6 (3/2rule_thickness, 45); |
| 1308 |
penpos7 (3/2rule_thickness, 45); |
| 1309 |
penpos8 (3/2rule_thickness, 45); |
| 1310 |
penpos9 (6/5rule_thickness, 135); |
| 1311 |
penpos10(6/6rule_thickness, 135); |
| 1312 |
|
| 1313 |
z6 = 1/2[z0,z1]; |
| 1314 |
|
| 1315 |
z7 = point 1/3 of (z2{right} .. {dir -45}z6); |
| 1316 |
z8 = point 2/3 of (z6{dir -45} .. {right}z5); |
| 1317 |
z9 = point 7/12 of (z0{up} .. {right}z2); |
| 1318 |
z10 = point 5/12 of (z5{right} .. {up}z1); |
| 1319 |
|
| 1320 |
fill stroke z0e{up} .. {dir 45}z9e .. z2e{right} .. z7e |
| 1321 |
.. {dir -45}z6e .. z8e .. {right}z5e .. {dir 45}z10e .. {up}z1e; |
| 1322 |
|
| 1323 |
draw z1{dir 90} .. z4{dir 180} .. {dir 225}z6{dir 225} .. {dir 180}z3{dir 180} |
| 1324 |
.. {dir 90}z0; |
| 1325 |
penlabels(0,1,2,3,4,5,6,7,8,9,10); |
| 1326 |
endchar; |
| 1327 |
|
| 1328 |
beginsymbol(1/2order_width# + 2side_bearing#, |
| 1329 |
asc_height# + 2/3rule_thickness#, |
| 1330 |
2/3rule_thickness#); |
| 1331 |
"small integral"; |
| 1332 |
|
| 1333 |
pair centre; |
| 1334 |
centre := (w/2, (h - d)/2); |
| 1335 |
|
| 1336 |
draw_integral([0])(1/2, centre); |
| 1337 |
endchar; |
| 1338 |
|
| 1339 |
beginsymbol(order_width#, asc_height#, 0) |
| 1340 |
"flat"; |
| 1341 |
|
| 1342 |
x0 = x1 = x4 = side_bearing + rule_thickness; |
| 1343 |
y0 = 0; y1 = h; |
| 1344 |
x3 = w - side_bearing; |
| 1345 |
|
| 1346 |
y3 = 0.45[y0,y1]; |
| 1347 |
|
| 1348 |
y4 = 4/5x_height; |
| 1349 |
|
| 1350 |
penpos0(rule_thickness, 10); |
| 1351 |
penpos1(rule_thickness, 10); |
| 1352 |
penpos3(rule_thickness, 0); |
| 1353 |
|
| 1354 |
fill stroke z0e -- z1e; |
| 1355 |
|
| 1356 |
pickup pencircle scaled rule_thickness; |
| 1357 |
|
| 1358 |
draw z0{dir 40} .. {up}z3 .. {dir 230}z4; |
| 1359 |
|
| 1360 |
penlabels (0,1,3,4); |
| 1361 |
endchar; |
| 1362 |
|
| 1363 |
beginsymbol(order_width#, asc_height#, 0) |
| 1364 |
"natural"; |
| 1365 |
|
| 1366 |
x0 = x1 = w - x2 = w - x3 = side_bearing + 1/2rule_thickness; |
| 1367 |
x4 = x5 = w - x6 = w - x7 = side_bearing; |
| 1368 |
|
| 1369 |
y1 = y3 = h; |
| 1370 |
y7 = x_height; |
| 1371 |
y6l = 0; |
| 1372 |
y0 = y2 = -h/3; |
| 1373 |
|
| 1374 |
z6 = z4 + whatever * dir 15; |
| 1375 |
z5 = z7 + whatever * dir 15; |
| 1376 |
|
| 1377 |
z8 = whatever[z0,z1] = whatever[z4,z6]; |
| 1378 |
z9 = whatever[z2,z3] = whatever[z5,z7]; |
| 1379 |
|
| 1380 |
x10 = x0l; |
| 1381 |
x11 = x0l; |
| 1382 |
x12 = x2r; |
| 1383 |
x13 = x2r; |
| 1384 |
|
| 1385 |
z10 = whatever[z4,z6]; |
| 1386 |
z11 = whatever[z5,z7]; |
| 1387 |
z12 = whatever[z4,z6]; |
| 1388 |
z13 = whatever[z5,z7]; |
| 1389 |
|
| 1390 |
penpos0(rule_thickness, 10); |
| 1391 |
penpos1(rule_thickness, 10); |
| 1392 |
penpos2(rule_thickness, 10); |
| 1393 |
penpos3(rule_thickness, 10); |
| 1394 |
penpos4(5/4rule_thickness, 90); |
| 1395 |
penpos5(5/4rule_thickness, 90); |
| 1396 |
penpos6(5/4rule_thickness, 90); |
| 1397 |
penpos7(5/4rule_thickness, 90); |
| 1398 |
penpos8 (rule_thickness, 10); |
| 1399 |
penpos9 (rule_thickness, 10); |
| 1400 |
penpos10(5/4rule_thickness, 90); |
| 1401 |
penpos11(5/4rule_thickness, 90); |
| 1402 |
penpos12(5/4rule_thickness, 90); |
| 1403 |
penpos13(5/4rule_thickness, 90); |
| 1404 |
|
| 1405 |
fill stroke z1e -- z8e; |
| 1406 |
fill stroke z9e -- z2e; |
| 1407 |
fill stroke z10e -- z12e; |
| 1408 |
fill stroke z11e -- z13e; |
| 1409 |
|
| 1410 |
penlabels (0,1,2,3,4,5,6,7); |
| 1411 |
endchar; |
| 1412 |
|
| 1413 |
beginsymbol(order_width#, asc_height#, 0) |
| 1414 |
"sharp"; |
| 1415 |
|
| 1416 |
x0 = x1 = w - x2 = w - x3 = side_bearing + rule_thickness; |
| 1417 |
|
| 1418 |
x4 = x5 = w - x6 = w - x7 = side_bearing; |
| 1419 |
|
| 1420 |
y3 = h; |
| 1421 |
y7 = x_height; |
| 1422 |
y6l = 0; |
| 1423 |
y0 = -h/3; |
| 1424 |
|
| 1425 |
z2 = z0 + whatever * dir 20; |
| 1426 |
z1 = z3 + whatever * dir 20; |
| 1427 |
z6 = z4 + whatever * dir 15; |
| 1428 |
z5 = z7 + whatever * dir 15; |
| 1429 |
|
| 1430 |
penpos0(rule_thickness, 10); |
| 1431 |
penpos1(rule_thickness, 10); |
| 1432 |
penpos2(rule_thickness, 10); |
| 1433 |
penpos3(rule_thickness, 10); |
| 1434 |
penpos4(5/4rule_thickness, 90); |
| 1435 |
penpos5(5/4rule_thickness, 90); |
| 1436 |
penpos6(5/4rule_thickness, 90); |
| 1437 |
penpos7(5/4rule_thickness, 90); |
| 1438 |
|
| 1439 |
fill stroke z0e -- z1e; |
| 1440 |
fill stroke z2e -- z3e; |
| 1441 |
fill stroke z4e -- z6e; |
| 1442 |
fill stroke z5e -- z7e; |
| 1443 |
|
| 1444 |
penlabels (0,1,2,3,4,5,6,7); |
| 1445 |
endchar; |
| 1446 |
|
| 1447 |
beginsymbol(11u#, 0.85asc_height#, 0); "aleph"; |
| 1448 |
|
| 1449 |
pickup pencircle scaled 2/3rule_thickness; |
| 1450 |
|
| 1451 |
penpos 1(0, 65); |
| 1452 |
penpos 2(rule_thickness, 65); |
| 1453 |
penpos 3(rule_thickness, 65); |
| 1454 |
penpos 4(0, 65); |
| 1455 |
penpos 5(rule_thickness, 65); |
| 1456 |
penpos 6(rule_thickness, 65); |
| 1457 |
penpos 7(rule_thickness, 65); |
| 1458 |
penpos 8(rule_thickness, 65); |
| 1459 |
penpos 9(rule_thickness, 65); |
| 1460 |
penpos10(rule_thickness, 65); |
| 1461 |
penpos11(rule_thickness, 65); |
| 1462 |
penpos12(rule_thickness, 65); |
| 1463 |
penpos13(rule_thickness, 65); |
| 1464 |
|
| 1465 |
x1l = side_bearing; |
| 1466 |
x4r = w - side_bearing; |
| 1467 |
y1r = h; |
| 1468 |
y4l = 0; |
| 1469 |
|
| 1470 |
x2 - x1 = x4 - x3 = ceiling (u/2); |
| 1471 |
y1 - y2 = y3 - y4 = 2rule_thickness; |
| 1472 |
1/2[z2,z3] = (w/2,h/2); |
| 1473 |
|
| 1474 |
z5 = 0.24[z2,z3]; |
| 1475 |
z6 = 0.60[z2,z3]; |
| 1476 |
|
| 1477 |
x7 = x8 = x2; |
| 1478 |
x9 = x5; |
| 1479 |
y7 = min (y6, y5 - 3/2rule_thickness); |
| 1480 |
bot y8l = bot y9l = 0; |
| 1481 |
|
| 1482 |
x10 = x11 = 0.85[x2,x3]; |
| 1483 |
y10 = max (y5, y6 + 3/2rule_thickness); |
| 1484 |
|
| 1485 |
x12 = x3 + 2/3rule_thickness; |
| 1486 |
x13 = 1/4[x6,x10]; |
| 1487 |
|
| 1488 |
top y13r = h; |
| 1489 |
z12 = z13 + whatever * (z3-z2); |
| 1490 |
z11 = z13 + whatever * (z3-z2); |
| 1491 |
|
| 1492 |
y11r := y11; % prevent the stroke from sticking out at the other side |
| 1493 |
|
| 1494 |
filldraw stroke z1e{down} ... {z3e-z2e}z2e -- z3e{z3e-z2e} ... {down}z4e; |
| 1495 |
filldraw stroke z12e -- z13e; |
| 1496 |
|
| 1497 |
alpha := angle (z5 - z7); |
| 1498 |
beta := (alpha + 90)/2; |
| 1499 |
penpos5'(3/2rule_thickness * abs cosd (155 - alpha), alpha - 90); |
| 1500 |
penpos7'(3/2rule_thickness * abs cosd (155 - beta), beta - 90); |
| 1501 |
z5' = z5; |
| 1502 |
z7' = z7; |
| 1503 |
|
| 1504 |
% We don't need a filldraw since the stroke is that thin. |
| 1505 |
% A filldraw might cause "Strange path" errors in low resolutions. |
| 1506 |
|
| 1507 |
draw stroke z5'e{-dir alpha} .. {-dir beta}z7'e -- z8e; |
| 1508 |
filldraw stroke z8e -- z9e; |
| 1509 |
|
| 1510 |
alpha := angle (z10 - z6); |
| 1511 |
beta := (alpha + 90)/2; |
| 1512 |
penpos 6'(3/2rule_thickness * abs cosd (155 - alpha), alpha - 90); |
| 1513 |
penpos10'(3/2rule_thickness * abs cosd (155 - beta), beta - 90); |
| 1514 |
z6' = z6; |
| 1515 |
z10' = z10; |
| 1516 |
|
| 1517 |
draw stroke z6'e{dir alpha} .. {dir beta}z10'e -- z11e; |
| 1518 |
|
| 1519 |
penlabels(1,2,3,4,5,6,7,8,9,10,11,12,13,5',7'); |
| 1520 |
endchar; |
| 1521 |
|
| 1522 |
beginsymbol(11u#, 0.85asc_height#, 0); "beth"; |
| 1523 |
|
| 1524 |
pickup pencircle scaled 2/3rule_thickness; |
| 1525 |
|
| 1526 |
penpos1(0, 65); |
| 1527 |
penpos2(rule_thickness, 65); |
| 1528 |
penpos3(rule_thickness, 65); |
| 1529 |
penpos4(rule_thickness, 65); |
| 1530 |
penpos5(rule_thickness, 65); |
| 1531 |
penpos6(rule_thickness, 65); |
| 1532 |
penpos7(rule_thickness, 65); |
| 1533 |
|
| 1534 |
x1l = side_bearing + rule_thickness; |
| 1535 |
y1r = h; |
| 1536 |
x2 - x1 = ceiling (u/2); |
| 1537 |
y1 - y2 = 3/2rule_thickness; |
| 1538 |
y3 = y2; |
| 1539 |
|
| 1540 |
x3 = w - x2; |
| 1541 |
bot y5l = 0; |
| 1542 |
|
| 1543 |
x4r = w - side_bearing; |
| 1544 |
y3l - y4 = y1 - y2r; |
| 1545 |
|
| 1546 |
x5 = x4; |
| 1547 |
|
| 1548 |
x6 = w - x7l = side_bearing; |
| 1549 |
y6 = y7 = y5; |
| 1550 |
|
| 1551 |
filldraw stroke z1e{down} ... {z3e-z2e}z2e -- z3e{z3e-z2e} ... {down}z4e -- z5e; |
| 1552 |
filldraw stroke z6e -- z7e; |
| 1553 |
|
| 1554 |
penlabels(1,2,3,4,5,6,7); |
| 1555 |
endchar; |
| 1556 |
|
| 1557 |
beginsymbol(7u#, 0.85asc_height#, 0); "gimel"; |
| 1558 |
|
| 1559 |
pickup pencircle scaled 2/3rule_thickness; |
| 1560 |
|
| 1561 |
penpos1(0, 65); |
| 1562 |
penpos2(rule_thickness, 65); |
| 1563 |
penpos3(rule_thickness, 65); |
| 1564 |
penpos4(rule_thickness, 65); |
| 1565 |
penpos5(rule_thickness, 65); |
| 1566 |
penpos6(rule_thickness, 65); |
| 1567 |
penpos7(rule_thickness, 65); |
| 1568 |
penpos8(rule_thickness, 65); |
| 1569 |
|
| 1570 |
x1l = side_bearing + rule_thickness; |
| 1571 |
y1r = h; |
| 1572 |
x2 - x1 = ceiling (u/2); |
| 1573 |
y1 - y2 = 3/2rule_thickness; |
| 1574 |
|
| 1575 |
z3 = z2 + whatever * dir -25; |
| 1576 |
|
| 1577 |
x3 = w - x2; |
| 1578 |
|
| 1579 |
x4r = w - side_bearing - 1/3rule_thickness; |
| 1580 |
y3l - y4 = y1 - y2r; |
| 1581 |
|
| 1582 |
x5 = x4; |
| 1583 |
x6 = w - side_bearing; |
| 1584 |
|
| 1585 |
y5l = y8r; |
| 1586 |
bot y6l = 0; |
| 1587 |
|
| 1588 |
x7 = side_bearing; |
| 1589 |
rt x8r = lft x5l; |
| 1590 |
y7 = y8 = y6; |
| 1591 |
|
| 1592 |
filldraw stroke z1e{down} ... {z3e-z2e}z2e -- z3e{z3e-z2e} ... {down}z4e -- z5e .. z6e; |
| 1593 |
filldraw stroke z7e -- z8e; |
| 1594 |
|
| 1595 |
penlabels(1,2,3,4,5,6,7,8); |
| 1596 |
endchar; |
| 1597 |
|
| 1598 |
beginsymbol(11u#, 0.85asc_height#, 0); "daleth"; |
| 1599 |
|
| 1600 |
pickup pencircle scaled 2/3rule_thickness; |
| 1601 |
|
| 1602 |
penpos1(0, 65); |
| 1603 |
penpos2(rule_thickness, 65); |
| 1604 |
penpos3(rule_thickness, 65); |
| 1605 |
penpos4(1/2rule_thickness, 65); |
| 1606 |
penpos5(rule_thickness, 65); |
| 1607 |
|
| 1608 |
x1l = side_bearing; |
| 1609 |
y1r = h; |
| 1610 |
x2 - x1 = ceiling (u/2); |
| 1611 |
y1 - y2 = 3/2rule_thickness; |
| 1612 |
y2 = y3 = y4; |
| 1613 |
|
| 1614 |
x3 = w - side_bearing; |
| 1615 |
x4 = x3 - 3/2rule_thickness; |
| 1616 |
y5 = 0; |
| 1617 |
x5l = x4l; |
| 1618 |
|
| 1619 |
|
| 1620 |
filldraw stroke z1e{down} ... {z3e-z2e}z2e -- z3e{z3e-z2e}; |
| 1621 |
filldraw stroke z4e{down} ... z5e; |
| 1622 |
|
| 1623 |
penlabels(1,2,3,4,5); |
| 1624 |
endchar; |
| 1625 |
|
| 1626 |
|
| 1627 |
begingroup; |
| 1628 |
|
| 1629 |
save slant; |
| 1630 |
save currenttransform; |
| 1631 |
|
| 1632 |
slant := 0.212557; |
| 1633 |
|
| 1634 |
transform currenttransform; |
| 1635 |
|
| 1636 |
currenttransform := identity slanted slant yscaled aspect_ratio scaled granularity shifted (-u,0); |
| 1637 |
|
| 1638 |
beginsymbol(11u#, x_height#, 8/25asc_height#); |
| 1639 |
"Weierstrass p"; |
| 1640 |
|
| 1641 |
pickup pencircle scaled 1/2rule_thickness; |
| 1642 |
|
| 1643 |
numeric theta; |
| 1644 |
theta = 90-angle(8u,h); |
| 1645 |
slope := -h/8u; % angle at middle |
| 1646 |
superness := 1/sqrt 2; |
| 1647 |
superpull := 1/6; |
| 1648 |
|
| 1649 |
penpos2(1/2rule_thickness, -90); |
| 1650 |
penpos1(5/6rule_thickness,theta); |
| 1651 |
penpos7(1/2rule_thickness, -90); |
| 1652 |
|
| 1653 |
x2 + .5u = x1 = x7 - .5u = 3u; |
| 1654 |
top y2l = h; |
| 1655 |
bot y7r = -d; |
| 1656 |
y1 = .4[-d, h]; |
| 1657 |
|
| 1658 |
lft x3l = hround .5u; |
| 1659 |
rt x6r = hround max(rt x7 + .5, .5w - .25u); |
| 1660 |
|
| 1661 |
x3r - x3l = x6r - x6l = (hround 3/4rule_thickness) - 1/10rule_thickness; |
| 1662 |
|
| 1663 |
ellipse_set(2l,3l,4l,1l); |
| 1664 |
ellipse_set(2r,3r,4r,1r); |
| 1665 |
ellipse_set(7l,6l,5l,1l); |
| 1666 |
ellipse_set(7r,6r,5r,1r); |
| 1667 |
|
| 1668 |
y3 = y3r; |
| 1669 |
y6 = y6r; |
| 1670 |
|
| 1671 |
filldraw stroke super_arc.e(2,3) & z3e{down} .. z4e --- z5e .. z6e{down} & super_arc.e(6,7); % flourish |
| 1672 |
|
| 1673 |
penpos8(1/2rule_thickness, 180); |
| 1674 |
penpos9(1/2rule_thickness, 90); |
| 1675 |
penpos10(rule_thickness, 0); |
| 1676 |
penpos11(1/2rule_thickness, -90); |
| 1677 |
penpos12(1/2rule_thickness, -180); |
| 1678 |
penpos13(5/7rule_thickness, -180); |
| 1679 |
|
| 1680 |
rt x10r = hround(w - 1.5u + 1/2rule_thickness); |
| 1681 |
lft x12r = hround(.5w - .5u); |
| 1682 |
rt x8l = hround 2.25u; |
| 1683 |
x9 = x11 = max(x12l + eps, .5w + 1.5u); |
| 1684 |
y8 = 0; |
| 1685 |
top y9r = vround .95h; |
| 1686 |
y10 = .5[y9,y11]; |
| 1687 |
bot y11r = y8; |
| 1688 |
|
| 1689 |
filldraw stroke z7e{left} ... z8e{up} ... pulled_arc.e(9,10) & pulled_arc.e(10,11); % stem and bowl |
| 1690 |
|
| 1691 |
y13 - 5/7rule_thickness = .15h; |
| 1692 |
bulb(11,12,13); % bulb |
| 1693 |
|
| 1694 |
penlabels(1,2,3,4,5,6,7,8,9,10,11,12,13); |
| 1695 |
endchar; |
| 1696 |
|
| 1697 |
beginsymbol(11u#, 11/10asc_height#, 1/10asc_height#); |
| 1698 |
"powerset"; |
| 1699 |
|
| 1700 |
pickup pencircle scaled 1/2rule_thickness; |
| 1701 |
|
| 1702 |
numeric theta; |
| 1703 |
theta = 90 - angle(12/7*8u, h); |
| 1704 |
slope := -h/(12/7*8u); % angle at middle |
| 1705 |
superness := 1/sqrt 2; |
| 1706 |
superpull := 1/6; |
| 1707 |
|
| 1708 |
penpos2(1/2rule_thickness, -90); |
| 1709 |
penpos1(rule_thickness,theta); |
| 1710 |
penpos7(1/2rule_thickness, -90); |
| 1711 |
|
| 1712 |
x2 + .5u = x1 = x7 - .5u = 3u; |
| 1713 |
top y2l = h; |
| 1714 |
bot y7r = -d; |
| 1715 |
y1 = .4h; |
| 1716 |
|
| 1717 |
lft x3l = hround .5u; |
| 1718 |
rt x6r = hround max(rt x7 + .5, .5w - .25u); |
| 1719 |
|
| 1720 |
x3r - x3l = x6r - x6l = (hround 3/4rule_thickness) - 1/10rule_thickness; |
| 1721 |
|
| 1722 |
ellipse_set(2l,3l,4l,1l); |
| 1723 |
ellipse_set(2r,3r,4r,1r); |
| 1724 |
ellipse_set(7l,6l,5l,1l); |
| 1725 |
ellipse_set(7r,6r,5r,1r); |
| 1726 |
|
| 1727 |
y3 = y3r; |
| 1728 |
y6 = y6r; |
| 1729 |
|
| 1730 |
filldraw stroke super_arc.e(2,3) & z3e{down} .. z4e --- z5e .. z6e{down} & super_arc.e(6,7); % flourish |
| 1731 |
|
| 1732 |
penpos8(1/2rule_thickness, 180); |
| 1733 |
penpos9(1/2rule_thickness, 90); |
| 1734 |
penpos10(rule_thickness, 0); |
| 1735 |
penpos11(1/2rule_thickness, -90); |
| 1736 |
penpos12(1/2rule_thickness, -180); |
| 1737 |
penpos13(5/7rule_thickness, -180); |
| 1738 |
|
| 1739 |
rt x10r = hround(w - 1.5u + 1/2rule_thickness); |
| 1740 |
lft x12r = hround(.5w - .5u); |
| 1741 |
rt x8l = hround 2.25u; |
| 1742 |
x9 = x11 = max(x12l + eps, .5w + 1.5u); |
| 1743 |
y8 = 10/11*5/12h; |
| 1744 |
top y9r = vround .95h; |
| 1745 |
y10 = .5[y9,y11]; |
| 1746 |
bot y11r = y8; |
| 1747 |
|
| 1748 |
filldraw stroke z7e{left} ... z8e{up} ... pulled_arc.e(9,10) & pulled_arc.e(10,11); % stem and bowl |
| 1749 |
|
| 1750 |
y13 - 5/7rule_thickness = y8 + 1/10h; |
| 1751 |
bulb(11,12,13); % bulb |
| 1752 |
|
| 1753 |
penlabels(1,2,3,4,5,6,7,8,9,10,11,12,13); |
| 1754 |
endchar; |
| 1755 |
|
| 1756 |
endgroup; |
| 1757 |
|
| 1758 |
% Warning: The other two orientations are above. |
| 1759 |
% They should stay consistent. |
| 1760 |
|
| 1761 |
beginoperator(plus_size#, 1); "upside down logical not"; |
| 1762 |
pickup rule_pen; |
| 1763 |
|
| 1764 |
r := plus_size/2; % - 11/10rule_thickness; |
| 1765 |
|
| 1766 |
draw (centre + r * dir 180) -- (centre + r * dir 0) |
| 1767 |
-- (centre + r * dir 0 + equal_spread * dir 90); |
| 1768 |
endchar; |
| 1769 |
|
| 1770 |
beginoperator(plus_size#, 1); "upside down reversed logical not"; |
| 1771 |
pickup rule_pen; |
| 1772 |
|
| 1773 |
r := plus_size/2; % - 11/10rule_thickness; |
| 1774 |
|
| 1775 |
draw (centre + r * dir 180 + equal_spread * dir 90) |
| 1776 |
-- (centre + r * dir 180) -- (centre + r * dir 0) |
| 1777 |
endchar; |
| 1778 |
|
| 1779 |
for sign = 1, -1: |
| 1780 |
beginoperator(plus_size#, 1); "half square union"; |
| 1781 |
pickup rule_pen; |
| 1782 |
|
| 1783 |
z3 - z0 = z2 - z1 = plus_size * dir 0; |
| 1784 |
z0 - z1 = sign * plus_size * dir 90; |
| 1785 |
|
| 1786 |
1/2[1/2[z0,z1], 1/2[z2,z3]] = centre; |
| 1787 |
|
| 1788 |
draw z0 -- z1 -- z2; |
| 1789 |
endchar; |
| 1790 |
|
| 1791 |
beginoperator(plus_size#, 1); "half square union"; |
| 1792 |
pickup rule_pen; |
| 1793 |
|
| 1794 |
z3 - z0 = z2 - z1 = plus_size * dir 0; |
| 1795 |
z0 - z1 = sign * plus_size * dir 90; |
| 1796 |
|
| 1797 |
1/2[1/2[z0,z1], 1/2[z2,z3]] = centre; |
| 1798 |
|
| 1799 |
draw z1 -- z2 -- z3; |
| 1800 |
endchar; |
| 1801 |
endfor; |
| 1802 |
|
| 1803 |
for alpha = 0, 90, 180, 270: |
| 1804 |
beginoperator(plus_size#, 1); "closed curly wedge"; |
| 1805 |
pickup rule_pen; |
| 1806 |
|
| 1807 |
z0 = centre + 1/2plus_size * dir alpha; |
| 1808 |
z1 = centre - 1/2plus_size * dir alpha; |
| 1809 |
z2 = z1 + 1/2plus_size * dir (alpha + 90); |
| 1810 |
z3 = z1 - 1/2plus_size * dir (alpha + 90); |
| 1811 |
|
| 1812 |
draw z2{dir (alpha - 40)} |
| 1813 |
.. {dir alpha}z0{dir (alpha + 180)} |
| 1814 |
.. {dir (alpha - 140)}z3{dir (alpha + 40)} |
| 1815 |
.. {dir (alpha + 140)}z2 & cycle; |
| 1816 |
|
| 1817 |
endchar; |
| 1818 |
endfor; |
| 1819 |
|
| 1820 |
for alpha = 0, 90, 180, 270: |
| 1821 |
beginoperator(6/5plus_size#, 1); "slice"; |
| 1822 |
pickup rule_pen; |
| 1823 |
|
| 1824 |
z1 - 1/2[z0,z2] = plus_size * dir alpha; |
| 1825 |
|
| 1826 |
z2 - z0 = plus_size * dir (alpha + 90); |
| 1827 |
|
| 1828 |
7/12[z1,1/2[z0,z2]] = centre; |
| 1829 |
|
| 1830 |
draw z1 -- z0{dir (alpha + 120)} .. {dir (alpha + 60)}z2 -- cycle; |
| 1831 |
endchar; |
| 1832 |
endfor; |
| 1833 |
|
| 1834 |
beginoperator(5/6small_op_size#, 8/5); "small lozenge"; |
| 1835 |
pickup rule_pen; |
| 1836 |
|
| 1837 |
lft x0 = w - rt x2 = side_bearing; |
| 1838 |
y0 = y2 = ypart centre; |
| 1839 |
|
| 1840 |
x1 = x3 = xpart centre; |
| 1841 |
top y1 = h; |
| 1842 |
bot y3 = -d; |
| 1843 |
|
| 1844 |
draw z0 -- z1 -- z2 -- z3 -- cycle; |
| 1845 |
endchar; |
| 1846 |
|
| 1847 |
beginoperator(5/6small_op_size#, 8/5); "small filled lozenge"; |
| 1848 |
pickup rule_pen; |
| 1849 |
|
| 1850 |
lft x0 = w - rt x2 = side_bearing; |
| 1851 |
y0 = y2 = ypart centre; |
| 1852 |
|
| 1853 |
x1 = x3 = xpart centre; |
| 1854 |
top y1 = h; |
| 1855 |
bot y3 = -d; |
| 1856 |
|
| 1857 |
draw z0 -- z1 -- z2 -- z3 -- cycle; |
| 1858 |
fill z0 -- z1 -- z2 -- z3 -- cycle; |
| 1859 |
endchar; |
| 1860 |
|
| 1861 |
beginoperator(1/sqrt(2)*med_op_size#, 8/5); "medium lozenge"; |
| 1862 |
pickup rule_pen; |
| 1863 |
|
| 1864 |
lft x0 = w - rt x2 = side_bearing; |
| 1865 |
y0 = y2 = ypart centre; |
| 1866 |
|
| 1867 |
x1 = x3 = xpart centre; |
| 1868 |
top y1 = h; |
| 1869 |
bot y3 = -d; |
| 1870 |
|
| 1871 |
draw z0 -- z1 -- z2 -- z3 -- cycle; |
| 1872 |
endchar; |
| 1873 |
|
| 1874 |
beginoperator(1/sqrt(2)*med_op_size#, 8/5); "medium filled lozenge"; |
| 1875 |
pickup rule_pen; |
| 1876 |
|
| 1877 |
lft x0 = w - rt x2 = side_bearing; |
| 1878 |
y0 = y2 = ypart centre; |
| 1879 |
|
| 1880 |
x1 = x3 = xpart centre; |
| 1881 |
top y1 = h; |
| 1882 |
bot y3 = -d; |
| 1883 |
|
| 1884 |
draw z0 -- z1 -- z2 -- z3 -- cycle; |
| 1885 |
fill z0 -- z1 -- z2 -- z3 -- cycle; |
| 1886 |
endchar; |
| 1887 |
|
| 1888 |
beginoperator(1/sqrt(2)*large_op_size#, 8/5); "large lozenge"; |
| 1889 |
pickup rule_pen; |
| 1890 |
|
| 1891 |
lft x0 = w - rt x2 = side_bearing; |
| 1892 |
y0 = y2 = ypart centre; |
| 1893 |
|
| 1894 |
x1 = x3 = xpart centre; |
| 1895 |
top y1 = h; |
| 1896 |
bot y3 = -d; |
| 1897 |
|
| 1898 |
draw z0 -- z1 -- z2 -- z3 -- cycle; |
| 1899 |
endchar; |
| 1900 |
|
| 1901 |
for alpha = 0, 90, 180, 270: |
| 1902 |
beginoperator(med_op_size#, 1); "medium filled triangle (" & decimal alpha & ")"; |
| 1903 |
pickup rule_pen; |
| 1904 |
draw triangle(centre, w/2-side_bearing, alpha); |
| 1905 |
fill triangle(centre, w/2-side_bearing, alpha); |
| 1906 |
endchar; |
| 1907 |
endfor; |
| 1908 |
|
| 1909 |
beginoperator(med_op_size#/sqrt(2), 1); "medium filled square"; |
| 1910 |
pickup rule_pen; |
| 1911 |
draw square(centre, w/2 - side_bearing, 0); |
| 1912 |
fill square(centre, w/2 - side_bearing, 0); |
| 1913 |
endchar; |
| 1914 |
|
| 1915 |
|
| 1916 |
beginoperator(large_op_size#, 1); "large filled star"; |
| 1917 |
pickup rule_pen; |
| 1918 |
r := w/2 - side_bearing; |
| 1919 |
reg_poly_points(a)(5, centre, r, 90); |
| 1920 |
reg_poly_points(b)(5, centre, .4r, 126); |
| 1921 |
draw z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 1922 |
fill z.a0 -- z.b0 -- z.a1 -- z.b1 -- z.a2 -- z.b2 -- z.a3 -- z.b3 -- z.a4 -- z.b4 -- cycle; |
| 1923 |
endchar; |
| 1924 |
|
| 1925 |
beginoperator(med_op_size#, 1); "medium star of david"; |
| 1926 |
pickup pencircle scaled 4/5rule_thickness; |
| 1927 |
r := w/2 - side_bearing; |
| 1928 |
reg_poly_points(a)(6, centre, r, 90); |
| 1929 |
draw z.a0 -- z.a2 -- z.a4 -- cycle; |
| 1930 |
draw z.a1 -- z.a3 -- z.a5 -- cycle; |
| 1931 |
endchar; |
| 1932 |
|
| 1933 |
beginoperator(large_op_size#, 1); "large star of david"; |
| 1934 |
pickup rule_pen; |
| 1935 |
r := w/2 - side_bearing; |
| 1936 |
reg_poly_points(a)(6, centre, r, 90); |
| 1937 |
draw z.a0 -- z.a2 -- z.a4 -- cycle; |
| 1938 |
draw z.a1 -- z.a3 -- z.a5 -- cycle; |
| 1939 |
endchar; |
| 1940 |
|
| 1941 |
beginoperator(med_op_size#, 1); "maltese"; |
| 1942 |
pickup rule_pen; |
| 1943 |
|
| 1944 |
1/2[z0,z1] = centre + 1/2med_op_size * dir 180; |
| 1945 |
1/2[z2,z3] = centre + 1/2med_op_size * dir 270; |
| 1946 |
1/2[z4,z5] = centre + 1/2med_op_size * dir 0; |
| 1947 |
1/2[z6,z7] = centre + 1/2med_op_size * dir 90; |
| 1948 |
|
| 1949 |
z0 - z1 = z5 - z4 = 1/2med_op_size * up; |
| 1950 |
z3 - z2 = z6 - z7 = 1/2med_op_size * right; |
| 1951 |
|
| 1952 |
filldraw z1{dir 45} |
| 1953 |
.. {right}centre{down} |
| 1954 |
.. {dir 225}z2 -- z3{dir 135} |
| 1955 |
.. {up}centre{right} |
| 1956 |
.. {dir -45}z4 -- z5{dir 225} |
| 1957 |
.. {left}centre{up} |
| 1958 |
.. {dir 45}z6 -- z7{dir -45} |
| 1959 |
.. {down}centre{left} |
| 1960 |
.. z0{dir 135} -- cycle; |
| 1961 |
endchar; |
| 1962 |
|
| 1963 |
|
| 1964 |
current_char := 219; |
| 1965 |
|
| 1966 |
% Keep these consistent with the glyphs in Sym-Order.mf! |
| 1967 |
|
| 1968 |
for negated = 0, 1: |
| 1969 |
|
| 1970 |
vardef ifneg(text values) = |
| 1971 |
select(negated)(values) |
| 1972 |
enddef; |
| 1973 |
|
| 1974 |
beginorder(1, order_width# + rule_thickness#, ifneg(2,4) * equal_spread# + rule_thickness#); |
| 1975 |
"closedequal"; |
| 1976 |
pickup rule_pen; |
| 1977 |
|
| 1978 |
z2 - z1 = z1 - z0 = equal_spread * dir 90; |
| 1979 |
z5 - z4 = z4 - z3 = equal_spread * dir 90; |
| 1980 |
|
| 1981 |
1/2[z0, z2] = left_point; |
| 1982 |
1/2[z3, z5] = right_point; |
| 1983 |
|
| 1984 |
draw z0 -- z3; |
| 1985 |
draw z1 -- z4 -- z5 -- z2 -- cycle; |
| 1986 |
|
| 1987 |
if negated = 1: |
| 1988 |
stroke_through(centre, 4equal_spread); |
| 1989 |
fi; |
| 1990 |
endchar; |
| 1991 |
|
| 1992 |
beginorder(1, order_width# + rule_thickness#, ifneg(2,4) * equal_spread# + rule_thickness#); |
| 1993 |
"equalclosed"; |
| 1994 |
pickup rule_pen; |
| 1995 |
|
| 1996 |
z2 - z1 = z1 - z0 = equal_spread * dir 90; |
| 1997 |
z5 - z4 = z4 - z3 = equal_spread * dir 90; |
| 1998 |
|
| 1999 |
1/2[z0, z2] = left_point; |
| 2000 |
1/2[z3, z5] = right_point; |
| 2001 |
|
| 2002 |
draw z0 -- z3 -- z4 -- z1 -- cycle; |
| 2003 |
draw z2 -- z5; |
| 2004 |
|
| 2005 |
if negated = 1: |
| 2006 |
stroke_through(centre, 4equal_spread); |
| 2007 |
fi; |
| 2008 |
endchar; |
| 2009 |
|
| 2010 |
beginorder(1, order_width# + rule_thickness#, ifneg(2,4) * equal_spread# + rule_thickness#); |
| 2011 |
"equivclosed"; |
| 2012 |
pickup rule_pen; |
| 2013 |
|
| 2014 |
z2 - z1 = z1 - z0 = equal_spread * dir 90; |
| 2015 |
z5 - z4 = z4 - z3 = equal_spread * dir 90; |
| 2016 |
|
| 2017 |
1/2[z0, z2] = left_point; |
| 2018 |
1/2[z3, z5] = right_point; |
| 2019 |
|
| 2020 |
draw z0 -- z3 -- z5 -- z2 -- cycle; |
| 2021 |
draw (z1 + 1/4rule_thickness * right) -- (z4 + 1/4rule_thickness * left); |
| 2022 |
|
| 2023 |
if negated = 1: |
| 2024 |
stroke_through(centre, 4equal_spread); |
| 2025 |
fi; |
| 2026 |
endchar; |
| 2027 |
|
| 2028 |
for sign = 1, -1: |
| 2029 |
beginorder(sign, order_width# + rule_thickness#, |
| 2030 |
greater_spread# + ifneg(4/3, 8/3) * equal_spread# + rule_thickness#); |
| 2031 |
"less sim"; |
| 2032 |
|
| 2033 |
pickup rule_pen; |
| 2034 |
|
| 2035 |
z1 - z0 = greater_spread * dir 90; |
| 2036 |
y2 = 1/2[y0, y1]; |
| 2037 |
x0 = xpart right_point; |
| 2038 |
x2 = xpart left_point; |
| 2039 |
y3 = y4 = y0 - equal_spread; |
| 2040 |
x4 - x3 = sign * (x0 - x2); |
| 2041 |
1/2[x3,x4] = xpart centre; |
| 2042 |
|
| 2043 |
1/2[y1, y4 - 1/3equal_spread] = ypart centre; |
| 2044 |
|
| 2045 |
draw z0 -- z2 -- z1; |
| 2046 |
draw sim(z3, z4); |
| 2047 |
|
| 2048 |
if negated = 1: |
| 2049 |
stroke_through(centre, 8/3equal_spread + greater_spread); |
| 2050 |
fi; |
| 2051 |
endchar; |
| 2052 |
endfor; |
| 2053 |
|
| 2054 |
for sign = 1, -1: |
| 2055 |
beginorder(sign, order_width# + rule_thickness#, |
| 2056 |
greater_spread# + ifneg(7/3, 9/3) * equal_spread# + rule_thickness#); |
| 2057 |
"less approx"; |
| 2058 |
|
| 2059 |
pickup rule_pen; |
| 2060 |
|
| 2061 |
z1 - z0 = greater_spread * dir 90; |
| 2062 |
y2 = 1/2[y0, y1]; |
| 2063 |
x0 = xpart right_point; |
| 2064 |
x2 = xpart left_point; |
| 2065 |
y3 = y4 = y0 - equal_spread; |
| 2066 |
y5 = y6 = y4 - equal_spread; |
| 2067 |
x4 - x3 = sign * (x0 - x2); |
| 2068 |
1/2[x3,x4] = xpart centre; |
| 2069 |
x6 = x4; |
| 2070 |
x5 = x3; |
| 2071 |
|
| 2072 |
1/2[y1, y6 - 1/3equal_spread] = ypart centre; |
| 2073 |
|
| 2074 |
draw z0 -- z2 -- z1; |
| 2075 |
draw sim(z3, z4); |
| 2076 |
draw sim(z5, z6); |
| 2077 |
|
| 2078 |
if negated = 1: |
| 2079 |
stroke_through(centre, 9/3equal_spread + greater_spread); |
| 2080 |
fi; |
| 2081 |
endchar; |
| 2082 |
endfor; |
| 2083 |
|
| 2084 |
for sign = 1, -1: |
| 2085 |
beginorder(sign, order_width# + rule_thickness#, |
| 2086 |
greater_spread# + ifneg(1,3) * equal_spread# + rule_thickness#); |
| 2087 |
"slanted equal or less than"; |
| 2088 |
|
| 2089 |
pickup rule_pen; |
| 2090 |
|
| 2091 |
z0 - z1 = greater_spread * dir 90; |
| 2092 |
z3 - z2 = equal_spread * dir 90; |
| 2093 |
z4 - z0 = equal_spread * dir 90; |
| 2094 |
|
| 2095 |
1/2[z2, z3] = left_point; |
| 2096 |
1/2[z1, z4] = right_point; |
| 2097 |
|
| 2098 |
draw z0 -- z2 -- z1; |
| 2099 |
draw z3 -- z4; |
| 2100 |
|
| 2101 |
if negated = 1: |
| 2102 |
stroke_through(centre, 3equal_spread + greater_spread); |
| 2103 |
fi; |
| 2104 |
endchar; |
| 2105 |
endfor; |
| 2106 |
|
| 2107 |
for sign = 1, -1: |
| 2108 |
beginorder(sign, order_width# + rule_thickness#, |
| 2109 |
ifneg(1,3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#); |
| 2110 |
"curly equal or curly less than"; |
| 2111 |
|
| 2112 |
pickup rule_pen; |
| 2113 |
|
| 2114 |
t := 2/3[equal_spread, greater_spread]; |
| 2115 |
|
| 2116 |
z0 - z1 = equal_spread * dir 90; |
| 2117 |
z2 - z4 = 7/5equal_spread * dir 90; |
| 2118 |
z4 - z3 = t/2 * dir 90; |
| 2119 |
y1 = y3; |
| 2120 |
y4 = ypart centre + 1/2(t - equal_spread); |
| 2121 |
x0 = xpart left_point; |
| 2122 |
x2 = xpart right_point; |
| 2123 |
|
| 2124 |
path p; |
| 2125 |
|
| 2126 |
p = z0{z3 - z1} .. z2; |
| 2127 |
|
| 2128 |
v := xpart (p intersectiontimes (z4 -- (z4 + h * dir (90 + sign * 20)))); |
| 2129 |
|
| 2130 |
draw prec(z1, z3, t); |
| 2131 |
draw subpath (0,v) of p; |
| 2132 |
|
| 2133 |
if negated = 1: |
| 2134 |
stroke_through(centre, 3equal_spread + 2/3[equal_spread, greater_spread]); |
| 2135 |
fi; |
| 2136 |
|
| 2137 |
labels(0,1,2,3,4); |
| 2138 |
endchar; |
| 2139 |
endfor; |
| 2140 |
|
| 2141 |
for alpha = 0, 180: |
| 2142 |
beginarrow(alpha, 6/5, ifneg(14/10, 21/10) * arrow_spread#); "triple arrow (" & decimal alpha & ")"; |
| 2143 |
|
| 2144 |
z1 - z0 = z2 - z1 = z4 - z3 = z5 - z4 = 2/3equal_spread * dir (arrow_dir + 90); |
| 2145 |
|
| 2146 |
z1 = foot; |
| 2147 |
z4 = head; |
| 2148 |
|
| 2149 |
pickup pencircle scaled 4/5rule_thickness; |
| 2150 |
|
| 2151 |
draw z0 -- arrowhead_intersection(head, arrow_dir, 14/10arrow_spread, z0 -- z3); |
| 2152 |
draw z1 -- arrowhead_intersection(head, arrow_dir, 14/10arrow_spread, z1 -- z4); |
| 2153 |
draw z2 -- arrowhead_intersection(head, arrow_dir, 14/10arrow_spread, z2 -- z5); |
| 2154 |
|
| 2155 |
pickup rule_pen; |
| 2156 |
|
| 2157 |
draw arrowhead(head, arrow_dir, 14/10arrow_spread); |
| 2158 |
|
| 2159 |
if negated = 1: |
| 2160 |
stroke_through_arrow(1/2[foot, head - arrow_spread * dir arrow_dir], alpha, 21/10arrow_spread) |
| 2161 |
(70, 70, 110, 110, 70, 70, 110, 110); |
| 2162 |
fi |
| 2163 |
endchar; |
| 2164 |
endfor; |
| 2165 |
|
| 2166 |
endfor; |
| 2167 |
|
| 2168 |
for sign = -1, 1: |
| 2169 |
beginsymbol(4/3arrow_spread# + 2side_bearing#, vcentre(2arrow_spread# + rule_thickness#)); |
| 2170 |
"left shift"; |
| 2171 |
|
| 2172 |
pickup rule_pen; |
| 2173 |
|
| 2174 |
top y0 = top y1 = h - 1/2arrow_spread; |
| 2175 |
bot y2 = -d; |
| 2176 |
|
| 2177 |
1/2[x0,x1] = w/2; |
| 2178 |
x1 - x0 = sign * 4/3arrow_spread; |
| 2179 |
|
| 2180 |
x2 = x1; |
| 2181 |
|
| 2182 |
draw z0 -- z1 -- z2; |
| 2183 |
|
| 2184 |
draw arrowhead(z0, 90 + sign * 90, arrow_spread); |
| 2185 |
endchar; |
| 2186 |
endfor; |
| 2187 |
|
| 2188 |
for sign = -1, 1: |
| 2189 |
beginoperator(arrow_len#, 1); |
| 2190 |
"loop arrow"; |
| 2191 |
|
| 2192 |
pickup rule_pen; |
| 2193 |
|
| 2194 |
z0 = centre + sign * arrow_len/2 * left; |
| 2195 |
z1 = centre + arrow_len/2 * down; |
| 2196 |
z2 = centre + arrow_len/4 * up; |
| 2197 |
z3 = centre + sign * arrow_len/4 * right; |
| 2198 |
z4 = centre + arrow_len * (1/4sign, 1/2); |
| 2199 |
z5 = centre + arrow_len * (1/2sign, 1/4); |
| 2200 |
|
| 2201 |
draw z0 -- z3{sign * right} .. {up}z5 .. {sign * left}z4 .. {down}z2 -- z1; |
| 2202 |
|
| 2203 |
draw arrowhead(z0, 90 + sign * 90, arrow_spread); |
| 2204 |
endchar; |
| 2205 |
endfor; |
| 2206 |
|
| 2207 |
for sign = -1, 1: |
| 2208 |
beginoperator(plus_size#, 1); "three times"; |
| 2209 |
pickup rule_pen; |
| 2210 |
|
| 2211 |
r := plus_size/2; |
| 2212 |
r := r * 1/3[1, sqrt 2]; |
| 2213 |
|
| 2214 |
z0 = centre + r * dir (sign * 45); |
| 2215 |
z1 = centre + r * dir (sign * 225); |
| 2216 |
z2 = centre + r * dir (270 + sign * 45); |
| 2217 |
z3 = centre + 1/4rule_thickness * dir (270 + sign * 45); |
| 2218 |
|
| 2219 |
draw z0 -- z1; |
| 2220 |
draw z3 -- z2; |
| 2221 |
endchar; |
| 2222 |
endfor; |
| 2223 |
|
| 2224 |
beginarrow(0, 5/6, 7/4arrow_spread#); |
| 2225 |
"Vvdash"; |
| 2226 |
|
| 2227 |
pickup rule_pen; |
| 2228 |
|
| 2229 |
z0 = foot + 4/5equal_spread * dir arrow_dir; |
| 2230 |
z1 = foot + 8/5equal_spread * dir arrow_dir; |
| 2231 |
|
| 2232 |
draw z1 + 1/4rule_thickness * dir arrow_dir -- head; |
| 2233 |
draw (foot - 7/8arrow_spread * dir (arrow_dir + 90)) -- |
| 2234 |
(foot + 7/8arrow_spread * dir (arrow_dir + 90)); |
| 2235 |
draw (z0 - 7/8arrow_spread * dir (arrow_dir + 90)) -- |
| 2236 |
(z0 + 7/8arrow_spread * dir (arrow_dir + 90)); |
| 2237 |
draw (z1 - 7/8arrow_spread * dir (arrow_dir + 90)) -- |
| 2238 |
(z1 + 7/8arrow_spread * dir (arrow_dir + 90)); |
| 2239 |
|
| 2240 |
endchar; |
| 2241 |
|
| 2242 |
beginoperator(plus_size#, 1); "negated medium bar"; |
| 2243 |
pickup rule_pen; |
| 2244 |
|
| 2245 |
r := plus_size/2; % - 11/10rule_thickness; |
| 2246 |
|
| 2247 |
draw (centre + r * dir 90) -- (centre + r * dir 270); |
| 2248 |
|
| 2249 |
stroke_through_arrow(centre, 90, 2/3plus_size, 45); |
| 2250 |
endchar; |
| 2251 |
|
| 2252 |
beginoperator(plus_size#, 1); "double bar"; |
| 2253 |
pickup rule_pen; |
| 2254 |
|
| 2255 |
r := plus_size/2; % - 11/10rule_thickness; |
| 2256 |
|
| 2257 |
z1 - z0 = equal_spread * right; |
| 2258 |
1/2[z0,z1] = centre; |
| 2259 |
|
| 2260 |
draw (z0 + r * up) -- (z0 + r * down); |
| 2261 |
draw (z1 + r * up) -- (z1 + r * down); |
| 2262 |
endchar; |
| 2263 |
|
| 2264 |
beginoperator(plus_size#, 1); "negated double bar"; |
| 2265 |
pickup rule_pen; |
| 2266 |
|
| 2267 |
r := plus_size/2; % - 11/10rule_thickness; |
| 2268 |
|
| 2269 |
z1 - z0 = equal_spread * right; |
| 2270 |
1/2[z0,z1] = centre; |
| 2271 |
|
| 2272 |
draw (z0 + r * up) -- (z0 + r * down); |
| 2273 |
draw (z1 + r * up) -- (z1 + r * down); |
| 2274 |
|
| 2275 |
stroke_through_arrow(centre, 90, plus_size, 40); |
| 2276 |
endchar; |
| 2277 |
|