home *** CD-ROM | disk | FTP | other *** search
/ Freelog 121 / FreelogMagazineJuilletAout2014-No121.iso / Bureautique / calibre / calibre-1.35.0.msi / file_652 < prev    next >
Text File  |  2013-05-28  |  18KB  |  290 lines
  1. /*************************************************************
  2.  *
  3.  *  MathJax/jax/output/HTML-CSS/optable/SuppMathOperators.js
  4.  *
  5.  *  Copyright (c) 2010 Design Science, Inc.
  6.  *
  7.  *  Licensed under the Apache License, Version 2.0 (the "License");
  8.  *  you may not use this file except in compliance with the License.
  9.  *  You may obtain a copy of the License at
  10.  *
  11.  *     http://www.apache.org/licenses/LICENSE-2.0
  12.  *
  13.  *  Unless required by applicable law or agreed to in writing, software
  14.  *  distributed under the License is distributed on an "AS IS" BASIS,
  15.  *  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16.  *  See the License for the specific language governing permissions and
  17.  *  limitations under the License.
  18.  *
  19.  */
  20.  
  21. (function (MML) {
  22.   var MO = MML.mo.OPTYPES;
  23.   var TEXCLASS = MML.TEXCLASS;
  24.  
  25.   MathJax.Hub.Insert(MML.mo.prototype,{
  26.     OPTABLE: {
  27.       prefix: {
  28.         '\u2A03': MO.OP,       // n-ary union operator with dot
  29.         '\u2A05': MO.OP,       // n-ary square intersection operator
  30.         '\u2A07': MO.OP,       // two logical and operator
  31.         '\u2A08': MO.OP,       // two logical or operator
  32.         '\u2A09': MO.OP,       // n-ary times operator
  33.         '\u2A0A': MO.OP,       // modulo two sum
  34.         '\u2A0B': MO.INTEGRAL2, // summation with integral
  35.         '\u2A0C': MO.INTEGRAL, // quadruple integral operator
  36.         '\u2A0D': MO.INTEGRAL2, // finite part integral
  37.         '\u2A0E': MO.INTEGRAL2, // integral with double stroke
  38.         '\u2A0F': MO.INTEGRAL2, // integral average with slash
  39.         '\u2A10': MO.OP,       // circulation function
  40.         '\u2A11': MO.OP,       // anticlockwise integration
  41.         '\u2A12': MO.OP,       // line integration with rectangular path around pole
  42.         '\u2A13': MO.OP,       // line integration with semicircular path around pole
  43.         '\u2A14': MO.OP,       // line integration not including the pole
  44.         '\u2A15': MO.INTEGRAL2, // integral around a point operator
  45.         '\u2A16': MO.INTEGRAL2, // quaternion integral operator
  46.         '\u2A17': MO.INTEGRAL2, // integral with leftwards arrow with hook
  47.         '\u2A18': MO.INTEGRAL2, // integral with times sign
  48.         '\u2A19': MO.INTEGRAL2, // integral with intersection
  49.         '\u2A1A': MO.INTEGRAL2, // integral with union
  50.         '\u2A1B': MO.INTEGRAL2, // integral with overbar
  51.         '\u2A1C': MO.INTEGRAL2, // integral with underbar
  52.         '\u2AFC': MO.OP,       // large triple vertical bar operator
  53.         '\u2AFF': MO.OP        // n-ary white vertical bar
  54.       },
  55.       infix: {
  56.         '\u2A1D': MO.BIN3,     // join
  57.         '\u2A1E': MO.BIN3,     // large left triangle operator
  58.         '\u2A1F': MO.BIN3,     // z notation schema composition
  59.         '\u2A20': MO.BIN3,     // z notation schema piping
  60.         '\u2A21': MO.BIN3,     // z notation schema projection
  61.         '\u2A22': MO.BIN4,     // plus sign with small circle above
  62.         '\u2A23': MO.BIN4,     // plus sign with circumflex accent above
  63.         '\u2A24': MO.BIN4,     // plus sign with tilde above
  64.         '\u2A25': MO.BIN4,     // plus sign with dot below
  65.         '\u2A26': MO.BIN4,     // plus sign with tilde below
  66.         '\u2A27': MO.BIN4,     // plus sign with subscript two
  67.         '\u2A28': MO.BIN4,     // plus sign with black triangle
  68.         '\u2A29': MO.BIN4,     // minus sign with comma above
  69.         '\u2A2A': MO.BIN4,     // minus sign with dot below
  70.         '\u2A2B': MO.BIN4,     // minus sign with falling dots
  71.         '\u2A2C': MO.BIN4,     // minus sign with rising dots
  72.         '\u2A2D': MO.BIN4,     // plus sign in left half circle
  73.         '\u2A2E': MO.BIN4,     // plus sign in right half circle
  74.         '\u2A30': MO.BIN4,     // multiplication sign with dot above
  75.         '\u2A31': MO.BIN4,     // multiplication sign with underbar
  76.         '\u2A32': MO.BIN4,     // semidirect product with bottom closed
  77.         '\u2A33': MO.BIN4,     // smash product
  78.         '\u2A34': MO.BIN4,     // multiplication sign in left half circle
  79.         '\u2A35': MO.BIN4,     // multiplication sign in right half circle
  80.         '\u2A36': MO.BIN4,     // circled multiplication sign with circumflex accent
  81.         '\u2A37': MO.BIN4,     // multiplication sign in double circle
  82.         '\u2A38': MO.BIN4,     // circled division sign
  83.         '\u2A39': MO.BIN4,     // plus sign in triangle
  84.         '\u2A3A': MO.BIN4,     // minus sign in triangle
  85.         '\u2A3B': MO.BIN4,     // multiplication sign in triangle
  86.         '\u2A3C': MO.BIN4,     // interior product
  87.         '\u2A3D': MO.BIN4,     // righthand interior product
  88.         '\u2A3E': MO.BIN4,     // z notation relational composition
  89.         '\u2A40': MO.BIN4,     // intersection with dot
  90.         '\u2A41': MO.BIN4,     // union with minus sign
  91.         '\u2A42': MO.BIN4,     // union with overbar
  92.         '\u2A43': MO.BIN4,     // intersection with overbar
  93.         '\u2A44': MO.BIN4,     // intersection with logical and
  94.         '\u2A45': MO.BIN4,     // union with logical or
  95.         '\u2A46': MO.BIN4,     // union above intersection
  96.         '\u2A47': MO.BIN4,     // intersection above union
  97.         '\u2A48': MO.BIN4,     // union above bar above intersection
  98.         '\u2A49': MO.BIN4,     // intersection above bar above union
  99.         '\u2A4A': MO.BIN4,     // union beside and joined with union
  100.         '\u2A4B': MO.BIN4,     // intersection beside and joined with intersection
  101.         '\u2A4C': MO.BIN4,     // closed union with serifs
  102.         '\u2A4D': MO.BIN4,     // closed intersection with serifs
  103.         '\u2A4E': MO.BIN4,     // double square intersection
  104.         '\u2A4F': MO.BIN4,     // double square union
  105.         '\u2A50': MO.BIN4,     // closed union with serifs and smash product
  106.         '\u2A51': MO.BIN4,     // logical and with dot above
  107.         '\u2A52': MO.BIN4,     // logical or with dot above
  108.         '\u2A53': MO.BIN4,     // double logical and
  109.         '\u2A54': MO.BIN4,     // double logical or
  110.         '\u2A55': MO.BIN4,     // two intersecting logical and
  111.         '\u2A56': MO.BIN4,     // two intersecting logical or
  112.         '\u2A57': MO.BIN4,     // sloping large or
  113.         '\u2A58': MO.BIN4,     // sloping large and
  114.         '\u2A59': MO.REL,      // logical or overlapping logical and
  115.         '\u2A5A': MO.BIN4,     // logical and with middle stem
  116.         '\u2A5B': MO.BIN4,     // logical or with middle stem
  117.         '\u2A5C': MO.BIN4,     // logical and with horizontal dash
  118.         '\u2A5D': MO.BIN4,     // logical or with horizontal dash
  119.         '\u2A5E': MO.BIN4,     // logical and with double overbar
  120.         '\u2A5F': MO.BIN4,     // logical and with underbar
  121.         '\u2A60': MO.BIN4,     // logical and with double underbar
  122.         '\u2A61': MO.BIN4,     // small vee with underbar
  123.         '\u2A62': MO.BIN4,     // logical or with double overbar
  124.         '\u2A63': MO.BIN4,     // logical or with double underbar
  125.         '\u2A64': MO.BIN4,     // z notation domain antirestriction
  126.         '\u2A65': MO.BIN4,     // z notation range antirestriction
  127.         '\u2A66': MO.REL,      // equals sign with dot below
  128.         '\u2A67': MO.REL,      // identical with dot above
  129.         '\u2A68': MO.REL,      // triple horizontal bar with double vertical stroke
  130.         '\u2A69': MO.REL,      // triple horizontal bar with triple vertical stroke
  131.         '\u2A6A': MO.REL,      // tilde operator with dot above
  132.         '\u2A6B': MO.REL,      // tilde operator with rising dots
  133.         '\u2A6C': MO.REL,      // similar minus similar
  134.         '\u2A6D': MO.REL,      // congruent with dot above
  135.         '\u2A6E': MO.REL,      // equals with asterisk
  136.         '\u2A6F': MO.REL,      // almost equal to with circumflex accent
  137.         '\u2A70': MO.REL,      // approximately equal or equal to
  138.         '\u2A71': MO.BIN4,     // equals sign above plus sign
  139.         '\u2A72': MO.BIN4,     // plus sign above equals sign
  140.         '\u2A73': MO.REL,      // equals sign above tilde operator
  141.         '\u2A74': MO.REL,      // double colon equal
  142.         '\u2A75': MO.REL,      // two consecutive equals signs
  143.         '\u2A76': MO.REL,      // three consecutive equals signs
  144.         '\u2A77': MO.REL,      // equals sign with two dots above and two dots below
  145.         '\u2A78': MO.REL,      // equivalent with four dots above
  146.         '\u2A79': MO.REL,      // less-than with circle inside
  147.         '\u2A7A': MO.REL,      // greater-than with circle inside
  148.         '\u2A7B': MO.REL,      // less-than with question mark above
  149.         '\u2A7C': MO.REL,      // greater-than with question mark above
  150.         '\u2A7D': MO.REL,      // less-than or slanted equal to
  151.         '\u2A7D\u0338': MO.REL, // less-than or slanted equal to with slash
  152.         '\u2A7E': MO.REL,      // greater-than or slanted equal to
  153.         '\u2A7E\u0338': MO.REL, // greater-than or slanted equal to with slash
  154.         '\u2A7F': MO.REL,      // less-than or slanted equal to with dot inside
  155.         '\u2A80': MO.REL,      // greater-than or slanted equal to with dot inside
  156.         '\u2A81': MO.REL,      // less-than or slanted equal to with dot above
  157.         '\u2A82': MO.REL,      // greater-than or slanted equal to with dot above
  158.         '\u2A83': MO.REL,      // less-than or slanted equal to with dot above right
  159.         '\u2A84': MO.REL,      // greater-than or slanted equal to with dot above left
  160.         '\u2A85': MO.REL,      // less-than or approximate
  161.         '\u2A86': MO.REL,      // greater-than or approximate
  162.         '\u2A87': MO.REL,      // less-than and single-line not equal to
  163.         '\u2A88': MO.REL,      // greater-than and single-line not equal to
  164.         '\u2A89': MO.REL,      // less-than and not approximate
  165.         '\u2A8A': MO.REL,      // greater-than and not approximate
  166.         '\u2A8B': MO.REL,      // less-than above double-line equal above greater-than
  167.         '\u2A8C': MO.REL,      // greater-than above double-line equal above less-than
  168.         '\u2A8D': MO.REL,      // less-than above similar or equal
  169.         '\u2A8E': MO.REL,      // greater-than above similar or equal
  170.         '\u2A8F': MO.REL,      // less-than above similar above greater-than
  171.         '\u2A90': MO.REL,      // greater-than above similar above less-than
  172.         '\u2A91': MO.REL,      // less-than above greater-than above double-line equal
  173.         '\u2A92': MO.REL,      // greater-than above less-than above double-line equal
  174.         '\u2A93': MO.REL,      // less-than above slanted equal above greater-than above slanted equal
  175.         '\u2A94': MO.REL,      // greater-than above slanted equal above less-than above slanted equal
  176.         '\u2A95': MO.REL,      // slanted equal to or less-than
  177.         '\u2A96': MO.REL,      // slanted equal to or greater-than
  178.         '\u2A97': MO.REL,      // slanted equal to or less-than with dot inside
  179.         '\u2A98': MO.REL,      // slanted equal to or greater-than with dot inside
  180.         '\u2A99': MO.REL,      // double-line equal to or less-than
  181.         '\u2A9A': MO.REL,      // double-line equal to or greater-than
  182.         '\u2A9B': MO.REL,      // double-line slanted equal to or less-than
  183.         '\u2A9C': MO.REL,      // double-line slanted equal to or greater-than
  184.         '\u2A9D': MO.REL,      // similar or less-than
  185.         '\u2A9E': MO.REL,      // similar or greater-than
  186.         '\u2A9F': MO.REL,      // similar above less-than above equals sign
  187.         '\u2AA0': MO.REL,      // similar above greater-than above equals sign
  188.         '\u2AA1': MO.REL,      // double nested less-than
  189.         '\u2AA1\u0338': MO.REL, // double nested less-than with slash
  190.         '\u2AA2': MO.REL,      // double nested greater-than
  191.         '\u2AA2\u0338': MO.REL, // double nested greater-than with slash
  192.         '\u2AA3': MO.REL,      // double nested less-than with underbar
  193.         '\u2AA4': MO.REL,      // greater-than overlapping less-than
  194.         '\u2AA5': MO.REL,      // greater-than beside less-than
  195.         '\u2AA6': MO.REL,      // less-than closed by curve
  196.         '\u2AA7': MO.REL,      // greater-than closed by curve
  197.         '\u2AA8': MO.REL,      // less-than closed by curve above slanted equal
  198.         '\u2AA9': MO.REL,      // greater-than closed by curve above slanted equal
  199.         '\u2AAA': MO.REL,      // smaller than
  200.         '\u2AAB': MO.REL,      // larger than
  201.         '\u2AAC': MO.REL,      // smaller than or equal to
  202.         '\u2AAD': MO.REL,      // larger than or equal to
  203.         '\u2AAE': MO.REL,      // equals sign with bumpy above
  204.         '\u2AAF\u0338': MO.REL, // precedes above single-line equals sign with slash
  205.         '\u2AB0\u0338': MO.REL, // succeeds above single-line equals sign with slash
  206.         '\u2AB1': MO.REL,      // precedes above single-line not equal to
  207.         '\u2AB2': MO.REL,      // succeeds above single-line not equal to
  208.         '\u2AB3': MO.REL,      // precedes above equals sign
  209.         '\u2AB4': MO.REL,      // succeeds above equals sign
  210.         '\u2AB5': MO.REL,      // precedes above not equal to
  211.         '\u2AB6': MO.REL,      // succeeds above not equal to
  212.         '\u2AB7': MO.REL,      // precedes above almost equal to
  213.         '\u2AB8': MO.REL,      // succeeds above almost equal to
  214.         '\u2AB9': MO.REL,      // precedes above not almost equal to
  215.         '\u2ABA': MO.REL,      // succeeds above not almost equal to
  216.         '\u2ABB': MO.REL,      // double precedes
  217.         '\u2ABC': MO.REL,      // double succeeds
  218.         '\u2ABD': MO.REL,      // subset with dot
  219.         '\u2ABE': MO.REL,      // superset with dot
  220.         '\u2ABF': MO.REL,      // subset with plus sign below
  221.         '\u2AC0': MO.REL,      // superset with plus sign below
  222.         '\u2AC1': MO.REL,      // subset with multiplication sign below
  223.         '\u2AC2': MO.REL,      // superset with multiplication sign below
  224.         '\u2AC3': MO.REL,      // subset of or equal to with dot above
  225.         '\u2AC4': MO.REL,      // superset of or equal to with dot above
  226.         '\u2AC5': MO.REL,      // subset of above equals sign
  227.         '\u2AC6': MO.REL,      // superset of above equals sign
  228.         '\u2AC7': MO.REL,      // subset of above tilde operator
  229.         '\u2AC8': MO.REL,      // superset of above tilde operator
  230.         '\u2AC9': MO.REL,      // subset of above almost equal to
  231.         '\u2ACA': MO.REL,      // superset of above almost equal to
  232.         '\u2ACB': MO.REL,      // subset of above not equal to
  233.         '\u2ACC': MO.REL,      // superset of above not equal to
  234.         '\u2ACD': MO.REL,      // square left open box operator
  235.         '\u2ACE': MO.REL,      // square right open box operator
  236.         '\u2ACF': MO.REL,      // closed subset
  237.         '\u2AD0': MO.REL,      // closed superset
  238.         '\u2AD1': MO.REL,      // closed subset or equal to
  239.         '\u2AD2': MO.REL,      // closed superset or equal to
  240.         '\u2AD3': MO.REL,      // subset above superset
  241.         '\u2AD4': MO.REL,      // superset above subset
  242.         '\u2AD5': MO.REL,      // subset above subset
  243.         '\u2AD6': MO.REL,      // superset above superset
  244.         '\u2AD7': MO.REL,      // superset beside subset
  245.         '\u2AD8': MO.REL,      // superset beside and joined by dash with subset
  246.         '\u2AD9': MO.REL,      // element of opening downwards
  247.         '\u2ADA': MO.REL,      // pitchfork with tee top
  248.         '\u2ADB': MO.REL,      // transversal intersection
  249.         '\u2ADC': MO.REL,      // forking
  250.         '\u2ADD': MO.REL,      // nonforking
  251.         '\u2ADE': MO.REL,      // short left tack
  252.         '\u2ADF': MO.REL,      // short down tack
  253.         '\u2AE0': MO.REL,      // short up tack
  254.         '\u2AE1': MO.REL,      // perpendicular with s
  255.         '\u2AE2': MO.REL,      // vertical bar triple right turnstile
  256.         '\u2AE3': MO.REL,      // double vertical bar left turnstile
  257.         '\u2AE4': MO.REL,      // vertical bar double left turnstile
  258.         '\u2AE5': MO.REL,      // double vertical bar double left turnstile
  259.         '\u2AE6': MO.REL,      // long dash from left member of double vertical
  260.         '\u2AE7': MO.REL,      // short down tack with overbar
  261.         '\u2AE8': MO.REL,      // short up tack with underbar
  262.         '\u2AE9': MO.REL,      // short up tack above short down tack
  263.         '\u2AEA': MO.REL,      // double down tack
  264.         '\u2AEB': MO.REL,      // double up tack
  265.         '\u2AEC': MO.REL,      // double stroke not sign
  266.         '\u2AED': MO.REL,      // reversed double stroke not sign
  267.         '\u2AEE': MO.REL,      // does not divide with reversed negation slash
  268.         '\u2AEF': MO.REL,      // vertical line with circle above
  269.         '\u2AF0': MO.REL,      // vertical line with circle below
  270.         '\u2AF1': MO.REL,      // down tack with circle below
  271.         '\u2AF2': MO.REL,      // parallel with horizontal stroke
  272.         '\u2AF3': MO.REL,      // parallel with tilde operator
  273.         '\u2AF4': MO.BIN4,     // triple vertical bar binary relation
  274.         '\u2AF5': MO.BIN4,     // triple vertical bar with horizontal stroke
  275.         '\u2AF6': MO.BIN4,     // triple colon operator
  276.         '\u2AF7': MO.REL,      // triple nested less-than
  277.         '\u2AF8': MO.REL,      // triple nested greater-than
  278.         '\u2AF9': MO.REL,      // double-line slanted less-than or equal to
  279.         '\u2AFA': MO.REL,      // double-line slanted greater-than or equal to
  280.         '\u2AFB': MO.BIN4,     // triple solidus binary relation
  281.         '\u2AFD': MO.BIN4,     // double solidus operator
  282.         '\u2AFE': MO.BIN3      // white vertical bar
  283.       }
  284.     }
  285.   });
  286.  
  287.   MathJax.Ajax.loadComplete(MML.optableDir+"/SuppMathOperators.js");
  288.  
  289. })(MathJax.ElementJax.mml);
  290.