Debian Codegraph @

texmf-dist/fonts/source/public/mnsymbol/Sym-Order.mf

raw
1
2 % There are some additional order glyphs in Sym-Geometric. Keep them consistent!
3
4 vardef ifneg(text values) =
5 select(negated)(values)
6 enddef;
7
8 % equal signs
9
10 if negated < 2:
11 beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + rule_thickness#); "equal";
12 pickup rule_pen;
13
14 z1 - z0 = equal_spread * dir 90;
15 z3 - z2 = equal_spread * dir 90;
16
17 1/2[z0, z1] = left_point;
18 1/2[z2, z3] = right_point;
19
20 draw z0 -- z2;
21 draw z1 -- z3;
22
23 if negated = 1:
24 stroke_through(centre, 3equal_spread);
25 fi;
26 endchar;
27 fi;
28
29 if negated < 2:
30 beginorder(1, order_width# + rule_thickness#, ifneg(2,4) * equal_spread# + rule_thickness#); "equiv";
31 pickup rule_pen;
32
33 z2 - z1 = z1 - z0 = equal_spread * dir 90;
34 z5 - z4 = z4 - z3 = equal_spread * dir 90;
35
36 1/2[z0, z2] = left_point;
37 1/2[z3, z5] = right_point;
38
39 draw z0 -- z3;
40 draw z1 -- z4;
41 draw z2 -- z5;
42
43 if negated = 1:
44 stroke_through(centre, 4equal_spread);
45 fi;
46 endchar;
47 fi;
48
49 if negated < 2:
50 for sign = 1, -1:
51 beginorder(sign, order_width# + rule_thickness#, ifneg(2/3, 8/3)*equal_spread# + rule_thickness#); "sim";
52 pickup rule_pen;
53
54 draw sim(left_point, right_point);
55
56 if negated = 1:
57 stroke_through(centre, 8/3equal_spread);
58 fi;
59 endchar;
60 endfor;
61 fi;
62
63 if negated < 2:
64 for sign = 1, -1:
65 beginorder(sign, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#);
66 "approx";
67
68 pickup rule_pen;
69
70 draw sim(left_point + 1/2equal_spread * dir 90, right_point + 1/2equal_spread * dir 90);
71 draw sim(left_point - 1/2equal_spread * dir 90, right_point - 1/2equal_spread * dir 90);
72
73 if negated = 1:
74 stroke_through(centre, 11/3equal_spread);
75 fi;
76 endchar;
77 endfor;
78 fi;
79
80 if negated < 2:
81 for sign = 1, -1:
82 beginorder(sign, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
83 "triple sim";
84
85 pickup rule_pen;
86
87 draw sim(left_point + equal_spread * dir 90, right_point + equal_spread * dir 90);
88 draw sim(left_point, right_point);
89 draw sim(left_point - equal_spread * dir 90, right_point - equal_spread * dir 90);
90
91 if negated = 1:
92 stroke_through(centre, 14/3equal_spread);
93 fi;
94 endchar;
95 endfor;
96 fi;
97
98 if negated < 2:
99 for sign = 1, -1:
100 beginorder(sign, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#);
101 "sim equal";
102
103 pickup rule_pen;
104
105 draw sim(left_point + 1/2equal_spread * dir 90, right_point + 1/2equal_spread * dir 90);
106 draw (left_point - 5/6equal_spread * dir 90) -- (right_point - 5/6equal_spread * dir 90);
107
108 if negated = 1:
109 stroke_through(centre, 11/3equal_spread);
110 fi;
111 endchar;
112 endfor;
113 fi;
114
115 if negated < 2:
116 for sign = 1, -1:
117 beginorder(sign, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#); "equal sim";
118 pickup rule_pen;
119
120 draw (left_point + 5/6equal_spread * dir 90) -- (right_point + 5/6equal_spread * dir 90);
121 draw sim(left_point - 1/2equal_spread * dir 90, right_point - 1/2equal_spread * dir 90);
122
123 if negated = 1:
124 stroke_through(centre, 11/3equal_spread);
125 fi;
126 endchar;
127 endfor;
128 fi;
129
130 if negated < 2:
131 for sign = 1, -1:
132 beginorder(sign, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#); "cong";
133 pickup rule_pen;
134
135 draw sim(left_point + equal_spread * dir 90, right_point + equal_spread * dir 90);
136 draw (left_point - 1/3equal_spread * dir 90) -- (right_point - 1/3equal_spread * dir 90);
137 draw (left_point - 4/3equal_spread * dir 90) -- (right_point - 4/3equal_spread * dir 90);
138
139 if negated = 1:
140 stroke_through(centre, 14/3equal_spread);
141 fi;
142 endchar;
143 endfor;
144 fi;
145
146 if negated < 2:
147 for sign = 1, -1:
148 beginorder(sign, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
149 "approx equal";
150
151 pickup rule_pen;
152
153 draw sim(left_point + equal_spread * dir 90, right_point + equal_spread * dir 90);
154 draw sim(left_point, right_point);
155 draw (left_point - 4/3equal_spread * dir 90) -- (right_point - 4/3equal_spread * dir 90);
156
157 if negated = 1:
158 stroke_through(centre, 14/3equal_spread);
159 fi;
160 endchar;
161 endfor;
162 fi;
163
164 if negated < 2:
165 beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + 2/5order_width# + rule_thickness#);
166 "bump equal";
167
168 pickup rule_pen;
169
170 z1 - z0 = equal_spread * dir 90;
171 z3 - z2 = equal_spread * dir 90;
172
173 1/2[z0, z1] = left_point;
174 1/2[z2, z3] = right_point;
175
176 draw z0 -- z2;
177 draw z3 -- half_circle(1/2[z1,z3], order_width/5, 0) -- z1;
178
179 if negated = 1:
180 stroke_through(centre, 3equal_spread + 2/5order_width);
181 fi;
182 endchar;
183 fi;
184
185 if negated < 2:
186 beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + 2/5order_width# + rule_thickness#);
187 "equal bump";
188
189 pickup rule_pen;
190
191 z0 - z1 = equal_spread * dir 90;
192 z2 - z3 = equal_spread * dir 90;
193
194 1/2[z0, z1] = left_point;
195 1/2[z2, z3] = right_point;
196
197 draw z0 -- z2;
198 draw z1 -- half_circle(1/2[z1,z3], order_width/5, 180) -- z3;
199
200 if negated = 1:
201 stroke_through(centre, 3equal_spread + 2/5order_width);
202 fi;
203 endchar;
204 fi;
205
206 if negated < 2:
207 beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + 2/5order_width# + rule_thickness#);
208 "double bump equal";
209
210 pickup rule_pen;
211
212 z1 - z0 = equal_spread * dir 90;
213 z3 - z2 = equal_spread * dir 90;
214
215 1/2[z0, z1] = left_point;
216 1/2[z2, z3] = right_point;
217
218 draw z0 -- half_circle(1/2[z0,z2], order_width/5, 180) -- z2;
219 draw z3 -- half_circle(1/2[z1,z3], order_width/5, 0) -- z1;
220
221 if negated = 1:
222 stroke_through(centre, 3equal_spread + 2/5order_width);
223 fi;
224 endchar;
225 fi;
226
227 if negated < 2:
228 beginorder(1, order_width# + rule_thickness#,
229 3equal_spread# + ifneg(2dot_size#, equal_spread# + rule_thickness#));
230 "dot equal";
231
232 pickup rule_pen;
233
234 z1 - z0 = equal_spread * dir 90;
235 z3 - z2 = equal_spread * dir 90;
236
237 1/2[z0, z1] = left_point;
238 1/2[z2, z3] = right_point;
239
240 draw z0 -- z2;
241 draw z1 -- z3;
242 fill circle(centre + 3/2equal_spread * dir 90, dot_size);
243
244 if negated = 1:
245 stroke_through(centre, 4equal_spread);
246 fi;
247 endchar;
248 fi;
249
250 if negated < 2:
251 beginorder(1, order_width# + rule_thickness#,
252 3equal_spread# + ifneg(2dot_size#, equal_spread# + rule_thickness#));
253 "equal dot";
254
255 pickup rule_pen;
256
257 z1 - z0 = equal_spread * dir 90;
258 z3 - z2 = equal_spread * dir 90;
259
260 1/2[z0, z1] = left_point;
261 1/2[z2, z3] = right_point;
262
263 draw z0 -- z2;
264 draw z1 -- z3;
265 fill circle(centre - 3/2equal_spread * dir 90, dot_size);
266
267 if negated = 1:
268 stroke_through(centre, 4equal_spread);
269 fi;
270 endchar;
271 fi;
272
273 if negated < 2:
274 beginorder(1, order_width# + rule_thickness#,
275 3equal_spread# + ifneg(2dot_size#, equal_spread# + rule_thickness#));
276 "dot equal dot";
277
278 pickup rule_pen;
279
280 z1 - z0 = equal_spread * dir 90;
281 z3 - z2 = equal_spread * dir 90;
282
283 1/2[z0, z1] = left_point;
284 1/2[z2, z3] = right_point;
285
286 draw z0 -- z2;
287 draw z1 -- z3;
288 fill circle(centre + 3/2equal_spread * dir 90, dot_size);
289 fill circle(centre - 3/2equal_spread * dir 90, dot_size);
290
291 if negated = 1:
292 stroke_through(centre, 4equal_spread);
293 fi;
294 endchar;
295 fi;
296
297 if negated < 2:
298 for sign = 1, -1:
299 beginorder(sign, order_width# + rule_thickness#,
300 3equal_spread# + ifneg(2dot_size#, equal_spread# + rule_thickness#));
301 "falling dot equal";
302
303 pickup rule_pen;
304
305 z1 - z0 = equal_spread * dir 90;
306 z3 - z2 = equal_spread * dir 90;
307
308 1/2[z0, z1] = left_point;
309 1/2[z2, z3] = right_point;
310
311 draw z0 -- z2;
312 draw z1 -- z3;
313 fill circle(left_point + 3/2equal_spread * dir 90, dot_size);
314 fill circle(right_point - 3/2equal_spread * dir 90, dot_size);
315
316 if negated = 1:
317 stroke_through(centre, 4equal_spread);
318 fi;
319 endchar;
320 endfor;
321 fi;
322
323 for round_smile = true, false:
324
325 if negated < 2:
326 for sign = 1, -1:
327 beginorder(1, order_width# + rule_thickness#, ifneg(2/3, 8/3) * equal_spread# + rule_thickness#);
328 "smile";
329
330 pickup rule_pen;
331
332 draw smile(sign, left_point, right_point, 2/3equal_spread, round_smile);
333
334 if negated = 1:
335 stroke_through(centre, 8/3equal_spread);
336 fi;
337 endchar;
338 endfor;
339 fi;
340
341 if negated < 2:
342 for sign = 1, -1:
343 beginorder(1, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#); "double smile";
344 pickup rule_pen;
345
346 s := 1/2equal_spread;
347
348 draw smile(sign, left_point + s * dir 90, right_point + s * dir 90, 2/3equal_spread, round_smile);
349 draw smile(sign, left_point - s * dir 90, right_point - s * dir 90, 2/3equal_spread, round_smile);
350
351 if negated = 1:
352 stroke_through(centre, 11/3equal_spread);
353 fi;
354 endchar;
355 endfor;
356 fi;
357
358 if negated < 2:
359 for sign = 1, -1:
360 beginorder(1, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#); "triple smile";
361 pickup rule_pen;
362
363 s := equal_spread;
364
365 draw smile(sign, left_point + s * dir 90, right_point + s * dir 90, 2/3equal_spread, round_smile);
366 draw smile(sign, left_point, right_point, 2/3equal_spread, round_smile);
367 draw smile(sign, left_point - s * dir 90, right_point - s * dir 90, 2/3equal_spread, round_smile);
368
369 if negated = 1:
370 stroke_through(centre, 14/3equal_spread);
371 fi;
372 endchar;
373 endfor;
374 fi;
375
376 if negated < 2:
377 for sign = 1, -1:
378 beginorder(1, order_width# + rule_thickness#, ifneg(7/3, 13/3) * equal_spread# + rule_thickness#); "smile frown";
379 pickup rule_pen;
380
381 s := 5/6equal_spread;
382
383 draw smile(sign, left_point + s * dir 90, right_point + s * dir 90, 2/3equal_spread, round_smile);
384 draw smile(-sign, left_point - s * dir 90, right_point - s * dir 90, 2/3equal_spread, round_smile);
385
386 if negated = 1:
387 stroke_through(centre, 13/3equal_spread);
388 fi;
389 endchar;
390 endfor;
391 fi;
392
393 if negated < 2:
394 for sign = 1, -1:
395 beginorder(1, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#); "smile equal";
396 pickup rule_pen;
397
398 s := 1/6equal_spread;
399
400 draw smile(sign, left_point + 3s * dir 90, right_point + 3s * dir 90, 2/3equal_spread, round_smile);
401 draw (left_point - 5s * dir 90) -- (right_point - 5s * dir 90);
402
403 if negated = 1:
404 stroke_through(centre, 11/3equal_spread);
405 fi;
406 endchar;
407 endfor;
408 fi;
409
410 if negated < 2:
411 for sign = 1, -1:
412 beginorder(1, order_width# + rule_thickness#, ifneg(5/3, 11/3) * equal_spread# + rule_thickness#); "equal smile";
413 pickup rule_pen;
414
415 s := 1/6equal_spread;
416
417 draw (left_point + 5s * dir 90) -- (right_point + 5s * dir 90);
418 draw smile(sign, left_point - 3s * dir 90, right_point - 3s * dir 90, 2/3equal_spread, round_smile);
419
420 if negated = 1:
421 stroke_through(centre, 11/3equal_spread);
422 fi;
423 endchar;
424 endfor;
425 fi;
426
427 if negated < 2:
428 for sign = 1, -1:
429 beginorder(1, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
430 "double smile equal";
431
432 pickup rule_pen;
433
434 s := 1/6equal_spread;
435
436 draw smile(sign, left_point + 6s * dir 90, right_point + 6s * dir 90, 2/3equal_spread, round_smile);
437 draw smile(sign, left_point, right_point, 2/3equal_spread, round_smile);
438 draw (left_point - 8s * dir 90) -- (right_point - 8s * dir 90);
439
440 if negated = 1:
441 stroke_through(centre, 14/3equal_spread);
442 fi;
443 endchar;
444 endfor;
445 fi;
446
447 if negated < 2:
448 for sign = 1, -1:
449 beginorder(1, order_width# + rule_thickness#, ifneg(10/3, 16/3) * equal_spread# + rule_thickness#);
450 "smile equal frown";
451
452 pickup rule_pen;
453
454 s := 4/3equal_spread;
455
456 draw smile(sign, left_point + s * dir 90, right_point + s * dir 90, 2/3equal_spread, round_smile);
457 draw left_point -- right_point;
458 draw smile(-sign, left_point - s * dir 90, right_point - s * dir 90, 2/3equal_spread, round_smile);
459
460 if negated = 1:
461 stroke_through(centre, 16/3equal_spread);
462 fi;
463 endchar;
464 endfor;
465 fi;
466
467 % Only the round version since we have no free glyphs left.
468 if round_smile and (negated < 2):
469 for sign = 1, -1:
470 beginorder(1, order_width# + rule_thickness#, ifneg(10/3, 16/3) * equal_spread# + rule_thickness#);
471 "smile frown equal";
472
473 pickup rule_pen;
474
475 s := 1/6equal_spread;
476
477 draw smile(sign, left_point + 8s * dir 90, right_point + 8s * dir 90, 2/3equal_spread, round_smile);
478 draw smile(-sign, left_point - 1s * dir 90, right_point - 1s * dir 90, 2/3equal_spread, round_smile);
479 draw (left_point - 10s * dir 90) -- (right_point - 10s * dir 90);
480
481 if negated = 1:
482 stroke_through(centre, 16/3equal_spread);
483 fi;
484 endchar;
485 endfor;
486 fi;
487
488 endfor;
489
490 if negated < 2:
491 beginorder(1, order_width# + rule_thickness#, ifneg(1,3) * equal_spread# + rule_thickness#);
492 "equal circled";
493
494 pickup rule_pen;
495
496 z1 - z0 = equal_spread * dir 90;
497 z3 - z2 = equal_spread * dir 90;
498
499 1/2[z0, z1] = left_point;
500 1/2[z2, z3] = right_point;
501
502 draw z0 -- z2;
503 draw z1 -- z3;
504
505 pickup pencircle scaled 3/4rule_thickness;
506
507 draw circle(centre, 1/2equal_spread);
508
509 if negated = 1:
510 stroke_through(centre, 3equal_spread);
511 fi;
512 endchar;
513 fi;
514
515 if negated < 2:
516 beginorder(1, order_width# + rule_thickness#, 3equal_spread# + 7/2dot_size# + rule_thickness#);
517 "circ equal";
518
519 pickup rule_pen;
520
521 z1 - z0 = equal_spread * dir 90;
522 z3 - z2 = equal_spread * dir 90;
523
524 1/2[z0, z1] = left_point;
525 1/2[z2, z3] = right_point;
526
527 draw z0 -- z2;
528 draw z1 -- z3;
529
530 pickup pencircle scaled 3/4rule_thickness;
531
532 draw circle(centre + 3/2equal_spread * dir 90,
533 min (7/4dot_size, equal_spread - 3/4rule_thickness));
534
535 if negated = 1:
536 stroke_through(centre, 3equal_spread + 7/2dot_size);
537 fi;
538 endchar;
539 fi;
540
541 if negated < 2:
542 beginorder(1, order_width# + rule_thickness#, 3equal_spread# + 7/2dot_size# + rule_thickness#);
543 "triangle equal";
544
545 pickup rule_pen;
546
547 z1 - z0 = equal_spread * dir 90;
548 z3 - z2 = equal_spread * dir 90;
549
550 1/2[z0, z1] = left_point;
551 1/2[z2, z3] = right_point;
552
553 x4 = xpart centre;
554 y4 = y5 + sind 60 * (x6 - x5) = h - 1/2rule_thickness;
555
556 y5 = y6;
557 1/2[x5, x6] = xpart centre;
558
559 y5 - y1 = 2/3equal_spread;
560
561 draw z0 -- z2;
562 draw z1 -- z3;
563
564 pickup pencircle scaled 3/4rule_thickness;
565
566 draw z4 -- z5 -- z6 -- cycle;
567
568 if negated = 1:
569 stroke_through(centre, 3equal_spread + 7/2dot_size);
570 fi;
571 endchar;
572 fi;
573
574 if negated < 2:
575 beginorder(1, order_width# + rule_thickness#, 5/2equal_spread# + 7/2dot_size# + rule_thickness#);
576 "hat equal";
577
578 pickup rule_pen;
579
580 z1 - z0 = equal_spread * dir 90;
581 z3 - z2 = equal_spread * dir 90;
582
583 1/2[z0, z1] = left_point;
584 1/2[z2, z3] = right_point;
585
586 x4 = xpart centre;
587 y4 = y5 + sind 30 * (x6 - x5) = h - 1/2rule_thickness;
588
589 y5 = y6;
590 1/2[x5, x6] = xpart centre;
591
592 y5 - y1 = 2/3equal_spread;
593
594 draw z0 -- z2;
595 draw z1 -- z3;
596 draw z6 -- z4 -- z5;
597
598 if negated = 1:
599 stroke_through(centre, 3equal_spread + 7/2dot_size);
600 fi;
601 endchar;
602 fi;
603
604 % element signs
605
606 if negated < 2:
607 for sign = 1, -1:
608 beginorder(sign, 17/24order_width# + rule_thickness#,
609 ifneg(0,2) * equal_spread# + 8/9[equal_spread#, greater_spread#] + rule_thickness#);
610 "element";
611
612 pickup rule_pen;
613
614 s := 8/9[equal_spread, greater_spread];
615
616 z1 - z0 = s * dir 90;
617 1/2[z0, z1] = right_point;
618 z3 - z2 = s * dir 90;
619 1/2[z2, z3] = 7/10[left_point,right_point];
620
621 draw z0 -- z2{left_point - right_point} .. left_point .. {right_point - left_point}z3 -- z1;
622 draw left_point -- right_point;
623
624 if negated = 1:
625 stroke_through(centre, 2equal_spread + 8/9[equal_spread, greater_spread]);
626 fi;
627 endchar;
628 endfor;
629 fi;
630
631 % orderings
632
633 if negated < 2:
634 for sign = 1, -1:
635 beginorder(sign, order_width# + rule_thickness#,
636 ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
637 "less than";
638
639 pickup rule_pen;
640
641 z1 - z0 = greater_spread * dir 90;
642
643 1/2[z0, z1] = right_point;
644
645 draw z0 -- left_point -- z1;
646
647 if negated = 1:
648 stroke_through(centre, 2equal_spread + greater_spread);
649 fi;
650 endchar;
651 endfor;
652 fi;
653
654 if negated < 2:
655 for sign = 1, -1:
656 beginorder(sign, order_width# + rule_thickness#,
657 greater_spread# + ifneg(2/3, 8/3) * equal_spread# + rule_thickness#);
658 "less than or equal";
659
660 pickup rule_pen;
661
662 z1 - z0 = greater_spread * dir 90;
663 y2 = 1/2[y0, y1];
664 x2 = x3 = xpart left_point;
665 y3 = y4;
666 z0 - z4 = 2/3equal_spread * dir 90;
667
668 1/2[z1, z4] = right_point;
669
670 draw z0 -- z2 -- z1;
671 draw z3 -- z4;
672
673 if negated = 1:
674 stroke_through(centre, 8/3equal_spread + greater_spread);
675 fi;
676 endchar;
677 endfor;
678 fi;
679
680 if negated < 2:
681 for sign = 1, -1:
682 beginorder(sign, order_width# + rule_thickness#,
683 greater_spread# + ifneg(1,3) * equal_spread# + rule_thickness#);
684 "less than or slanted equal";
685
686 pickup rule_pen;
687
688 z1 - z0 = greater_spread * dir 90;
689 z2 - z3 = equal_spread * dir 90;
690 z0 - z4 = equal_spread * dir 90;
691
692 1/2[z2, z3] = left_point;
693 1/2[z1, z4] = right_point;
694
695 draw z0 -- z2 -- z1;
696 draw z3 -- z4;
697
698 if negated = 1:
699 stroke_through(centre, 3equal_spread + greater_spread);
700 fi;
701 endchar;
702 endfor;
703 fi;
704
705 if negated < 3:
706 for sign = 1, -1:
707 beginorder(sign, order_width# + rule_thickness#,
708 greater_spread# + ifneg(5/3, 11/3, 11/3) * equal_spread# + rule_thickness#);
709 "less than or double equal";
710
711 pickup rule_pen;
712
713 z1 - z0 = greater_spread * dir 90;
714 y2 = 1/2[y0, y1];
715 x2 = x3 = x5 = xpart left_point;
716 y3 = y4;
717 z0 - z4 = 2/3equal_spread * dir 90;
718 y5 = y6;
719 z4 - z6 = equal_spread * dir 90;
720
721 1/2[z1, z6] = right_point;
722
723 draw z0 -- z2 -- z1;
724 draw z3 -- z4;
725 draw z5 -- z6;
726
727 if negated = 1:
728 stroke_through(centre, 11/3equal_spread + greater_spread);
729 elseif negated = 2:
730 stroke_through(1/2[1/2[z3,z4], 1/2[z5,z6]], 3equal_spread);
731 fi;
732 endchar;
733 endfor;
734 fi;
735
736 if negated < 2:
737 for sign = 1, -1:
738 beginorder(sign, order_width# + rule_thickness#,
739 3/2greater_spread# + ifneg(1,3) * equal_spread# + rule_thickness#);
740 "less greater";
741
742 pickup rule_pen;
743
744 y1 - y0 = greater_spread;
745 y2 - y3 = equal_spread;
746 y0 - y4 = equal_spread;
747 y3 - y5 = greater_spread;
748
749 x2 = x3 = x5 = xpart left_point;
750 x0 = x1 = x4 = xpart right_point;
751
752 y2 = 1/2[y0, y1];
753
754 1/2[y1, y5] = ypart centre;
755
756 draw z0 -- z2 -- z1;
757 draw z3 -- z4 -- z5;
758
759 if negated = 1:
760 stroke_through(centre, 3equal_spread + 3/2greater_spread);
761 fi;
762 endchar;
763 endfor;
764 fi;
765
766 if negated < 2:
767 for sign = 1, -1:
768 beginorder(sign, order_width# + rule_thickness#,
769 2greater_spread# + ifneg(4/3, 10/3) * equal_spread# + rule_thickness#);
770 "less equal greater";
771
772 pickup rule_pen;
773
774 y2 - y0 = greater_spread;
775 x0 = x2 = xpart right_point;
776
777 y1 = 1/2[y0, y2];
778 x1 = xpart left_point;
779
780 y5 - y3 = greater_spread;
781 x3 = x5 = xpart left_point;
782
783 y4 = 1/2[y3, y5];
784 x4 = xpart right_point;
785
786 y0 - y5 = 4/3equal_spread;
787
788 1/2[y0, y5] = ypart centre;
789
790 draw z0 -- z1 -- z2;
791 draw z3 -- z4 -- z5;
792 draw left_point -- right_point;
793
794 if negated = 1:
795 stroke_through(centre, 10/3equal_spread + 2greater_spread);
796 fi;
797 endchar;
798 endfor;
799 fi;
800
801 if negated < 3:
802 for sign = 1, -1:
803 beginorder(sign, order_width# + rule_thickness#,
804 2greater_spread# + ifneg(7/3, 13/3, 13/3) * equal_spread# + rule_thickness#);
805 "less double equal greater";
806
807 pickup rule_pen;
808
809 y2 - y0 = greater_spread;
810 x0 = x2 = xpart right_point;
811
812 y1 = 1/2[y0, y2];
813 x1 = xpart left_point;
814
815 y5 - y3 = greater_spread;
816 x3 = x5 = xpart left_point;
817
818 y4 = 1/2[y3, y5];
819 x4 = xpart right_point;
820
821 y0 - y5 = 7/3equal_spread;
822
823 1/2[y0, y5] = ypart centre;
824
825 1/2[z6, z7] = left_point;
826 1/2[z8, z9] = right_point;
827
828 z7 - z6 = equal_spread * dir 90;
829 z9 - z8 = equal_spread * dir 90;
830
831 draw z0 -- z1 -- z2;
832 draw z3 -- z4 -- z5;
833 draw z6 -- z8;
834 draw z7 -- z9;
835
836 if negated = 1:
837 stroke_through(centre, 13/3equal_spread + 2greater_spread);
838 elseif negated = 2:
839 stroke_through(centre, 3equal_spread);
840 fi;
841 endchar;
842 endfor;
843 fi;
844
845 if negated < 2:
846 for sign = 1, -1:
847 beginorder(sign, order_width# + rule_thickness#,
848 3/2greater_spread# + ifneg(2,4) * equal_spread# + rule_thickness#);
849 "less slanted equal greater";
850
851 pickup rule_pen;
852
853 y2 - y0 = greater_spread;
854 x0 = x2 = xpart right_point;
855
856 y1 = 1/2[y0, y2];
857 x1 = xpart left_point;
858
859 y5 - y3 = greater_spread;
860 x3 = x5 = xpart left_point;
861
862 y4 = 1/2[y3, y5];
863 x4 = xpart right_point;
864
865 z6 = 1/2[z1, z5];
866 z7 = 1/2[z0, z4];
867
868 y1 - y6 = equal_spread;
869
870 1/2[y6, y7] = ypart centre;
871
872 draw z0 -- z1 -- z2;
873 draw z3 -- z4 -- z5;
874 draw z6 -- z7;
875
876 if negated = 1:
877 stroke_through(centre, 4equal_spread + 3/2greater_spread);
878 fi;
879 endchar;
880 endfor;
881 fi;
882
883
884 if negated < 2:
885 for sign = 1, -1:
886 beginorder(sign, order_width# + 2equal_spread# + rule_thickness#,
887 ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
888 "less less";
889
890 pickup rule_pen;
891
892 z1 - z0 = greater_spread * dir 90;
893 z3 - z5 = greater_spread * dir 90;
894 z2 = left_point;
895 z4 - z2 = sign * 2equal_spread * dir 0;
896 z3 - z1 = sign * 2equal_spread * dir 0;
897
898 1/2[z3, z5] = right_point;
899
900 draw z0 -- z2 -- z1;
901 draw z3 -- z4 -- z5;
902
903 if negated = 1:
904 stroke_through(centre, 2equal_spread + greater_spread);
905 fi;
906 endchar;
907 endfor;
908 fi;
909
910 if negated < 2:
911 for sign = 1, -1:
912 beginorder(sign, order_width# + 4equal_spread# + rule_thickness#,
913 ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
914 "less less less";
915
916 pickup rule_pen;
917
918 z1 - z0 = greater_spread * dir 90;
919 z3 - z5 = greater_spread * dir 90;
920 z6 - z8 = greater_spread * dir 90;
921 z2 = left_point;
922 z4 - z2 = sign * 2equal_spread * dir 0;
923 z3 - z1 = sign * 2equal_spread * dir 0;
924 z7 - z4 = sign * 2equal_spread * dir 0;
925 z6 - z3 = sign * 2equal_spread * dir 0;
926
927 1/2[z6, z8] = right_point;
928
929 draw z0 -- z2 -- z1;
930 draw z3 -- z4 -- z5;
931 draw z6 -- z7 -- z8;
932
933 if negated = 1:
934 stroke_through(centre, 2equal_spread + greater_spread);
935 fi;
936 endchar;
937 endfor;
938 fi;
939
940 if negated < 2:
941 for sign = 1, -1:
942 beginorder(sign, order_width# + rule_thickness#,
943 ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
944 "closed less than";
945
946 pickup rule_pen;
947
948 z1 - z0 = greater_spread * dir 90;
949
950 1/2[z0, z1] = right_point;
951
952 draw z0 -- left_point -- z1 -- cycle;
953
954 if negated = 1:
955 stroke_through(centre, 2equal_spread + greater_spread);
956 fi;
957 endchar;
958 endfor;
959 fi;
960
961 if negated < 2:
962 for sign = 1, -1:
963 beginorder(sign, order_width# + rule_thickness#,
964 greater_spread# + ifneg(2/3, 8/3) * equal_spread# + rule_thickness#);
965 "closed less than or equal";
966
967 pickup rule_pen;
968
969 z1 - z0 = greater_spread * dir 90;
970 y2 = 1/2[y0, y1];
971 x2 = x3 = xpart left_point;
972 y3 = y4;
973 z0 - z4 = 2/3equal_spread * dir 90;
974
975 1/2[z1, z4] = right_point;
976
977 draw z0 -- z2 -- z1 -- cycle;
978 draw z3 -- z4;
979
980 if negated = 1:
981 stroke_through(centre, 8/3equal_spread + greater_spread);
982 fi;
983 endchar;
984 endfor;
985 fi;
986
987 if negated < 2:
988 for sign = 1, -1:
989 beginorder(sign, order_width# + rule_thickness#,
990 1/2[equal_spread#, greater_spread#] + ifneg(0,2) * equal_spread# + rule_thickness#);
991 "square subset";
992
993 pickup rule_pen;
994
995 z1 - z0 = 1/2[equal_spread, greater_spread] * dir 90;
996 z3 - z2 = 1/2[equal_spread, greater_spread] * dir 90;
997
998 1/2[z0, z1] = left_point;
999 1/2[z2, z3] = right_point;
1000
1001 draw z3 -- z1 -- z0 -- z2;
1002
1003 if negated = 1:
1004 stroke_through(centre, 2equal_spread + 1/2[equal_spread, greater_spread]);
1005 fi;
1006 endchar;
1007 endfor;
1008 fi;
1009
1010 if negated < 3:
1011 for sign = 1, -1:
1012 beginorder(sign, order_width# + rule_thickness#,
1013 ifneg(1,3,3) * equal_spread# + 1/2[equal_spread#, greater_spread#] + rule_thickness#);
1014 "square subset equal";
1015
1016 pickup rule_pen;
1017
1018 z1 - z0 = 1/2[equal_spread, greater_spread] * dir 90;
1019 z3 - z2 = 1/2[equal_spread, greater_spread] * dir 90;
1020
1021 1/2[z1, z4] = left_point;
1022 1/2[z3, z5] = right_point;
1023
1024 y4 = y5 = y0 - equal_spread;
1025 x4 = x0;
1026 x5 = x2;
1027
1028 draw z3 -- z1 -- z0 -- z2;
1029 draw z4 -- z5;
1030
1031 if negated = 1:
1032 stroke_through(centre, 3equal_spread + 1/2[equal_spread, greater_spread]);
1033 elseif negated = 2:
1034 stroke_through(1/2[1/2[z0,z2], 1/2[z4,z5]], 3equal_spread);
1035 fi;
1036 endchar;
1037 endfor;
1038 fi;
1039
1040 if negated < 3:
1041 for sign = 1, -1:
1042 beginorder(sign, order_width# + rule_thickness#,
1043 ifneg(2,4,4) * equal_spread# + 1/2[equal_spread#, greater_spread#] + rule_thickness#);
1044 "square subset double equal";
1045
1046 pickup rule_pen;
1047
1048 z1 - z0 = 1/2[equal_spread, greater_spread] * dir 90;
1049 z3 - z2 = 1/2[equal_spread, greater_spread] * dir 90;
1050
1051 1/2[z1, z6] = left_point;
1052 1/2[z3, z7] = right_point;
1053
1054 y4 = y5 = y0 - equal_spread;
1055 y6 = y7 = y4 - equal_spread;
1056 x4 = x6 = x0;
1057 x5 = x7 = x2;
1058
1059 draw z3 -- z1 -- z0 -- z2;
1060 draw z4 -- z5;
1061 draw z6 -- z7;
1062
1063 if negated = 1:
1064 stroke_through(centre, 4equal_spread + 1/2[equal_spread, greater_spread]);
1065 elseif negated = 2:
1066 stroke_through(1/2[1/2[z4,z5], 1/2[z6,z7]], 3equal_spread);
1067 fi;
1068 endchar;
1069 endfor;
1070 fi;
1071
1072 if negated < 2:
1073 for sign = 1, -1:
1074 beginorder(sign, order_width# + rule_thickness#,
1075 ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
1076 "double square subset";
1077
1078 pickup rule_pen;
1079
1080 z1 - z0 = equal_spread * dir 90;
1081 z3 - z2 = equal_spread * dir 90;
1082
1083 1/2[z1, z0] = left_point + 3/4equal_spread * dir (90 - sign * 90);
1084 1/2[z3, z2] = right_point;
1085
1086 z5 - z4 = 8/3equal_spread * dir 90;
1087 z7 - z6 = 8/3equal_spread * dir 90;
1088
1089 1/2[z5, z4] = left_point;
1090 1/2[z7, z6] = right_point;
1091
1092 draw z3 -- z1 -- z0 -- z2;
1093 draw z7 -- z5 -- z4 -- z6;
1094
1095 if negated = 1:
1096 stroke_through(centre, 14/3equal_spread);
1097 fi;
1098 endchar;
1099 endfor;
1100 fi;
1101
1102 if negated < 2:
1103 for sign = 1, -1:
1104 beginorder(sign, order_width# + rule_thickness#,
1105 ifneg(0,2) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
1106 "subset";
1107
1108 pickup rule_pen;
1109
1110 draw subset(left_point, right_point, 2/3[equal_spread, greater_spread]);
1111
1112 if negated = 1:
1113 stroke_through(centre, 2equal_spread + 2/3[equal_spread, greater_spread]);
1114 fi;
1115 endchar;
1116 endfor;
1117 fi;
1118
1119 if negated < 3:
1120 for sign = 1, -1:
1121 beginorder(sign, order_width# + rule_thickness#,
1122 ifneg(1,3,3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
1123 "subset or equal";
1124
1125 pickup rule_pen;
1126
1127 t := 2/3[equal_spread, greater_spread];
1128 s := 1/2equal_spread + 1/2t;
1129
1130 z1 - z0 = z3 - z2 = (t/2 + equal_spread) * dir 90;
1131 y0 = y2 = ypart centre - s;
1132 x0 = xpart left_point;
1133 x2 = xpart right_point;
1134
1135 draw subset(z1, z3, t);
1136 draw z0 -- z2;
1137
1138 if negated = 1:
1139 stroke_through(centre, 3equal_spread + 2/3[equal_spread, greater_spread]);
1140 elseif negated = 2:
1141 stroke_through(1/2[z0,z2] + 1/2equal_spread * dir 90, 3equal_spread);
1142 fi;
1143 endchar;
1144 endfor;
1145 fi;
1146
1147 if negated < 3:
1148 for sign = 1, -1:
1149 beginorder(sign, order_width# + rule_thickness#,
1150 ifneg(2,4,4) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
1151 "subset or double equal";
1152
1153 pickup rule_pen;
1154
1155 t := 2/3[equal_spread, greater_spread];
1156 s := 1/2t;
1157
1158 z1 - z0 = z3 - z2 = (t/2 + equal_spread) * dir 90;
1159 y0 = y2 = ypart centre - s;
1160 x0 = xpart left_point;
1161 x2 = xpart right_point;
1162
1163 z0 - z4 = z2 - z5 = equal_spread * dir 90;
1164
1165 draw subset(z1, z3, t);
1166 draw z0 -- z2;
1167 draw z4 -- z5;
1168
1169 if negated = 1:
1170 stroke_through(centre, 4equal_spread + 2/3[equal_spread, greater_spread]);
1171 elseif negated = 2:
1172 stroke_through(1/2[1/2[z0,z2], 1/2[z4,z5]], 3equal_spread);
1173 fi;
1174 endchar;
1175 endfor;
1176 fi;
1177
1178 if negated < 2:
1179 for sign = 1, -1:
1180 beginorder(sign, order_width# + rule_thickness#, ifneg(8/3, 14/3) * equal_spread# + rule_thickness#);
1181 "double subset";
1182
1183 pickup rule_pen;
1184
1185 draw subset(left_point + 3/4equal_spread * dir (90 - sign * 90), right_point,
1186 equal_spread);
1187 draw subset(left_point, right_point, 8/3equal_spread);
1188
1189 if negated = 1:
1190 stroke_through(centre, 14/3equal_spread);
1191 fi;
1192 endchar;
1193 endfor;
1194 fi;
1195
1196 if negated < 2:
1197 for sign = 1, -1:
1198 beginorder(sign, order_width# + rule_thickness#,
1199 ifneg(0,2) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
1200 "curly less than";
1201
1202 pickup rule_pen;
1203
1204 draw prec(left_point, right_point, 2/3[equal_spread, greater_spread]);
1205
1206 if negated = 1:
1207 stroke_through(centre, 2equal_spread + 2/3[equal_spread, greater_spread]);
1208 fi;
1209 endchar;
1210 endfor;
1211 fi;
1212
1213 if negated < 2:
1214 for sign = 1, -1:
1215 beginorder(sign, order_width# + rule_thickness#,
1216 ifneg(2/3, 8/3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
1217 "curly less than or equal";
1218
1219 pickup rule_pen;
1220
1221 t := 2/3[equal_spread, greater_spread];
1222 s := 1/3equal_spread + 1/2t;
1223
1224 z1 - z0 = z3 - z2 = (t/2 + 2/3equal_spread) * dir 90;
1225 y0 = y2 = ypart centre - s;
1226 x0 = xpart left_point;
1227 x2 = xpart right_point;
1228
1229 draw prec(z1, z3, t);
1230 draw z0 -- z2;
1231
1232 if negated = 1:
1233 stroke_through(centre, 8/3equal_spread + 2/3[equal_spread, greater_spread]);
1234 fi;
1235 endchar;
1236 endfor;
1237 fi;
1238
1239 if negated < 2:
1240 for sign = 1, -1:
1241 beginorder(sign, order_width# + rule_thickness#,
1242 ifneg(1,3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
1243 "curly less than or curly equal";
1244
1245 pickup rule_pen;
1246
1247 t := 2/3[equal_spread, greater_spread];
1248
1249 z1 - z0 = equal_spread * dir 90;
1250 z4 - z2 = 7/5equal_spread * dir 90;
1251 z3 - z4 = t/2 * dir 90;
1252 y1 = y3;
1253 y4 = ypart centre - 1/2(t - equal_spread);
1254 x0 = xpart left_point;
1255 x2 = xpart right_point;
1256
1257 path p;
1258
1259 p = z0{z3 - z1} .. z2;
1260
1261 v := xpart (p intersectiontimes (z4 -- (z4 + h * dir (270 - sign * 20))));
1262
1263 draw prec(z1, z3, t);
1264 draw subpath (0,v) of p;
1265
1266 if negated = 1:
1267 stroke_through(centre, 3equal_spread + 2/3[equal_spread, greater_spread]);
1268 fi;
1269 endchar;
1270 endfor;
1271 fi;
1272
1273 if negated < 3:
1274 for sign = 1, -1:
1275 beginorder(sign, order_width# + rule_thickness#,
1276 ifneg(4/3, 10/3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
1277 "curly less sim";
1278
1279 pickup rule_pen;
1280
1281 t := 2/3[equal_spread, greater_spread];
1282 s := 1/3equal_spread + t/2;
1283
1284 z1 - z0 = z3 - z2 = (t/2 + equal_spread) * dir 90;
1285 y0 = y2 = ypart centre - s;
1286 x0 = xpart left_point;
1287 x2 = xpart right_point;
1288
1289 draw prec(z1, z3, t);
1290
1291 if sign > 0:
1292 draw sim(z0, z2);
1293 else:
1294 draw sim(z2, z0);
1295 fi
1296
1297 if negated = 1:
1298 stroke_through(centre, 10/3equal_spread + 2/3[equal_spread, greater_spread]);
1299 elseif negated = 2:
1300 stroke_through(1/2[z0,z2], 8/3equal_spread);
1301 fi;
1302 endchar;
1303 endfor;
1304 fi;
1305
1306 if negated < 3:
1307 for sign = 1, -1:
1308 beginorder(sign, order_width# + rule_thickness#,
1309 ifneg(7/3, 13/3, 13/3) * equal_spread# + 2/3[equal_spread#, greater_spread#] + rule_thickness#);
1310 "curly less approx";
1311
1312 pickup rule_pen;
1313
1314 t := 2/3[equal_spread, greater_spread];
1315 s := -1/6equal_spread + t/2;
1316
1317 z1 - z0 = z3 - z2 = (t/2 + equal_spread) * dir 90;
1318 y0 = y2 = ypart centre - s;
1319 x0 = xpart left_point;
1320 x2 = xpart right_point;
1321
1322 z0 - z4 = z2 - z5 = equal_spread * dir 90;
1323
1324 draw prec(z1, z3, t);
1325
1326 if sign > 0:
1327 draw sim(z0, z2);
1328 draw sim(z4, z5);
1329 else:
1330 draw sim(z2, z0);
1331 draw sim(z5, z4);
1332 fi
1333
1334 if negated = 1:
1335 stroke_through(centre, 13/3equal_spread + 2/3[equal_spread, greater_spread]);
1336 elseif negated = 2:
1337 stroke_through(1/2[1/2[z0,z2], 1/2[z4,z5]], 11/3equal_spread);
1338 fi;
1339 endchar;
1340 endfor;
1341 fi;
1342
1343 if negated < 2:
1344 for sign = 1, -1:
1345 beginorder(sign, order_width# + rule_thickness#,
1346 ifneg(0,2) * equal_spread# + greater_spread# + rule_thickness#);
1347 "less than dot";
1348
1349 pickup rule_pen;
1350
1351 z1 - z0 = greater_spread * dir 90;
1352
1353 1/2[z0, z1] = right_point;
1354
1355 draw z0 -- left_point -- z1;
1356 fill circle(right_point - sign * dot_size * dir 0, dot_size);
1357
1358 if negated = 1:
1359 stroke_through(centre, 2equal_spread + greater_spread);
1360 fi;
1361 endchar;
1362 endfor;
1363 fi;
1364
1365 if negated < 2:
1366 for sign = 1, -1:
1367 beginorder(sign, order_width# + rule_thickness#,
1368 greater_spread# + ifneg(2/3, 10/3) * equal_spread# + rule_thickness#);
1369 "less than or equal dot";
1370
1371 pickup rule_pen;
1372
1373 z1 - z0 = greater_spread * dir 90;
1374 y2 = 1/2[y0, y1];
1375 x2 = x3 = xpart left_point;
1376 y3 = y4;
1377 z0 - z4 = 2/3equal_spread * dir 90;
1378
1379 1/2[z1, z4] = right_point;
1380
1381 draw z0 -- z2 -- z1;
1382 draw z3 -- z4;
1383 fill circle(1/2[z0,z1] - sign * dot_size * dir 0, dot_size);
1384
1385 if negated = 1:
1386 stroke_through(centre, 10/3equal_spread + greater_spread);
1387 fi;
1388 endchar;
1389 endfor;
1390 fi;
1391
1392 if negated < 2:
1393 for sign = 1, -1:
1394 beginorder(sign, order_width# + rule_thickness#,
1395 greater_spread# + ifneg(1,3) * equal_spread# + rule_thickness#);
1396 "less than or slanted equal dot";
1397
1398 pickup rule_pen;
1399
1400 z1 - z0 = greater_spread * dir 90;
1401 z2 - z3 = equal_spread * dir 90;
1402 z0 - z4 = equal_spread * dir 90;
1403
1404 1/2[z2, z3] = left_point;
1405 1/2[z1, z4] = right_point;
1406
1407 draw z0 -- z2 -- z1;
1408 draw z3 -- z4;
1409 fill circle(1/2[z0,z1] - sign * dot_size * dir 0, dot_size);
1410
1411 if negated = 1:
1412 stroke_through(centre, 3equal_spread + greater_spread);
1413 fi;
1414 endchar;
1415 endfor;
1416 fi;
1417