summaryrefslogtreecommitdiff
path: root/macros/optex/pkg/math.opm
blob: 88bc81c627cbfdfc1a710f6822a50cac9a20900f (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
% This is macro package used by OpTeX, see http://petr.olsak.net/optex
% math.opm, Petr Olšák <petr@olsak.net>, 2022
% This file can serve as an template for other package files
% See end of the file for more information

\_def\_math_version {0.11, 2023-04-15}
\_codedecl \replacemissingchars {Doing math more comfortably <\_math_version>}
\_namespace{math}

   \_doc
   The `math` package provides options, they can be declared using
   the \`\mathset``{<options>}` macro. For example `\mathset {vert, dots}`.
   If you create your own package with options, provide a similar
   `\<pkg>set` macro. The \`\.kv` macro is similar to \OpTeX's `\kv`, but
   with specific `pkg:math` dictionary.
   \_cod

\_def\.mathset #1{%
   \_edef\.restorekvdict{\_kvdict{\_the\_kvdict}}%
   \_kvdict{pkg:math}%
      \_nokvx {\_opwarning{\_the\_kvdict: unknown option "##1", ignored}}%
      \_kvx {vert}     {\.smartvert}%     sets | as math active, to do better |x| or ||x||
      \_kvx {dots}     {\.smartdots}%     \dots behaves like \ldots or \cdots
      \_kvx {bfserif}  {\.bfserif}%       \bf, \bi select fonts with serifs
      \_kvx {mstyle}   {\.mstyle{##1}}%   sets mstyle=TeX or ISO or french or upright
      \_kvx {bstyle}   {\.bstyle{##1}}%   sets bstyle=TeX or ISO or upright or OpTeX
      \_kvx {rmchars}  {\.rmchars{##1}}%  does \.rmchars{<list>}
      \_kvx {vargreek} {\.vargreek{##1}}% does \.vargreek{<list>}
      \_kvx {text}     {\.dotext{##1}}%   does \.dotext{<list>}
      \_readkv{#1}%
   \.restorekvdict
}
\_def\.kv #1{\_trycs{_kv:pkg:math:#1}{\_kvunknown}}% for accessing values given by \mathset

\_nspublic \mathset ;

   \_doc
   \`\bigp`, \`\bbigp`, \`\Bigp`, \`\biggp`, \`\Biggp`, \`\autop`, \`\normalp` are inspired from
   \tricklink[bigp]{0094}
   \_cod

\_def\.bigp #1{\.fparam{#1}\_bigl\_bigr}
\_def\.bbigp #1{\.fparam{#1}\_bbigl\_bbigr}
\_def\.Bigp #1{\.fparam{#1}\_Bigl\_Bigr}
\_def\.biggp#1{\.fparam{#1}\_biggl\_biggr}
\_def\.Biggp#1{\.fparam{#1}\_Biggl\_Biggr}
\_def\.autop#1{\.fparam{#1}\_left\_right}
\_def\.normalp#1{\.fparam{#1}\_relax\_relax}
\_def\.fparam#1#2#3{%
   \_isequal .{#1}\_iffalse #1\_fi
   \_let\.bigleft=#2\_let\.bigright=#3\_nospacefuturelet\.next\.fparamA}
\_def\.fparamA{%
   \_casesof \.next
   (        {\.fparamB()}%
   [        {\.fparamB[]}%
   \{       {\.fparamB\{\}}%
   \_bgroup {\_def\.lparen{\{}\_def\.rparen{\}}\.fparamC}%
   \_finc   {}%
}
\_def\.fparamB#1#2{%
   \_def\.lparen{#1}\_def\.rparen{#2}%
   \_def\.next#1##1#2{\_trick_ensurebalanced#1#2\.fparamC{##1}}%
   \.next
}
\_def\.fparamC#1{%
   \_ifx\.bigleft\_left \_mathopen{}\_bgroup\_fi
   \.bigleft\.lparen{#1}\.bigright\.rparen
   \_ifx\.bigright\_right \_egroup\_fi
}
\_nspublic \bigp \bbigp \Bigp \biggp \Biggp \autop \normalp ;

   \_doc
   We need macro \`\.ensurebalanced``<open-b><close-b><macro>` for balancing nested parentheses from
   \tricklink[balancing]{0043}. We use `trick` namespace for these macros.
   \_cod

\_resetnamespace{trick}
   \_def\.ensurebalanced#1#2#3{\_immediateassigned{%
      \_def\.balopen{#1}\_def\.balclose{#2}\_let\.balaction=#3%
      \_def\.readnextbal##1##2#2{\.ensurebalancedA{##1#2##2}}}%
      \.ensurebalancedA}
   \_def\.ensurebalancedA#1{\.isbalanced#1%
      \_iftrue\_afterfi{\.balaction{#1}}\_else\_afterfi{\.readnextbal{#1}}\_fi}
   \_def\.isbalanced#1\_iftrue{\_immediateassignment\_tmpnum=0 \.isbalancedA#1{\.isbalanced}}
   \_def\.isbalancedA#1#{\.countbalanced#1\.isbalanced \.isbalancedB}
   \_def\.isbalancedB#1{%
      \_ifx\.isbalanced#1\_afterfi{\_cs{ifnum}\_tmpnum=0 }\_else\_ea\.isbalancedA\_fi}
   \_def\.countbalanced#1{\_ea\_ifx\.balopen #1\_immediateassignment\_incr\_tmpnum\_fi
                          \_ea\_ifx\.balclose#1\_immediateassignment\_decr\_tmpnum\_fi
                          \_ifx\.isbalanced#1\_else\_ea\.countbalanced\_fi}
\_resetnamespace{math}

   \_doc
   \`\smartdots` re-sets `\dots` to `\.dots`.
   The `\.dots` lets `\.next` using `\futurelet` and checks the `\.next`:
   It it is declared by `\_chardef` then `\.mchar` is the real Unicode character
   with `\chardef`ed code.
   If `\.next` is a real Unicode character then `\.mchar` includes it. This
   is done by the expandable \o`\cstochar` macro provided by \OpTeX/.
   If `\.next` is something else (i.e.\ `\.mchar` is empty) then print
   \o`\ldots` else print \o`\cdots` for Op, Bin, Rel, Open, Close math
   classes of the `\.next` math object or prints \o`\ldots` in other cases.
   \_cod

\_def\.smartdots {\_let\dots=\.dots}
\_def\.dots{\_relax \_ifmmode \_ea\.specdots \_else \_dots \_fi}
\_def\.specdots{\_futurelet\.next\.specdotsA}
\_def\.specdotsA{%
   \.ischardef\.next\_iftrue \_edef\.mchar{\_Uchar\.next}%
   \_else \_edef\.mchar{\_cstochar\.next}%
   \_fi
   \_ifx\.mchar\_empty \_ldots
   \_else \_Umathcharnumdef\.next=\_Umathcode\_ea`\.mchar \_relax
      \_ifcase \.readclass\.next
         \_ldots\_or \_cdots\_or \_cdots\_or \_cdots\_or \_cdots\_or \_cdots \_else \_ldots \_fi
   \_fi
}
\_def\.ischardef #1\_iftrue {\_ea\.ischardefA\_meaning#1\_fin}
\_def\.ischardefA #1#2#3#4#5#6\_fin {\_def\.tmpa{#1#2#3#4#5}\_ifx\.tmpa\.stringchar}
\_edef\.stringchar{\_string\char}
\_def\.readclass#1{\_ea\.readclassA\_meaning#1\_fin}
\_def\.readclassA#1"#2"#3\_fin{#2}

\_nspublic \smartdots ;

   \_doc
   \`\smartvert` sets `|` as math-active character and declares it
   equal to `\.autovert` macro. This macro checks two variants: there
   is single `|` or there is double `||`. It runs \`\.autovertA` or
   \`\.autoVertA`. These macros find the closing `|` or `||` and use
   `|` or `‖` in context of `\left`, `\right`. The \`\singlevert`
   is declared here if a user want to use a single vertical bar.
   \_cod

\_newpublic\_mathchardef \singlevert=\_mathcode`|
\_def\.autovert {\_isnextchar|{\.autoVertA}{\.autovertA}}
\_def\.autovertA #1|{\_mathopen{}\_mathclose{\_left|#1\_right|}}
\_def\.autoVertA|#1||{\_mathopen{}\_mathclose{\_left‖#1\_right‖}}
\_bgroup \_lccode`\~=`\| \_lowercase{\_egroup
   \_def\.smartvert{\_let~=\.autovert \_mathcode`|="8000 }}

\_nspublic \smartvert ;

   \_doc
   The control sequences \`\N`, \`\Z`, \`\Q`, \`\R`, \`\C`
   \`\sgn`, \`\argmin`, \`\argmax`, \`\grad`, \`\rank`, \`\tr`, \`\diag`, \`\Span`,
   \`\Rng`, \`\Null`, \`\Ker`, \`\Res`, \`\tg`, \`\cotg`, \`\arctg`, \`\arccotg`,
   \`\frac`, \`\dfrac`, \`\tfrac`, \`\.`
   are defined directly in the user space by \o`\_newpublic`.
   The \`\.pdef` is a shortcut for `\protected\def`.
   \_cod

\_def\.pdef{\_protected\_def}

\_newpublic\.pdef \N {{\_bbchar N}}
\_newpublic\.pdef \Z {{\_bbchar Z}}
\_newpublic\.pdef \Q {{\_bbchar Q}}
\_newpublic\.pdef \R {{\_bbchar R}}
\_newpublic\.pdef \C {{\_bbchar C}}

\_newpublic\.pdef \sgn     {\_mathop{\_rm sgn}\_nolimits}
\_newpublic\.pdef \argmin  {\_mathop{\_rm argmin}}
\_newpublic\.pdef \argmax  {\_mathop{\_rm argmax}}
\_newpublic\.pdef \grad    {\_mathop{\_rm grad}\_nolimits}
\_newpublic\.pdef \rank    {\_mathop{\_rm rank}\_nolimits}
\_newpublic\.pdef \tr      {\_mathop{\_rm tr}\_nolimits}
\_newpublic\.pdef \diag    {\_mathop{\_rm diag}\_nolimits}
\_newpublic\.pdef \Span    {\_mathop{\_rm Span}\_nolimits}
\_newpublic\.pdef \Rng     {\_mathop{\_rm Rng}\_nolimits}
\_newpublic\.pdef \Null    {\_mathop{\_rm Null}\_nolimits}
\_newpublic\.pdef \Ker     {\_mathop{\_rm Ker}\_nolimits}
\_newpublic\.pdef \Res     {\_mathop{\_rm Res}\_nolimits}
\_newpublic\.pdef \tg      {\_mathop{\_rm tg}\_nolimits}
\_newpublic\.pdef \cotg    {\_mathop{\_rm cotg}\_nolimits}
\_newpublic\.pdef \arctg   {\_mathop{\_rm arctg}\_nolimits}
\_newpublic\.pdef \arccotg {\_mathop{\_rm arccotg}\_nolimits}

\_newpublic\.pdef \frac  #1#2{{{#1}\_over#2}}
\_newpublic\.pdef \dfrac #1#2{{\_displaystyle{{#1}\_over#2}}}
\_newpublic\.pdef \tfrac #1#2{{\_textstyle{{#1}\_over#2}}}

\_newpublic\.pdef \.#1{{\_bf#1}}

   \_doc
   \`\eqsystem``{<equations>}` saves its parameter to `\.tmpb`
   and does a collection of `\_replstring`s. It replaces all spaces by `&`
   (but ignores the optional first and last space), it removes spaces before `\cr`,
   it precedes `\mathord` before all `-`
   (but not if the minus is alone in the column) and runs `\halign`.
   The \n`\baselineskip` is enlarged by \O`\openup`\`\eqskip`.
   Each item adds 0.5\`\eqsep` around it and \`\eqfil` to the left side and
   `\hfil` to the right side.
   \_cod

\_protected \_optdef\.eqsystem[]#1{\_vcenter{%
   \_def\.tmpb{\.bb#1\.bb}\_replstring\.tmpb{ }{&}%
   \_replstring\.tmpb{\.bb&}{}\_replstring\.tmpb{&\.bb}{}\_replstring\.tmpb{&\cr}{\cr}%
   \_replstring\.tmpb{-}{\_mathord-}\_replstring\.tmpb{&\_mathord-&}{&-&}%
   \_let ~=\_relax
   \_the\_opt \_relax \_openup\.eqskip
   \_halign{&\_the\.eqfil\_kern.5\.eqsep$\_displaystyle{{}##{}}$\_kern.5\.eqsep\_hfil\_cr
            \.tmpb\_crcr}%
}}
\_let\.bb=\_empty
\_newdimen\.eqskip
\_newdimen\.eqsep
\_newtoks\.eqfil   \.eqfil={\_hfill}
\_nspublic \eqsystem \eqskip \eqsep \eqfil ;

   \_doc
   The \`\toright` and  \`\toleft` macros are based on the
   \o`\setpos` and \o`\posx` macros. The printing point is shifted by `\posx`
   to the left (i.e.\ to the left boundary of the sheet) and then it is shifted
   to the desired space by `\kern\hoffset+\hsize`.
   This idea is moved from \tricklink[torighteq]{0028}.
   \_cod

\_newcount \.tomarginno
\_def\.toright #1{\_incr\.tomarginno {\_setpos[_math_tr:\_the\.tomarginno]%
   \_rlap{\_kern-\_posx[_math_tr:\_the\.tomarginno]\_kern\_hoffset\_kern\_hsize\_llap{#1}}}}
\_def\.toleft #1{\_incr\.tomarginno {\_setpos[_math_tr:\_the\.tomarginno]%
   \_rlap{\_kern-\_posx[_math_tr:\_the\.tomarginno]\_kern\_hoffset\_rlap{#1}}}}

\_nspublic \toright \toleft ;

   \_doc
   The \`\subeqmark` works because the internal \O`\_thednum`
   is re-defined. The \`\.dnumpost` is added here. If you want to use another format
   for \O`\_thednum` then you have to add the \^`\.dnumpost` to it too.
   \_cod

\_def \_thednum    {(\_the\_dnum \.dnumpost)}
\_def\.dnumpost{}
\_def\.subeqmark #1{\_def\.dnumpost{#1}\_lowercase{\_ifx a#1}\_else \_decr\_dnum\_fi \_eqmark}

\_nspublic \subeqmark ;

   \_doc
   \`\bfserif` re-defines internal \OpTeX/ \O`\_mabf` and \O`\_mabi` macros.
   \_cod

\_def\.bfserif{%
   \_protected\_def\_mabf {\_inmath{\_bfvariables\_bfgreek\_bfGreek\_bfdigits}}%
   \_protected\_def\_mabi {\_inmath{\_bivariables\_bigreek\_bfGreek\_bfdigits}}%
}

\_nspublic \bfserif ;

   \_doc
   The options `mstyle`, resp. `bstyle` run \`\.mstyle`, resp. \`\.bstyle`
   and these macros set required shapes of math variables. This can be done
   only when Unicode-math is loaded already. This is a reason why
   \`\.unionly``{<code>}{<text>}` is used: it runs <code> only when
   Unicode-math is loaded, otherwise it prints a warning.
   \_cod

\_def\.mstyle #1{\.unionly{\_lowercase{\_cs{_math_mstyle_#1}}}{mstyle}}
\_def\.bstyle #1{\.unionly{\_lowercase{\_cs{_math_bstyle_#1}}}{bstyle}}

\_def\.mstyle_tex {%
   \_protected\_def\_mit {\_itvariables \_rmdigits \_itgreek \_rmGreek}\_mit
}
\_def\.mstyle_iso {%
   \_protected\_def\_mit {\_itvariables \_rmdigits \_itgreek \_itGreek}\_mit
}
\_def\.mstyle_french {%
   \_protected\_def\_mit {\_umathrange{A-Z}71\_ncharrmA \_umathrange{a-z}71\_ncharita
                          \_rmdigits \_rmgreek \_rmGreek}%
   \_mit
}
\_def\.mstyle_upright {%
   \_protected\_def\_mit {\_rmvariables \_rmdigits \_rmgreek \_rmGreek}\_mit
}
\_def\.bstyle_tex {%
   \_protected\_def\_mabf {\_inmath{\_bfvariables\_bigreek\_bfGreek\_bfdigits}}%
   \_protected\_def\_mabi {\_inmath{\_bivariables\_bigreek\_bfGreek\_bidigits}}%
}
\_def\.bstyle_optex {%
   \_protected\_def\_mabf {\_inmath{\_bsansvariables \_bsansgreek \_bsansGreek \_bsansdigits}}%
   \_protected\_def\_mabi {\_inmath{\_bisansvariables \_bisansgreek \_bsansGreek \_bsansdigits}}%
}
\_def\.bstyle_iso {%
   \_protected\_def\_mabf {\_inmath{\_bivariables\_bigreek\_biGreek\_bfdigits}}%
   \_protected\_def\_mabi {\_inmath{\_bivariables\_bigreek\_bfGreek\_bidigits}}%
}
\_def\.bstyle_upright {%
   \_protected\_def\_mabf {\_inmath{\_bfvariables\_bfgreek\_bfGreek\_bfdigits}}%
   \_protected\_def\_mabi {\_inmath{\_bivariables\_bigreek\_biGreek\_bidigits}}%
}
\_def\.unionly #1#2{\_ifx\_rmvariables\_undefined
   \_opwarning{pkg:math: Unicode-math must be loaded first, \_string#2 ignored}%
   \_else \_afterfi{#1}\_fi
}

   \_doc
   \`\rmchars``{<list>}` is implemented using \O`\foreach`. The list is
   expanded first because we want to expand control sequences like `\alpha`
   to a real character $\_rmgreek \alpha$.\nl
   \`\vargreek``{<list>}` is implemented using \O`\foreach`. The
   parameter is not expanded because we want to keep control sequences like
   `\alpha` unchanged.
   \_cod

\_def\.rmchars#1{\_ea\_foreach \_expanded{#1}\_do{\_ifx,##1\_else\.rmchar##1\_fi}}
\_def\.rmchar#1{\_Umathcode`#1=0 1 `#1 }

\_def\.vargreek#1{\_foreach#1\_do{\_ifx,##1\_else \.vargreekchar##1\_fi}}
\_def\.vargreekchar#1{%
   \_ifcsname var\_csstring#1\_endcsname \_slet{\_csstring#1}{var\_csstring#1}%
   \_else \_opwarning{\_string\vargreek: the \_bslash var\_csstring#1\_space doesn't exists}%
   \_fi
}
\_nspublic \rmchars \vargreek ;

   \_doc
   \`\textvariables`, \`\textdigits`, \`\textmoremath` initialize
   new two families 5, 6 using `\.textmathini` and sets `\mathcode`s
   of given characters to these families.
   Moreover, `\textvariables` adds `\fam` register setting to `\rm` and `\it`
   selectors and re-set Greek variables to use only math font (because we
   are not sure if Greek letters are in the current text fonts).\nl
   \`\.dotext``{<list of words>}` runs `\.text<word>` for each <word> in the list.
   It is used when the option `text={<list of words>}` is used.
   \_cod

\_def\.textmathini{%
   \_fontdef\.mathrm{\_rm}\_fontdef\.mathit{\_it}%
   \_fontdef\.mathbf{\_bf}\_fontdef\.mathbi{\_bi}%
   \_addto\_normalmath{%
      \_setmathfamily    5 \.mathrm
      \_setmathfamily    6 \.mathit
   }%
   \_addto\_boldmath{%
      \_setmathfamily    5 \.mathbf
      \_setmathfamily    6 \.mathbi
   }%
   \_normalmath
   \_let\.textmathini=\_relax
}
\_def\.textvariables {\.textmathini \_mathcodes 6 {7{\_Urange a-z \_Urange A-Z}}%
   \_addto\_marm {\_fam5 }\_addto\_mait{\_fam6 }%
   \_protected\_def\_itgreek    {\_umathrangegreek01\_greekita}%
   \_protected\_def\_rmgreek    {\_umathrangegreek01\_greekrma}%
   \_protected\_def\_itGreek    {\_umathrangeGREEK01\_greekitA}
   \_protected\_def\_rmGreek    {\_umathrangeGREEK01\_greekrmA}
   \_itgreek \_rmGreek
}
\_def\.textdigits    {\.textmathini \_mathcodes 5 {7{\_Urange 0-9}}}
\_def\.textmoremath  {\.textmathini
   \_mathcodes 5 {5{!?} 2{*+-} 3{=<>} 6{,:;} 0{./|} 4{([\{} 5{\})]}}%
   \_Umathcode `- = 2 5 "2212  % hyphen behaves like minus in math mode
}
\_def\.dotext#1{\_foreach #1 \_do
   ##1 {\_trycs{_math_text##1}{\_opwarning{text option: "##1" unknown}}}}

\_nspublic \textvariables \textdigits \textmoremath ;

   \_doc
   \`\replacemissingchars``<family>` defines `\UnicodeMathSymbol` and reads
   `unimath-table.opm`, i.e.\ it does for each math character following
   if the character is missing in main math font and if it is present in
   added font and if it is not already replaced character then apply new math
   code or `\Umathaccent` definition. Its name is added to `\.alist` or
   `\.clist`. The new codes are declared by `\matchars<family>{<expanded>\clist}`.
   The `\.rlist` is the list of characters already replaced. They are not
   replaced again if a new `\replacemissingchars` is used.
   \_cod

\_def\.rlist{\sqrt\cuberoot\fourthroot} % they cannot be replaced by \mathchars
\_def\.replacemissingchars#1{%
   \_def\.alist{}\_def\.clist{}
   \_def\UnicodeMathSymbol##1##2##3##4{%
      \_iffontchar\_textfont1##1 \_else     % not in main math font
         \_iffontchar\_textfont#1 ##1       % is presnet in added font
            \_isinlist\.rlist{##2}\_iffalse % not already replaced
               \_ifx##3\_mathaccent
                  \_protected\_def##2{\_Umathaccent fixed 7 #1 ##1 }%
                  \_addto\.alist{##2}%
               \_else
                  \_addto\.clist{##2}%
      \_fi\_fi\_fi\_fi
   }
   \_input unimath-table.opm
   \_wlog{^^J\_string\replacemissingchars: From \_string\fam=\_string#1 is printed now:^^J%
         CHARACTERS: \_unexpanded\_ea{\.clist}^^JACCENTS: \_unexpanded\_ea{\.alist}^^J}%
   \_def\.tmp{\_mathchars #1}\_ea\.tmp\_ea{\.clist}%
   \_ea\_addto \_ea\.rlist \_ea{\.clist}\_ea\_addto \_ea\.rlist \_ea{\.alist}%
   \_def\.alist{}\_def\.clist{}\_let\UnicodeMathSymbol=\_undefined
}
\_nspublic \replacemissingchars ;

   \_doc
   \`\scriptspaces``{<s-rel>}{<s-bin>}{<ss-rel>}{<ss-bin>}`
   sets internal \LuaTeX/ registers represented by
   appropriate primitives, see section 7.5 in the \LuaTeX/ manual.
   \_cod

\_def\.scriptspaces #1#2#3#4{%
   \_Umathordrelspacing\_scriptstyle=\.orzeromu{#1}\_relax
   \_Umathrelordspacing\_scriptstyle=\.orzeromu{#1}\_relax
   \_Umathrelopspacing \_scriptstyle=\.orzeromu{#1}\_relax
   \_Umathordrelspacing\_crampedscriptstyle=\.orzeromu{#1}\_relax
   \_Umathrelordspacing\_crampedscriptstyle=\.orzeromu{#1}\_relax
   \_Umathrelopspacing \_crampedscriptstyle=\.orzeromu{#1}\_relax
   \_Umathordbinspacing\_scriptstyle=\.orzeromu{#2}\_relax
   \_Umathbinordspacing\_scriptstyle=\.orzeromu{#2}\_relax
   \_Umathbinopspacing \_scriptstyle=\.orzeromu{#2}\_relax
   \_Umathordbinspacing\_crampedscriptstyle=\.orzeromu{#2}\_relax
   \_Umathbinordspacing\_crampedscriptstyle=\.orzeromu{#2}\_relax
   \_Umathbinopspacing \_crampedscriptstyle=\.orzeromu{#2}\_relax
   \_Umathordrelspacing\_scriptscriptstyle=\.orzeromu{#3}\_relax
   \_Umathrelordspacing\_scriptscriptstyle=\.orzeromu{#3}\_relax
   \_Umathrelopspacing \_scriptscriptstyle=\.orzeromu{#3}\_relax
   \_Umathordrelspacing\_crampedscriptscriptstyle=\.orzeromu{#3}\_relax
   \_Umathrelordspacing\_crampedscriptscriptstyle=\.orzeromu{#3}\_relax
   \_Umathrelopspacing \_crampedscriptscriptstyle=\.orzeromu{#3}\_relax
   \_Umathordbinspacing\_scriptscriptstyle=\.orzeromu{#4}\_relax
   \_Umathbinordspacing\_scriptscriptstyle=\.orzeromu{#4}\_relax
   \_Umathbinopspacing \_scriptscriptstyle=\.orzeromu{#4}\_relax
   \_Umathordbinspacing\_crampedscriptscriptstyle=\.orzeromu{#4}\_relax
   \_Umathbinordspacing\_crampedscriptscriptstyle=\.orzeromu{#4}\_relax
   \_Umathbinopspacing \_crampedscriptscriptstyle=\.orzeromu{#4}\_relax
}
\_def\.orzeromu#1{\_ifx^#1^0mu\_else#1\_fi}

\_nspublic \scriptspaces ;

   \_doc
   \`\mathclap``{<formula>}`, \`\mathrlap``{<formula>}`, and \`\mathllap``{<formula>}`
   are based on the \OpTeX/ macros \O`\setmathstyle` and \O`\usemathstyle`.
   \_cod

\_def\.mathclap#1{{\_setmathstyle \_hbox to0pt{\_hss$\_usemathstyle#1$\_hss}}}
\_def\.mathrlap#1{{{}\_setmathstyle \_rlap{$\_usemathstyle#1$}}}
\_def\.mathllap#1{{{}\_setmathstyle \_llap{$\_usemathstyle#1$}}}

\_nspublic \mathclap \mathrlap \mathllap ;

\_endnamespace
\_endcode

\sec Summary

This package provides various extensions usable for math typesetting. Mostly
of them are inspired from
\ulink[http://petr.olsak.net/optex/optex-tricks.html]{\OpTeX/ tricks} www page.

The following macros are defined in this package:
\begitems
* \~`\bigp`, \~`\bbigp`, \~`\Bigp`, \~`\biggp`, \~`\Biggp`, \~`\autop`, \~`\normalp`
  gives better controlling of sizes of parentheses.
* \~`\smartdots` declares `\dots` macro more intelligent.
  \~`\smartvert` declares \"`|`" for better spacing.
* There are many common math macros for sets or for operators, for example
  \~`\R` or \~`\sgn`.
* \~`\eqsystem` enables to write systems of equations comfortably,
* \~`\toright`, \~`\toleft` puts the \o`\eqmark` to desired position,
  \~`\subeqmark` prints the given suffix as a part of the equation mark.
* \~`\scriptspaces` sets more spaces around rel, bin in script and scripscript styles.
* \~`\bfserif` sets `\bf` and `\bi` for math typesetting as for bold-serif, bold-italic-serif.
* \~`\rmchars` sets selected characters printed as `\rm`,
  \~`\vargreek` sets Greek leters to their variants.
* \~`\textvariables`, \~`\textdigits`, \~`\textmoremath`
  enables characters from used text font in math mode
  (variables, digits, more characters).
* \~`\replacemissingchars` allows to re-declare all characters missing in math font
  for printing them from additional math font.
\enditems

Eight options are provided by the `math` package. You can set them by
\^`\mathset``{<options>}` after `\load[math]`, for example
`\mathset{dots, vert, vargreek={\epsilon,\rho}}`. The options are:
\begitems
* `dots` sets more inteligent `\dots`, the same as \~`\smartdots`.
* `vert` sets more inteligent `|`, the same as \~`\smartvert`.
* `bfserif` sets bold-serif, bold-italic-serif, the same as \~`\bfserif`.
* `mstyle=<style>`, `bstyle=<style>` are math styles explained in section~\ref[mstyle].
* `rmchars={<list>}` sets `\rm` for selected characters, the same as \~`\rmchars`,
   see section~\ref[rmchars].
* `vargreek={<list>}` sets variants for Greek letetters, the same as \~`\vargreek`,
   see section~\ref[rmchars].
* `text={<list>}` sets \~`\textvariables`, \~`\textdigits`, or \~`\textmoremath`,
  see section~\ref[textvars].
\enditems

This package is not definitive. I plan to add more features in new versions
if needed. Moreover, this package gives an example for package writers how
to write their own packages, see section~\ref[pkgtemplate].

\sec Controlled sizes of parentheses

If you write `$f(x(y+z))$` then the outer parentheses should be bigger.
Classical Plain \TeX/ provides macros \O`\bigl`, \O`\bigr`, etc., they can
be used in this manner: `$f\bigl(x(y+z)\bigr)$`. But the source file looks
bad with such markup. Better is to say that parentheses have to be bigger
using a single prefix before functional symbol, i.e. `$\bigp f(x(y+z))$`.
This should be print the same as previous example with \O`\bigl`, \O`\bigr`.

The prefixes \^`\bigp` (big pair), \^`\bbigp` (bbig pair), \^`\Bigp` (Big pair),
\^`\biggp` (bigg pair) and \^`\Biggp` (Bigg pair) are provided,
they can be used before a functional symbol. The scaled parentheses
surrounding the functional parameter can be (...) or [...] or `\{`...`\}` or
\{...\}. I.e.\ `\Bigp\Gamma [x]` is the same as `\Gamma \Bigl[x\bigr]`.
Moreover, the functional parameter gets its own \TeX/ group, so
`\Bigp G(a\over2)` results to `G\Bigl({a\over2}\bigr)`.
There are two more prefixes \^`\autop` and \^`\normalp`. First one applies
`\left`, `\right` to the parentheses of the parameter, second one keeps
the parentheses unscaled. If you want to scale the parentheses without
preceding functional symbol then use dot instead this symbol, for example
`\Bigp.(a)` is equal to `\Bigl(a\Bigr)`.

Examples:
\begtt
$$
  \displaylines{
  \biggp F (1+\Bigp g (1+\bbigp f(1+\bigp f(1+f(x))))) \cr
  f(x(y+z)),\quad  \bigp f(x(y+z)),\quad \autop f (a\over b)\cr
  \Bigp f(a\over b+c),\quad \Bigp f(x^2\over2),\quad \Bigp.(a\over b)
  }
$$
\endtt
gives:
$$
  \displaylines{
  \biggp F (1+\Bigp g (1+\bbigp f(1+\bigp f(1+f(x))))) \cr
  f(x(y+z)),\quad  \bigp f(x(y+z)),\quad \autop f (a\over b)\cr
  \Bigp f(a\over b+c),\quad \Bigp f(x^2\over2),\quad \Bigp.(a\over b)
  }
$$

\sec Intelligent `\dots` like in AMS\TeX

AMS\TeX/ provides \o`\dots` macro which works depending on the context. If it is surrounded
by symbols like $+$, $-$, $=$ then it works like \o`\cdots`, if it is surrounded by
comma or similar symbols then it works like \o`\ldots`.
This package keeps \o`\dots` unchanged but it is changed (and behaves as
mentioned above) after the \^`\smartdots` declaration.

\smartdots
You can try this after the \^`\smartdots` declaration:
\medskip

`$a_1, a_2, \dots, a_n$    ` prints $a_1, a_2, \dots, a_n$,

`$a_1 + a_2 + \dots + a_n$ ` prints $a_1 + a_2 + \dots + a_n$,


\sec Using vertical bars with better spacing

The character \"`|`" is declared with Ord class by default in Plain \TeX/,
but we are using it typically in the context `$|x|$`. It means there should
be Open and Close classes. This example gives correct result but try to use
`$|-1|$` which gives bad spacing: $|-1|$.
And `$||x||$` gives bad result too.

When you declare \^`\smartvert`, these problems are solved. Moreover, the
\"`|`" or \"`||`" are expected to be always in pairs and they are scaled by
`\left` and `\right` primitives automatically. If you don't want to use it
in a pair, use \^`\singlevert` or `\big|`, or `\Big|` etc. Compare
the result of `$|\sum a_n|+||x||$`:
$$
  \eqalign{
     |\sum a_n|+||x|| &\quad \hbox{if \scantextokens{`\smartvert`} isn't initialized,}\cr
     \smartvert
     |\sum a_n|+||x|| &\quad \hbox{if \scantextokens{`\smartvert`} is initialized.}
  }
$$


\sec Basic and typical macros for sets, functions etc.

These typical macros are defined in `math.opm`:
\^`\N` for $\N$, \^`\Z` for $\Z$, \^`\Q` for $\Q$, \^`\R` for $\R$, \^`\C` for $\C$,
\^`\sgn`, \^`\argmin`, \^`\argmax`, \^`\grad`, \^`\rank`, \^`\tr`, \^`\diag`, \^`\Span`, \^`\Rng`,
\^`\Null`, \^`\Ker`, \^`\Res`, \^`\tg`, \^`\cotg`, \^`\arctg`, \^`\arccotg`.

I hate the \^`\frac`, \^`\dfrac` and \^`\tfrac` macros defined in \LaTeX/
but someone may want to use them. This package defines them.
But I note: usage of `$1\over2$` for $1\over2$
is much more understandable than \LaTeX's `$\frac12$`.

The vectors and matrices are usually printed by `{\bf A}{\bf x}`.
The package provides a shortcut `\.<letter>` to do the same, so user can write
`\.A\.x` for multiplication of a matrix $\.A$ by a vector $\.x$.
We strictly don't recommend usage of `\.`, `\v`, `\=`, etc.\ for accents, so
`math.opm` can define `\.` differently than the classical meaning \"dotaccent".


\sec System of equations printed by `\eqsystem`

The \^`\eqsystem``{<equations>}` enables to write systems of equations more
comfortably. The equations are separated by `\cr` and the aligned columns
are separated by space. For example:
\begtt
$$
  \eqsystem{  x +  y - 2z = 10 \cr
             2x - 7y +  z = 13 \cr
             -x +  y ~  ~ = -5 }
$$
\endtt
prints
$$
  \eqsystem{  x +  y - 2z = 10 \cr
             2x - 7y +  z = 13 \cr
             -x +  y ~  ~ = -5 }
$$
Note that empty columns have to be filled by `~` mark.
There are columns for variables (possibly multiplied by a constant) and for
binary operators `+` and `-` or relations `=`, `>` etc. or constants. Each column
is aligned to right. The number of columns is unlimited (we have 7 columns in
the example above). All given equations are packed to the `\vcenter` box.

The spaces between lines are enlarged by the value of \^`\eqskip`
and the horizontal spaces between columns are enlaged by \^`\eqsep`.
Both registers are set to 0\,pt by default.

The \^`\eqfil` register is \"left filler" applied to each item in the \^`\eqsystem` columns.
Its default is `\eqfil={\hfill}`. The right filler is hardwired and it is `\hfil`.
This makes columns aligned to right by default. For example, when you set
`\eqfil={\hfil}` then you have columns centered.

The \^`\eqsystem` macro allows optional parameter which is processed inside
group before printing equations. You can do local settings here, for example
`\eqsystem[\eqskip=2pt \eqsep=5pt]{...}`.


\sec Equation marks in atypical cases

We may want to put equation marks `\eqmark` in more lines in display mode when we
are using macros not designed for such case. For example in the lines of
the `\cases` macro:

\begtt
$$ f(x) = \cases{0 & for $x<0$\toright\eqmark \cr
                 1 & otherwise\toright\eqmark } $$
\endtt
This puts the equation marks to the right margin in each line generated by
the `\cases` macro.
$$ f(x) = \cases{0 & for $x\string<0$\toright\eqmark \cr
                 1 & otherwise\toright\eqmark }
$$
The \^`\toright`\o`\eqmark` is used here. Analogically,
\^`\toleft`\o`\eqmark` puts the equation mark to the left margin.
The position of these marks are correct after second or more \TeX/ run
because \TeX/ needs to read data from its previous run in this case.

Sometimes we want to declare a bunch of equations with the same numeric
equation marks but with different suffixes, for example (1.1a), (1.1b). We
provide the macro \^`\subeqmark``<suffix>` here.
If `<suffix>` is `a` or `A` then \^`\subeqmark` starts a new bunch of
equations with the next number. Following `\subeqmark b`, `\subeqmark c`,
etc.\ use the same equation number, they differ only by given suffixes:
You can put `[<label>]` after `<suffix>` for referencing purposes.
Example:

\begtt
$$ \eqsystem[\eqskip=3pt]{
     x + 2y + 3z = 600 \toright{\subeqmark a}\cr
   12x +  y - 3z = -7  \toright{\subeqmark b[label]}\cr
    4x -  y + 5z =  5  \toright{\subeqmark c}\cr }
$$
The equation~\ref[label] has negative right side. Moreover, it applies
$$
  a^2 + b^2 = c^2. \eqmark
$$
\endtt
prints
$$ \eqsystem[\eqskip=3pt]{
     x + 2y + 3z = 600 \toright{\subeqmark a}\cr
   12x +  y - 3z = -7  \toright{\subeqmark b[label]}\cr
    4x -  y + 5z =  5  \toright{\subeqmark c}\cr
  }
$$
The equation~\ref[label] has negative right side. Moreover, it applies
$$
  a^2 + b^2 = c^2. \eqmark
$$

\sec Setting more spaces in script styles

Classical \TeX/ puts \n`\thickmuskip` around relations and \n`\medmuskip` around
binary operators only in \n`\textstyle` and \n`\displaystyle`. These spaces are
missing in \n`\scripstyle` and \n`\scriptscriptstyle`. It means that we get, for
example
$$
  \sum_{i=j+1}^\infty a_i
$$
The formula $i=k+1$ has no spaces here, so it looks unattractive. \LuaTeX/
provides better control of all such spaces, so `math.opm` declares the macro
\^`\scriptspaces``{<s-rel>}{<s-bin>}{<ss-rel>}{<ss-bin>}` for setting
these spaces. <s-rel> is \"muskip" value used around relations in \n`\scriptstyle`,
<s-bin> is \"muskip" used around binary operators in \n`\scriptstyle` and the
last two parameters gives these spacing in \n`\scriptscriptstyle`.
If a parameter is empty, it means that it has zero value.
For example after `\scriptspaces {2mu}{1.3mu}{}{}`
the formula mentioned above looks like
$$
  \scriptspaces {2mu}{1.3mu}{}{}
  \sum_{i=j+1}^\infty a_i
$$
It looks better, doesn't it?

\sec[mstyle] `\bf` and `\bi` shapes, math styles

\OpTeX/ sets `\bf` and `\bi` math selectors as sans serif, because this
follows the old traditional math typesetting of vectors and matrices.
But Knuth's \TeX/ has another default behavior:`\bf` and `\bi` select serifed
shapes. So, many people consider it as a standard. You can declare \^`\bfserif` if
you want serifed `\bf` and `\bi` math letters.

Moreover, this package provides `mstyle=<style>` and `bstyle=<style>` options.
The `mstyle` option can be `TeX`, `ISO`, `french` or `upright` and `bstyle`
option can be `TeX`, `OpTeX`, `ISO`, `upright`. The `mstyle` and `bstyle`
options set the upright/italic versions of math Latin/Greek variables in the same
manner as `math-style` and `bold-style` options (from \LaTeX's
`unicode-math`) do it. The `bstyle=OpTeX` sets sans serif bold variables,
which is default in \OpTeX.

\sec[rmchars] Selected upright letters and variants for Greek letters

Some mathematicians claim that the letters $e$, $i$ and $\pi$ in meaning
\"a constant" should be printed in upright form. \TeX/ prints all variables in
math italic, but this package enables to set exceptions for some letters.
For example after \^`\rmchars``{e, i, \pi}`, all occurrences of these three letters
in math mode will be set in upright shape. If you set this, then the
well-known math identity `$e^{i\pi}=-1$` looks like this:
$$
  {\rm e}^{\rm i\muppi} = -1, \qquad \hbox{compare with:}\quad e^{i\pi} = -1.
$$
The syntax is \^`\rmchars``{<list>}`, where <list> is a list of characters
separated by (optional) commas. The character is `a` to `z` or `A` to `Z` or
`\alpha` to `\omega`.

If you set a character by `\rmchars` globally and you want to print it in italic
locally then use `\mit`, for example `{\mit e}` prints $e$.

Several Greek letters have their variant shape:
`\epsilon`~$\epsilon$, `\varepsilon`~$\varepsilon$,
`\sigma`~$\sigma$, `\varsigma`~$\varsigma$,
`\phi`~$\phi$, `\varphi`~$\varphi$,
`\theta`~$\theta$, `\vartheta`~$\vartheta$,
`\pi`~$\pi$, `\varpi`~$\varpi$,
`\kappa`~$\kappa$, `\varkappa`~$\varkappa$,
`\rho`~$\rho$, `\varrho`~$\varrho$,
`\Theta`~$\Theta$, `\varTheta`~$\varTheta$.
Maybe, there is a tradition of usage variant shapes instead of standard ones
in your mathematics field. Then you can use
\^`\vargreek``{<list>}`, where <list> includes the list of no-var control
sequences for these letters (separated by optional comma).
For example `\vargreek{\epsilon \phi \rho}` causes that `\epsilon` is
printed as $\varepsilon$, `\phi` as $\varphi$ and `\rho` as $\varrho$.

If you want to declare a Greek letter by both `\vargreek` and `\rmchars`,
use `\rmchars` first.

The package provides two options `rmchars` and `vargreek`. The equation
sign must follow and then the `{<list>}` with syntax mentioned above. For example
`\mathset{vargreek={\epsilon,\rho}}`.


\sec[textvars] Variables and digits from currently used text font

When Unicode math font is loaded then all variables and digits are printed
from it in math mode. If you are using text fonts with another visual
concept then you can see a differences when you use digits in text mode and in
math mode. You can specify \^`\textdigits` if you want to use digits from
current text `\rm` font in math and \^`\textvariables` if you want to use
variables from current text `\it` font in math.
You can set printing of
+−*/=<>\{([])\} from text `\rm` font in math by \^`\textmoremath`.
You can inspire from the \^`\textmoremath` macro and set more similar
characters from text font.

You have to load a text font family (using \o`\fontfam` for example) first and
use \^`\textdigits`, \^`\textvariables`, \^`\textmoremath` after it. This is
due to these macros reads {\em current} text \o`\rm` and \o`\it` fonts and set
them to math printing.

Note that we cannot avoid a visual incompatibility of parentheses when they
are use in the context \n`\left`, \n`\right`. These parentheses must be printed
from math font always because text font is unable to create bigger versions of
them.

The package provides the option `text={<list of words>}`, each <word> from the
<list> can be `digits` or `variables` or `moremath`. It runs corresponding macro(s)
described above. For example `\mathset{text=digits variables}` is equal to the
declaration of `\textdigits` `\textvariables`.


\sec Replacing all missing math characters from another font

If we load an additional math font by \o`\addUmathfont`, for example:
\begtt
\addUmathfont \xits {[XITSMath-Regular]}{} {[XITSMath-Bold]}{} {}
\endtt
then we can re-declare the code of arbitrary math character in such a way
that it is printed from this additional font. It can be done by \o`\mathchars`
provided by \OpTeX/, for example:
\begtt
\mathchars \xits {\leftdasharrow \updasharrow \rightdasharrow \downdasharrow}
\endtt
But this method enables to re-declare only selected characters. Maybe, you
want to re-declare {\em all} Unicode math characters which are missing in the main font.
This can be done by \^`\replacemissingchars`\,`<family>` provided by the
`math.opm`. For example
\begtt
\replacemissingchars \xits
\endtt
replaces all characters missing in the main font by characters from the
`\xits` declared by previous \o`\addUmathfont`.
The names of all replaced characters are printed in log file.
If the additional math font doesn't provide all Unicode math characters
then you can load a next additional math font using another \o`\addUmathfont` and do
\^`\replacemissingchars`\,`<family>` again. Only those characters not replaced
by previous steps are replaced.


\sec Miscelaneous commands

I created various commands at the requests of users. They asked me to create
commands similar to ones from \LaTeX/ packages.

\^`\mathclap``{<formula>}` creates `{\hbox to0pt{\hss $<formula>$\hss}}` and
respects the math style.\nl
\^`\mathrlap``{<formula>}` and \^`\mathllap``{<formula>}` is \O`\rlap` and
\O`\llap` analogue of \^`\mathclap`.


\sec[pkgtemplate] General recommendation for writing \OpTeX/ packages

This section has nothing common with the subject of this package but this package
can serve as inspiration for another package writers. It should be a template
for another `<pkg>.opm` files. We emphasize several principles here.
The basic information can be found in
\ulink[https://petr.olsak.net/ftp/olsak/optex/optex-doc.pdf\#ref:basic-code]
{section 2.2} of the \OpTeX/ manual.
Try to run\fnote{Run it three times because Table of contents and Index are created.}
\begtt
optex -jobname math-doc '\docgen math'
\endtt
for creating this documentation. You can see (from the log file) that the
`math.opm` is read four times during this process. First one is due to
\o`\docgen`~`math`. It skips the part before \o`\_endcode` and searches the
following {`\_doc...\_cod`} pair in the file and processes it (see the end
of the file `math.opm`). The macros and main instruction about generating
toc, index, etc.\ are here. First instruction is \o`\load``[doc,math]` which
initializes `doc` mode of \OpTeX/ and loads `math.opm` secondly because we
want to show some effects provided by this package. Then there is
\o`\printdoctail`~`math.opm` which loads the `math.opm` again and prints the
documentation starting from \o`\_endcode`. Finally, there is
\o`\printdoc`~`math.opm` which prints the codes mixed by the documentation
text inside pairs {`\_doc...\_cod`}. This causes the fourth loading of the
`math.opm` file.

The first part of the `math.opm` file looks like:
\begtt \catcode`\<=13 \adef!{\string}
% Optional comments

\_def\_<pkg>_version {<version-number>, <version-date>}
\_codedecl \pkgsequence {Doing the life more comfortable !<\_<pkg>_version>}
\_namespace{<pkg>}
\endtt
The `\_<pkg>_version` macro should be declared here. The macro should expand
to version number followed by version date. User can check
the package version simply by expanding this macro after the package is
loaded. And we want to have this data only at single place of the file.
You may check the log file if the text given by \o`\_codedecl` isn't too long
and isn't broken to more lines. Keeping single line is better because users can
`grep @:` on log file in order to get information of all loaded packages
and their version numbers.

The \o`\_namespace``{<pkg>}` opens the name space used by your package where all
`\.foo` are internally transformed to `\_<pkg>_foo`. Next part of the file
includes the code itself documented in {`\_doc...\_cod`} pairs. It is
finished by \o`\_endnamespace` which finalizes the scope where `\.foo` are
transformed to `\_<pkg>_foo` and by \o`\_endcode` which does \n`\endinput` when
the macros are load. Final part of the file after \o`\_endcode` can include
more detailed documentation.

If your package requires other packages then insert
\o`\load``[<package1>,<package2>]` after \o`\_codedecl` and before the the
\o`\_namespace` command. Each package uses its own namespace, so it is
important to load these packages before your \o`\_namespace` is opened.

If you have any idea of creating a macro package, you probably start with
experimental macros in the public namespace. It means that there are
`\def\mymacro` etc. Once such a code is working, you can include it to the
macro package introduced by \o`\_namespace``{<pkg>}`. You have to go through
your code carefully sequence per sequence and insert `_` or `.` in front of
their names. The \"`_`" prefix have to be used if the sequence is a primitive or
an \OpTeX/ macro and the \"`.`" prefix if it is your macro. So, the code fragment
`\def\mymacro` have to be rewritten to `\_def\.mymacro`. If the macro
`\mymacro` is intended for end users, then export it to the
public name space after it is defined by the \o`\_nspublic` `\mymacro ;` command.

Sometimes you may want to define a macro only in public namespace. Then
use prefix \o`\_newpublic` before your declaration, see declaration of
 \^`\sgn` in this package as an example. The reason is: if
a user has defined such a macro already then the warning is printed.
The user can read this warning and declare the macro after
`\load[<pkg>]` in this case.

   \_doc
   \load [doc,math]
   \def\opurl{http://petr.olsak.net/ftp/olsak/optex/optex-doc.pdf}
   \def\tnurl{http://petr.olsak.net/ftp/olsak/optex/tex-nutshell.pdf}
   \def\trurl{http://petr.olsak.net/optex/optex-tricks.html}
   \def\tricklink[#1]#2{\ea\ulink \ea[\trurl\##1]{\OpTeX/ trick #2}}
   \def\exlink#1#2{\ea\ulink\expanded{[#2\csstring#1]{\hbox{\tt\string#1\,}}}}
   \def\o`#1`{\exlink#1{\opurl\#cs:^}}
   \def\O`#1`{\exlink#1{\opurl\#cs:}}
   \def\n`#1`{\exlink#1{\tnurl\#cs:}}
   \outlines 0

   \tit Macros for doing math more comfortably
   \hfill Version: \_math_version \par
   \centerline{\it Petr Olšák\/\fnotemark1, 2022, 2023}
   \fnotetext{\url{https://petr.olsak.net}}

   \notoc\nonum\sec Table of contents
   \maketoc
   \printdoctail math.opm % prints the documantation written after \_endcode
   \sec Implementation
   \printdoc     math.opm % prints \_doc...\_cod parts + code before \_endcode
   \nonum\sec Index
   \begmulti 3
      \tt \makeindex      % prints index in three columns
   \endmulti
   \bye
   \_cod

\endinput

0.11  2023-04-15: \bbigp introduced.
0.10  2023-03-12: \mathclap etc. introduced.
0.09  2023-03-11: mstyle, bstyle options introduced.
0.08  2023-01-28: \eqsystem introduced, \eqfil added.
0.07  2023-01-23: \sgn etc. defined as \protected\def.
      2023-01-15: \replacemissingchars: bug fixed
0.06, 2023-01-14: \rmchars, \vargreek, \bfserif introduced
0.05, 2023-01-07: \mathset introduced
0.04, 2022-12-26: \casesof used in \.fparamA
                  \singlevert declared instead \_singlevert (bug fix)
0.03, 2022-12-19: \cotg, \arccotg defined,
                  \autop: \mathclose{} replaced by \bgroup...\egroup,
                  \scriptspaces: Rel-Op, Bin-Op spacing added.
0.02, 2022-11-26: \smartvert introduced
0.01, 2022-11-25: released