On Thu, 20 Nov 2008, Chen Shen wrote:

Hi,

A small problem: the definition of \bot and \top in math mode should
be interchanged. Thanks.

Thanks for reporting this.

Hans, in math-ini.lua the unicode slots for top and bot are interchanged
(char-ini.lua is correct). top is 0x22A5 (Unicode DOWN TACK) and bot is 0x22A4 (Unicode TOP TACK). Who came up with these unicode names.

Chen, if you want an immediate solution, replace math-ini.lua with the attached file and regenerate formats.

Aditya
if not modules then modules = { } end modules ['math-ini'] = {
    version   = 1.001,
    comment   = "companion to math-ini.tex",
    author    = "Hans Hagen, PRAGMA-ADE, Hasselt NL",
    copyright = "PRAGMA ADE / ConTeXt Development Team",
    license   = "see context related readme files"
}

--[[ldx--
<p>Math definitions. This code may move.</p>
--ldx]]--

-- if needed we can use the info here to set up xetex definition files
-- the "8000 hackery influences direct characters (utf) as indirect \char's

local texsprint, format, utfchar, utfbyte = tex.sprint, string.format, 
utf.char, utf.byte

mathematics       = mathematics       or { }
mathematics.data  = mathematics.data  or { }
mathematics.slots = mathematics.slots or { }

mathematics.classes = {
    ord     = 0,  -- mathordcomm     mathord
    op      = 1,  -- mathopcomm      mathop
    bin     = 2,  -- mathbincomm     mathbin
    rel     = 3,  -- mathrelcomm     mathrel
    open    = 4,  -- mathopencomm    mathopen
    close   = 5,  -- mathclosecomm   mathclose
    punct   = 6,  -- mathpunctcomm   mathpunct
    alpha   = 7,  -- mathalphacomm   firstofoneargument
    accent  = 8,
    radical = 9,
    inner   = 0,  -- mathinnercomm   mathinner
    nothing = 0,  -- mathnothingcomm firstofoneargument
    choice  = 0,  -- mathchoicecomm  @@mathchoicecomm
    box     = 0,  -- mathboxcomm     @@mathboxcomm
    limop   = 1,  -- mathlimopcomm   @@mathlimopcomm
    nolop   = 1,  -- mathnolopcomm   @@mathnolopcomm
}

mathematics.classes.alphabetic  = mathematics.classes.alpha
mathematics.classes.unknown     = mathematics.classes.nothing
mathematics.classes.punctuation = mathematics.classes.punct
mathematics.classes.normal      = mathematics.classes.nothing
mathematics.classes.opening     = mathematics.classes.open
mathematics.classes.closing     = mathematics.classes.close
mathematics.classes.binary      = mathematics.classes.bin
mathematics.classes.relation    = mathematics.classes.rel
mathematics.classes.fence       = mathematics.classes.unknown
mathematics.classes.diacritic   = mathematics.classes.accent
mathematics.classes.large       = mathematics.classes.op
mathematics.classes.variable    = mathematics.classes.alphabetic
mathematics.classes.number      = mathematics.classes.nothing

mathematics.families = {
    mr = 0, bs  =  8,
    mi = 1, bi  =  9,
    sy = 2, sc  = 10,
    ex = 3, tf  = 11,
    it = 4, ma  = 12,
    sl = 5, mb  = 13,
    bf = 6, mc  = 14,
    nn = 7, md  = 15,
}

mathematics.families.letters   = mathematics.families.mr
mathematics.families.numbers   = mathematics.families.mr
mathematics.families.variables = mathematics.families.mi
mathematics.families.operators = mathematics.families.sy
mathematics.families.lcgreek   = mathematics.families.mi
mathematics.families.ucgreek   = mathematics.families.mr
mathematics.families.vargreek  = mathematics.families.mi
mathematics.families.mitfamily = mathematics.families.mi
mathematics.families.calfamily = mathematics.families.sy

mathematics.families[0] = mathematics.families.mr
mathematics.families[1] = mathematics.families.mi
mathematics.families[2] = mathematics.families.sy
mathematics.families[3] = mathematics.families.ex

function mathematics.mathcode(target,class,family,slot)
    if class <= 7 then
        return ("\\omathcode%s=\"%X%02X%04X "):format(target,class,family,slot)
    end
end
function 
mathematics.delcode(target,small_family,small_slot,large_family,large_slot)
    return ("\\odelcode%s=\"%02X%04X\"%02X%04X 
"):format(target,small_family,small_slot,large_family,large_slot)
end
function mathematics.radical(small_family,small_slot,large_family,large_slot)
    return ("\\radical%s=\"%02X%04X%\"02X%04X 
"):format(target,small_family,small_slot,large_family,large_slot)
end
function mathematics.mathchar(class,family,slot)
    return ("\\omathchar\"%X%02X%04X "):format(class,family,slot)
end
function mathematics.mathaccent(class,family,slot)
    return ("\\omathaccent\"%X%02X%04X "):format(class,family,slot)
end
function mathematics.delimiter(class,family,slot,largefamily,largeslot)
    return ("\\odelimiter\"%X%02X%04X\"%02X%04X 
"):format(class,family,slot,largefamily,largeslot)
end
function mathematics.mathchardef(name,class,family,slot) -- we can avoid this 
one
    return ("\\omathchardef\\%s\"%X%02X%04X "):format(name,class,family,slot)
end

function 
mathematics.setmathsymbol(name,class,family,slot,largefamily,largeslot,unicode)
    class = mathematics.classes[class] or class -- no real checks needed
    family = mathematics.families[family] or family
    -- \unexpanded ? \relax needed for the codes?
    local classes = mathematics.classes
    if largefamily and largeslot then
        largefamily = mathematics.families[largefamily] or largefamily
        if class == classes.radical then
            texsprint(("\\unexpanded\\xdef\\%s{%s 
}"):format(name,mathematics.radical(class,family,slot,largefamily,largeslot)))
        elseif class == classes.open or class == classes.close then
            
texsprint(("\\unexpanded\\xdef\\%s{%s}"):format(name,mathematics.delimiter(class,family,slot,largefamily,largeslot)))
        end
    elseif class == classes.accent then
        texsprint(("\\unexpanded\\xdef\\%s{%s 
}"):format(name,mathematics.mathaccent(class,family,slot)))
    elseif unicode then
        -- beware, open/close and other specials should not end up here
        local ch = utfchar(unicode)
        if characters.filters.utf.private.escapes[ch] then
            texsprint(("\\xdef\\%s{\\char%s }"):format(name,unicode))
        else
            texsprint(("\\xdef\\%s{%s}"):format(name,ch))
        end
    else
        texsprint(mathematics.mathchardef(name,class,family,slot))
    end
end

-- direct sub call

function 
mathematics.setmathcharacter(target,class,family,slot,largefamily,largeslot)
    class = mathematics.classes[class] or class -- no real checks needed
    family = mathematics.families[family] or family
    if largefamily and largeslot then
        largefamily = mathematics.families[largefamily] or largefamily
        texsprint(mathematics.delcode(target,family,slot,largefamily,largeslot))
    else
        texsprint(mathematics.mathcode(target,class,family,slot))
    end
end

-- definitions (todo: expand commands to utf instead of codes)

mathematics.trace = false -- false

function mathematics.define(slots)
    local slots = slots or mathematics.slots.current
    local setmathcharacter = mathematics.setmathcharacter
    local setmathsymbol = mathematics.setmathsymbol
    local trace = mathematics.trace
    local function report(k,m,c,f,i,fe,ie)
        local mc = mathematics.classes[m] or m
        if fe then
            logs.report("mathematics","a - %s:%s 0x%05X -> %s -> %s %s (%s %s) 
-> %s",mc,m,k,c,f,i,fe,ie,utfchar(k))
        elseif c then
            logs.report("mathematics","b - %s:%s 0x%05X -> %s -> %s %s -> 
%s",mc,m,k,c,f,i,utfchar(k))
        else
            logs.report("mathematics","c - %s:%s 0x%05X -> %s %s -> 
%s",mc,m,k,f,i,utfchar(k))
        end
    end
    for k,v in pairs(characters.data) do
        local m = v.mathclass
        -- i need to clean this up a bit
        if m then
            local c = v.mathname
            if c == false then
                -- no command
                local s = slots[k]
                if s then
                    local f, i, fe, ie = s[1], s[2], s[3], s[4]
                    if trace then
                        report(k,m,c,f,i,fe,ie)
                    end
                    setmathcharacter(k,m,f,i,fe,ie)
                end
            elseif c then
                local s = slots[k]
                if s then
                    local f, i, fe, ie = s[1], s[2], s[3], s[4]
                    if trace then
                        report(k,m,c,f,i,fe,ie)
                    end
                    setmathsymbol(c,m,f,i,fe,ie,k)
                    setmathcharacter(k,m,f,i,fe,ie)
                end
            elseif v.contextname then
                local s = slots[k]
                local c = v.contextname
                if s then
                    local f, i, fe, ie = s[1], s[2], s[3], s[4]
                    if trace then
                        report(k,m,c,f,i,fe,ie)
                    end
                    -- todo: mathortext
                    setmathsymbol(c,m,f,i,fe,ie,k)
                    setmathcharacter(k,m,f,i,fe,ie)
                end
            else
                local a = v.adobename
                if a and m then
                    local s, f, i, fe, ie = slots[k], nil, nil, nil, nil
                    if s then
                        f, i, fe, ie = s[1], s[2], s[3], s[4]
                    elseif m == "variable" then
                        f, i = mathematics.families.variables, k
                    elseif m == "number" then
                        f, i = mathematics.families.numbers, k
                    end
                    if f and i then
                        if trace then
                            report(k,m,a,f,i,fe,ie)
                        end
                        setmathcharacter(k,m,f,i,fe,ie)
                    end
                end
            end
        end
    end
end

-- temporary here: will become separate

-- maybe we should define a nice virtual font so that we have
-- just the base n families repeated for different styles

mathematics.slots.traditional = {

    [0x03B1] = { "lcgreek", 0x0B }, -- alpha
    [0x03B2] = { "lcgreek", 0x0C }, -- beta
    [0x03B3] = { "lcgreek", 0x0D }, -- gamma
    [0x03B4] = { "lcgreek", 0x0E }, -- delta
    [0x03B5] = { "lcgreek", 0x0F }, -- epsilon
    [0x03B6] = { "lcgreek", 0x10 }, -- zeta
    [0x03B7] = { "lcgreek", 0x11 }, -- eta
    [0x03B8] = { "lcgreek", 0x12 }, -- theta
    [0x03B9] = { "lcgreek", 0x13 }, -- iota
    [0x03BA] = { "lcgreek", 0x14 }, -- kappa
    [0x03BB] = { "lcgreek", 0x15 }, -- lambda
    [0x03BC] = { "lcgreek", 0x16 }, -- mu
    [0x03BD] = { "lcgreek", 0x17 }, -- nu
    [0x03BE] = { "lcgreek", 0x18 }, -- xi
    [0x03BF] = { "lcgreek", 0x6F }, -- omicron
    [0x03C0] = { "lcgreek", 0x19 }, -- pi
    [0x03C1] = { "lcgreek", 0x1A }, -- rho
--  [0x03C2] = { "lcgreek", 0x00 }, -- varsigma
    [0x03C3] = { "lcgreek", 0x1B }, -- sigma
    [0x03C4] = { "lcgreek", 0x1C }, -- tau
    [0x03C5] = { "lcgreek", 0x1D }, -- upsilon
--  [0x03C6] = { "lcgreek", 0x1E }, -- varphi
    [0x03C7] = { "lcgreek", 0x1F }, -- chi
    [0x03C8] = { "lcgreek", 0x20 }, -- psi
    [0x03C9] = { "lcgreek", 0x21 }, -- omega

    [0x0391] = { "ucgreek", 0x41 }, -- Alpha
    [0x0392] = { "ucgreek", 0x42 }, -- Beta
    [0x0393] = { "ucgreek", 0x00 }, -- Gamma
    [0x0394] = { "ucgreek", 0x01 }, -- Delta
    [0x0395] = { "ucgreek", 0x45 }, -- Epsilon
    [0x0396] = { "ucgreek", 0x5A }, -- Zeta
    [0x0397] = { "ucgreek", 0x48 }, -- Eta
    [0x0398] = { "ucgreek", 0x02 }, -- Theta
    [0x0399] = { "ucgreek", 0x49 }, -- Iota
    [0x039A] = { "ucgreek", 0x4B }, -- Kappa
    [0x039B] = { "ucgreek", 0x03 }, -- Lambda
    [0x039C] = { "ucgreek", 0x4D }, -- Mu
    [0x039D] = { "ucgreek", 0x4E }, -- Nu
    [0x039E] = { "ucgreek", 0x04 }, -- Xi
    [0x039F] = { "ucgreek", 0x4F }, -- Omicron
    [0x03A0] = { "ucgreek", 0x05 }, -- Pi
    [0x03A1] = { "ucgreek", 0x52 }, -- Rho
    [0x03A3] = { "ucgreek", 0x06 }, -- Sigma
    [0x03A4] = { "ucgreek", 0x54 }, -- Tau
    [0x03A5] = { "ucgreek", 0x07 }, -- Upsilon
    [0x03A6] = { "ucgreek", 0x08 }, -- Phi
    [0x03A7] = { "ucgreek", 0x58 }, -- Chi
    [0x03A8] = { "ucgreek", 0x09 }, -- Psi
    [0x03A9] = { "ucgreek", 0x0A }, -- Omega

    [0x03F5] = { "vargreek", 0x22 }, -- varepsilon
    [0x03D1] = { "vargreek", 0x23 }, -- vartheta
    [0x03D6] = { "vargreek", 0x24 }, -- varpi
    [0x03F1] = { "vargreek", 0x25 }, -- varrho
    [0x03C2] = { "vargreek", 0x26 }, -- varsigma

    -- varphi is part of the alphabet, contrary to the other var*s'

    [0x03C6] = { "vargreek", 0x27 }, -- varphi
    [0x03D5] = { "lcgreek",  0x1E }, -- phi

    [0x03F0] = { "lcgreek",  0x14 }, -- varkappa, not in tex fonts

    [0x0021] = { "mr", 0x21 }, -- !
    [0x0028] = { "mr", 0x28 }, -- (
    [0x0029] = { "mr", 0x29 }, -- )
    [0x002A] = { "sy", 0x03 }, -- *
    [0x002B] = { "mr", 0x2B }, -- +
    [0x002C] = { "mi", 0x3B }, -- ,
    [0x002D] = { "sy", 0x00 }, -- -
    [0x2212] = { "sy", 0x00 }, -- -
    [0x002E] = { "mi", 0x3A }, -- .
    [0x002F] = { "mi", 0x3D }, -- /
    [0x003A] = { "mr", 0x3A }, -- :
    [0x003B] = { "mr", 0x3B }, -- ;
    [0x003C] = { "mi", 0x3C }, -- <
    [0x003D] = { "mr", 0x3D }, -- =
    [0x003E] = { "mi", 0x3E }, -- >
    [0x003F] = { "mr", 0x3F }, -- ?
    [0x005C] = { "sy", 0x6E }, -- \
    [0x007B] = { "sy", 0x66 }, -- {
    [0x007C] = { "sy", 0x6A }, -- |
    [0x007D] = { "sy", 0x67 }, -- }
    [0x00AC] = { "sy", 0x3A }, -- lnot
    [0x00B1] = { "sy", 0x06 }, -- pm
    [0x00B7] = { "sy", 0x01 }, -- cdot
    [0x00D7] = { "sy", 0x02 }, -- times
    [0x00F7] = { "sy", 0x04 }, -- div
    [0x2022] = { "sy", 0x0F }, -- bullet
    [0x2111] = { "sy", 0x3D }, -- Im
    [0x2118] = { "mi", 0x7D }, -- wp
    [0x211C] = { "sy", 0x3C }, -- Re
    [0x2190] = { "sy", 0x20 }, -- leftarrow
    [0x2191] = { "sy", 0x22, "ex", 0x78 }, -- uparrow
    [0x2192] = { "sy", 0x21 }, -- rightarrow
    [0x2193] = { "sy", 0x23, "ex", 0x79 }, -- downarrow
    [0x2194] = { "sy", 0x24 }, -- leftrightarrow
    [0x2195] = { "sy", 0x6C, "ex", 0x3F }, -- updownarrow
    [0x2196] = { "sy", 0x2D }, -- nwarrow
    [0x2197] = { "sy", 0x25 }, -- nearrow
    [0x2198] = { "sy", 0x2E }, -- swarrow
    [0x2199] = { "sy", 0x26 }, -- searrow
    [0x21D0] = { "sy", 0x28 }, -- Leftarrow
    [0x21D1] = { "sy", 0x6C, "ex", 0x7E }, -- Uparrow
    [0x21D2] = { "sy", 0x29 }, -- Rightarrow
    [0x21D3] = { "sy", 0x2B, "ex", 0x7F }, -- Downarrow
    [0x21D4] = { "sy", 0x2C }, -- Leftrightarrow
    [0x21D5] = { "sy", 0x6D, "ex", 0x77 }, -- Updownarrow
    [0x2135] = { "sy", 0x40 }, -- aleph
    [0x2113] = { "mi", 0x60 }, -- ell
--  ...
    [0x2200] = { "sy", 0x38 }, -- forall
--  [0x2201] = { "sy", 0x00 }, -- complement
    [0x2202] = { "mi", 0x40 }, -- partial
    [0x2203] = { "sy", 0x39 }, -- exists
--  [0x2204] = { "sy", 0x00 }, -- not exists
    [0x2205] = { "sy", 0x3B }, -- empty set
--  [0x2206] = { "sy", 0x00 }, -- increment
    [0x2207] = { "sy", 0x72 }, -- nabla
    [0x2208] = { "sy", 0x32 }, -- in
    [0x2209] = { "sy", 0x33 }, -- ni
    [0x220F] = { "ex", 0x51 }, -- prod
    [0x2210] = { "ex", 0x60 }, -- coprod
    [0x2211] = { "ex", 0x50 }, -- sum
--  [0x2212] = { "sy", 0x00 }, -- -
    [0x2213] = { "sy", 0x07 }, -- mp
    [0x2215] = { "sy", 0x3D }, -- / AM: Not sure
    [0x2216] = { "sy", 0x6E }, -- setminus
    [0x2217] = { "sy", 0x03 }, -- *
    [0x2218] = { "sy", 0x0E }, -- circ
    [0x2219] = { "sy", 0x0F }, -- bullet
--  [0x221A] = { "sy", 0x70, "ex", 0x70 }, -- sqrt. AM: Check surd??
--  ...
    [0x221D] = { "sy", 0x2F }, -- propto
    [0x221E] = { "sy", 0x31 }, -- infty
    [0x2225] = { "sy", 0x6B }, -- parallel
    [0x2227] = { "sy", 0x5E }, -- wedge
    [0x2228] = { "sy", 0x5F }, -- vee
    [0x2229] = { "sy", 0x5C }, -- cap
    [0x222A] = { "sy", 0x5B }, -- cup
    [0x222B] = { "ex", 0x52 }, -- intop
--  ... other integrals
    [0x2236] = { "mr", 0x3A }, -- colon
    [0x223C] = { "sy", 0x18 }, -- sim
    [0x2243] = { "sy", 0x27 }, -- simeq
    [0x2248] = { "sy", 0x19 }, -- approx
    [0x225C] = { "ma", 0x2C }, -- triangleq
    [0x2261] = { "sy", 0x11 }, -- equiv
    [0x2264] = { "sy", 0x14 }, -- leq
    [0x2265] = { "sy", 0x15 }, -- geq
    [0x226A] = { "sy", 0x1C }, -- ll
    [0x226B] = { "sy", 0x1D }, -- gg
    [0x227A] = { "sy", 0x1E }, -- prec
    [0x227B] = { "sy", 0x1F }, -- succ
--  [0x227C] = { "sy", 0x16 }, -- preceq, AM:No see 2AAF
--  [0x227D] = { "sy", 0x17 }, -- succeq, AM:No see 2AB0
    [0x2282] = { "sy", 0x1A }, -- subset
    [0x2283] = { "sy", 0x1B }, -- supset
    [0x2286] = { "sy", 0x12 }, -- subseteq
    [0x2287] = { "sy", 0x13 }, -- supseteq
    [0x2293] = { "sy", 0x75 }, -- sqcap
    [0x2294] = { "sy", 0x74 }, -- sqcup
    [0x2295] = { "sy", 0x08 }, -- oplus
    [0x2296] = { "sy", 0x09 }, -- ominus
    [0x2297] = { "sy", 0x0A }, -- otimes
    [0x2298] = { "sy", 0x0B }, -- oslash
    [0x2299] = { "sy", 0x0C }, -- odot
    [0x22A4] = { "sy", 0x3F }, -- bop
    [0x22A5] = { "sy", 0x3E }, -- top
    [0x22C0] = { "ex", 0x56 }, -- bigwedge
    [0x22C1] = { "ex", 0x57 }, -- bigvee
    [0x22C2] = { "ex", 0x54 }, -- bigcap
    [0x22C3] = { "ex", 0x53 }, -- bigcup
    [0x22C4] = { "sy", 0x05 }, -- diamond
    [0x22C5] = { "sy", 0x01 }, -- cdot
    [0x22C6] = { "mi", 0x3F }, -- star
    [0x25B3] = { "sy", 0x34 }, -- triangle up

    [0x2220] = { "ma", 0x5C }, -- angle
    [0x2221] = { "ma", 0x5D }, -- measuredangle
    [0x2222] = { "ma", 0x5E }, -- sphericalangle

    [0x2245] = { "ma", 0x75 }, -- aproxeq

    [0x1D6A4] = { "mi", 0x7B }, -- imath
    [0x1D6A5] = { "mi", 0x7C }, -- jmath

    [0x0028] = { "mr", 0x28, "ex", 0x00 }, -- (
    [0x0029] = { "mr", 0x29, "ex", 0x01 }, -- )
    [0x002F] = { "mr", 0x2F, "ex", 0x0E }, -- /
    [0x003C] = { "sy", 0x3C, "ex", 0x0A }, -- <
    [0x003E] = { "sy", 0x3E, "ex", 0x0B }, -- >
    [0x005B] = { "mr", 0x5B, "ex", 0x02 }, -- [
    [0x005D] = { "mr", 0x5D, "ex", 0x03 }, -- ]
    [0x007C] = { "sy", 0x6A, "ex", 0x0C }, -- |
    [0x005C] = { "sy", 0x6E, "ex", 0x0F }, -- \
    [0x007B] = { "sy", 0x66, "ex", 0x08 }, -- {
    [0x007D] = { "sy", 0x67, "ex", 0x09 }, -- }

    [0x005E] = { "mr", 0x5E, "ex", 0x62 }, -- widehat
    [0x007E] = { "mr", 0x7E, "ex", 0x65 }, -- widetilde

    [0x2AAF] = { "sy", 0x16 }, -- preceq
    [0x2AB0] = { "sy", 0x17 }, -- succeq

    [0x2145] = { "mr", 0x44 },
    [0x2146] = { "mr", 0x64 },
    [0x2147] = { "mr", 0x65 },

    -- please let lm/gypre math show up soon

}

mathematics.slots.current = mathematics.slots.traditional

function mathematics.utfmathclass(chr, default)
    local cd = characters.data[utfbyte(chr)]
    return (cd and cd.mathclass) or default or "unknown"
end
function mathematics.utfmathstretch(chr, default) -- "h", "v", "b", ""
    local cd = characters.data[utfbyte(chr)]
    return (cd and cd.mathstretch) or default or ""
end
function mathematics.utfmathcommand(chr, default)
    local cd = characters.data[utfbyte(chr)]
    local cmd = cd and cd.mathname
    tex.sprint(cmd or default or "")
end
function mathematics.utfmathfiller(chr, default)
    local cd = characters.data[utfbyte(chr)]
    local cmd = cd and (cd.mathfiller or cd.mathname)
    tex.sprint(cmd or default or "")
end

mathematics.entities = mathematics.entities or { }

function mathematics.register_xml_entities()
    local entities = xml.entities
    for name, unicode in pairs(mathematics.entities) do
        if not entities[name] then
            entities[name] = utfchar(unicode)
        end
    end
end
___________________________________________________________________________________
If your question is of interest to others as well, please add an entry to the 
Wiki!

maillist : ntg-context@ntg.nl / http://www.ntg.nl/mailman/listinfo/ntg-context
webpage  : http://www.pragma-ade.nl / http://tex.aanhet.net
archive  : https://foundry.supelec.fr/projects/contextrev/
wiki     : http://contextgarden.net
___________________________________________________________________________________

Reply via email to