| |
| # This is the Mathematical Markup Language (MathML) 3.0, an XML |
| # application for describing mathematical notation and capturing |
| # both its structure and content. |
| # |
| # With additional changes for integration into the validator.nu |
| # service. |
| # |
| # Copyright 1998-2010 W3C (MIT, ERCIM, Keio) |
| # Copyright 2012 Mozilla Foundation |
| # |
| # Use and distribution of this code are permitted under the terms |
| # W3C Software Notice and License |
| # http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231 |
| |
| include "mathml3-strict-content.rnc"{ |
| cn.content = (text | mglyph | sep | PresentationExpression)* |
| cn.attributes = CommonAtt, DefEncAtt, attribute type {text}?, math-base? |
| |
| ci.attributes = CommonAtt, DefEncAtt, ci.type? |
| ci.type = attribute type {text} |
| ci.content = (text | mglyph | PresentationExpression)* |
| |
| csymbol.attributes = CommonAtt, DefEncAtt, attribute type {text}?,cd? |
| csymbol.content = (text | mglyph | PresentationExpression)* |
| |
| bvar = element bvar { (ci | semantics-ci) & degree?} |
| |
| cbytes.attributes = CommonAtt, DefEncAtt |
| |
| cs.attributes = CommonAtt, DefEncAtt |
| |
| apply.content = ContExp+ | (ContExp, BvarQ, Qualifier*, ContExp*) |
| |
| bind.content = apply.content |
| } |
| |
| # changed pattern name to math-base to avoid name conflict - mike |
| math-base = attribute base { text } |
| |
| |
| sep = element sep {empty} |
| PresentationExpression |= notAllowed |
| |
| |
| DomainQ = (domainofapplication|condition|interval|(lowlimit,uplimit?))* |
| domainofapplication = element domainofapplication {ContExp} |
| condition = element condition {ContExp} |
| uplimit = element uplimit {ContExp} |
| lowlimit = element lowlimit {ContExp} |
| |
| Qualifier = DomainQ|degree|momentabout|logbase |
| degree = element degree {ContExp} |
| momentabout = element momentabout {ContExp} |
| logbase = element logbase {ContExp} |
| |
| type = attribute type {text} |
| order = attribute order {"numeric" | "lexicographic"} |
| closure = attribute closure {text} |
| |
| |
| ContExp |= piecewise |
| |
| |
| piecewise = element piecewise {CommonAtt, DefEncAtt,(piece* & otherwise?)} |
| |
| piece = element piece {CommonAtt, DefEncAtt, ContExp, ContExp} |
| |
| otherwise = element otherwise {CommonAtt, DefEncAtt, ContExp} |
| |
| |
| DeprecatedContExp = reln | fn | declare |
| ContExp |= DeprecatedContExp |
| |
| reln = element reln {ContExp*} |
| fn = element fn {ContExp} |
| declare = element declare {attribute type {xsd:string}?, |
| attribute scope {xsd:string}?, |
| attribute nargs {xsd:nonNegativeInteger}?, |
| attribute occurrence {"prefix"|"infix"|"function-model"}?, |
| DefEncAtt, |
| ContExp+} |
| |
| |
| interval.class = interval |
| ContExp |= interval.class |
| |
| |
| interval = element interval { CommonAtt, DefEncAtt,closure?, ContExp,ContExp} |
| |
| unary-functional.class = inverse | ident | domain | codomain | math-image | ln | log | moment |
| ContExp |= unary-functional.class |
| |
| |
| inverse = element inverse { CommonAtt, DefEncAtt, empty} |
| ident = element ident { CommonAtt, DefEncAtt, empty} |
| domain = element domain { CommonAtt, DefEncAtt, empty} |
| codomain = element codomain { CommonAtt, DefEncAtt, empty} |
| # changed pattern name to math-image to avoid name conflict - mike |
| math-image = element image { CommonAtt, DefEncAtt, empty } |
| ln = element ln { CommonAtt, DefEncAtt, empty} |
| log = element log { CommonAtt, DefEncAtt, empty} |
| moment = element moment { CommonAtt, DefEncAtt, empty} |
| |
| lambda.class = lambda |
| ContExp |= lambda.class |
| |
| |
| lambda = element lambda { CommonAtt, DefEncAtt, BvarQ, DomainQ, ContExp} |
| |
| nary-functional.class = compose |
| ContExp |= nary-functional.class |
| |
| |
| compose = element compose { CommonAtt, DefEncAtt, empty} |
| |
| binary-arith.class = quotient | divide | minus | power | rem | root |
| ContExp |= binary-arith.class |
| |
| |
| quotient = element quotient { CommonAtt, DefEncAtt, empty} |
| divide = element divide { CommonAtt, DefEncAtt, empty} |
| minus = element minus { CommonAtt, DefEncAtt, empty} |
| power = element power { CommonAtt, DefEncAtt, empty} |
| rem = element rem { CommonAtt, DefEncAtt, empty} |
| root = element root { CommonAtt, DefEncAtt, empty} |
| |
| unary-arith.class = factorial | minus | root | abs | conjugate | arg | real | imaginary | floor | ceiling | exp |
| ContExp |= unary-arith.class |
| |
| |
| factorial = element factorial { CommonAtt, DefEncAtt, empty} |
| abs = element abs { CommonAtt, DefEncAtt, empty} |
| conjugate = element conjugate { CommonAtt, DefEncAtt, empty} |
| arg = element arg { CommonAtt, DefEncAtt, empty} |
| real = element real { CommonAtt, DefEncAtt, empty} |
| imaginary = element imaginary { CommonAtt, DefEncAtt, empty} |
| floor = element floor { CommonAtt, DefEncAtt, empty} |
| ceiling = element ceiling { CommonAtt, DefEncAtt, empty} |
| exp = element exp { CommonAtt, DefEncAtt, empty} |
| |
| nary-minmax.class = max | min |
| ContExp |= nary-minmax.class |
| |
| |
| max = element max { CommonAtt, DefEncAtt, empty} |
| min = element min { CommonAtt, DefEncAtt, empty} |
| |
| nary-arith.class = plus | times | gcd | lcm |
| ContExp |= nary-arith.class |
| |
| |
| plus = element plus { CommonAtt, DefEncAtt, empty} |
| times = element times { CommonAtt, DefEncAtt, empty} |
| gcd = element gcd { CommonAtt, DefEncAtt, empty} |
| lcm = element lcm { CommonAtt, DefEncAtt, empty} |
| |
| nary-logical.class = and | or | xor |
| ContExp |= nary-logical.class |
| |
| |
| and = element and { CommonAtt, DefEncAtt, empty} |
| or = element or { CommonAtt, DefEncAtt, empty} |
| xor = element xor { CommonAtt, DefEncAtt, empty} |
| |
| unary-logical.class = not |
| ContExp |= unary-logical.class |
| |
| |
| not = element not { CommonAtt, DefEncAtt, empty} |
| |
| binary-logical.class = implies | equivalent |
| ContExp |= binary-logical.class |
| |
| |
| implies = element implies { CommonAtt, DefEncAtt, empty} |
| equivalent = element equivalent { CommonAtt, DefEncAtt, empty} |
| |
| quantifier.class = forall | exists |
| ContExp |= quantifier.class |
| |
| |
| forall = element forall { CommonAtt, DefEncAtt, empty} |
| exists = element exists { CommonAtt, DefEncAtt, empty} |
| |
| nary-reln.class = eq | gt | lt | geq | leq |
| ContExp |= nary-reln.class |
| |
| |
| eq = element eq { CommonAtt, DefEncAtt, empty} |
| gt = element gt { CommonAtt, DefEncAtt, empty} |
| lt = element lt { CommonAtt, DefEncAtt, empty} |
| geq = element geq { CommonAtt, DefEncAtt, empty} |
| leq = element leq { CommonAtt, DefEncAtt, empty} |
| |
| binary-reln.class = neq | approx | factorof | tendsto |
| ContExp |= binary-reln.class |
| |
| |
| neq = element neq { CommonAtt, DefEncAtt, empty} |
| approx = element approx { CommonAtt, DefEncAtt, empty} |
| factorof = element factorof { CommonAtt, DefEncAtt, empty} |
| tendsto = element tendsto { CommonAtt, DefEncAtt, type?, empty} |
| |
| int.class = int |
| ContExp |= int.class |
| |
| |
| int = element int { CommonAtt, DefEncAtt, empty} |
| |
| Differential-Operator.class = diff |
| ContExp |= Differential-Operator.class |
| |
| |
| diff = element diff { CommonAtt, DefEncAtt, empty} |
| |
| partialdiff.class = partialdiff |
| ContExp |= partialdiff.class |
| |
| |
| partialdiff = element partialdiff { CommonAtt, DefEncAtt, empty} |
| |
| unary-veccalc.class = divergence | grad | curl | laplacian |
| ContExp |= unary-veccalc.class |
| |
| |
| divergence = element divergence { CommonAtt, DefEncAtt, empty} |
| grad = element grad { CommonAtt, DefEncAtt, empty} |
| curl = element curl { CommonAtt, DefEncAtt, empty} |
| laplacian = element laplacian { CommonAtt, DefEncAtt, empty} |
| |
| nary-setlist-constructor.class = math-set | \list |
| ContExp |= nary-setlist-constructor.class |
| |
| |
| # changed pattern name to math-set to avoid name conflict - mike |
| math-set = element set { CommonAtt, DefEncAtt, type?, BvarQ*, DomainQ*, ContExp*} |
| \list = element \list { CommonAtt, DefEncAtt, order?, BvarQ*, DomainQ*, ContExp*} |
| |
| nary-set.class = union | intersect | cartesianproduct |
| ContExp |= nary-set.class |
| |
| |
| union = element union { CommonAtt, DefEncAtt, empty} |
| intersect = element intersect { CommonAtt, DefEncAtt, empty} |
| cartesianproduct = element cartesianproduct { CommonAtt, DefEncAtt, empty} |
| |
| binary-set.class = in | notin | notsubset | notprsubset | setdiff |
| ContExp |= binary-set.class |
| |
| |
| in = element in { CommonAtt, DefEncAtt, empty} |
| notin = element notin { CommonAtt, DefEncAtt, empty} |
| notsubset = element notsubset { CommonAtt, DefEncAtt, empty} |
| notprsubset = element notprsubset { CommonAtt, DefEncAtt, empty} |
| setdiff = element setdiff { CommonAtt, DefEncAtt, empty} |
| |
| nary-set-reln.class = subset | prsubset |
| ContExp |= nary-set-reln.class |
| |
| |
| subset = element subset { CommonAtt, DefEncAtt, empty} |
| prsubset = element prsubset { CommonAtt, DefEncAtt, empty} |
| |
| unary-set.class = card |
| ContExp |= unary-set.class |
| |
| |
| card = element card { CommonAtt, DefEncAtt, empty} |
| |
| sum.class = sum |
| ContExp |= sum.class |
| |
| |
| sum = element sum { CommonAtt, DefEncAtt, empty} |
| |
| product.class = product |
| ContExp |= product.class |
| |
| |
| product = element product { CommonAtt, DefEncAtt, empty} |
| |
| limit.class = limit |
| ContExp |= limit.class |
| |
| |
| limit = element limit { CommonAtt, DefEncAtt, empty} |
| |
| unary-elementary.class = sin | cos | tan | sec | csc | cot | sinh | cosh | tanh | sech | csch | coth | arcsin | arccos | arctan | arccosh | arccot | arccoth | arccsc | arccsch | arcsec | arcsech | arcsinh | arctanh |
| ContExp |= unary-elementary.class |
| |
| |
| sin = element sin { CommonAtt, DefEncAtt, empty} |
| cos = element cos { CommonAtt, DefEncAtt, empty} |
| tan = element tan { CommonAtt, DefEncAtt, empty} |
| sec = element sec { CommonAtt, DefEncAtt, empty} |
| csc = element csc { CommonAtt, DefEncAtt, empty} |
| cot = element cot { CommonAtt, DefEncAtt, empty} |
| sinh = element sinh { CommonAtt, DefEncAtt, empty} |
| cosh = element cosh { CommonAtt, DefEncAtt, empty} |
| tanh = element tanh { CommonAtt, DefEncAtt, empty} |
| sech = element sech { CommonAtt, DefEncAtt, empty} |
| csch = element csch { CommonAtt, DefEncAtt, empty} |
| coth = element coth { CommonAtt, DefEncAtt, empty} |
| arcsin = element arcsin { CommonAtt, DefEncAtt, empty} |
| arccos = element arccos { CommonAtt, DefEncAtt, empty} |
| arctan = element arctan { CommonAtt, DefEncAtt, empty} |
| arccosh = element arccosh { CommonAtt, DefEncAtt, empty} |
| arccot = element arccot { CommonAtt, DefEncAtt, empty} |
| arccoth = element arccoth { CommonAtt, DefEncAtt, empty} |
| arccsc = element arccsc { CommonAtt, DefEncAtt, empty} |
| arccsch = element arccsch { CommonAtt, DefEncAtt, empty} |
| arcsec = element arcsec { CommonAtt, DefEncAtt, empty} |
| arcsech = element arcsech { CommonAtt, DefEncAtt, empty} |
| arcsinh = element arcsinh { CommonAtt, DefEncAtt, empty} |
| arctanh = element arctanh { CommonAtt, DefEncAtt, empty} |
| |
| nary-stats.class = mean | sdev | variance | median | mode |
| ContExp |= nary-stats.class |
| |
| |
| mean = element mean { CommonAtt, DefEncAtt, empty} |
| sdev = element sdev { CommonAtt, DefEncAtt, empty} |
| variance = element variance { CommonAtt, DefEncAtt, empty} |
| median = element median { CommonAtt, DefEncAtt, empty} |
| mode = element mode { CommonAtt, DefEncAtt, empty} |
| |
| nary-constructor.class = vector | matrix | matrixrow |
| ContExp |= nary-constructor.class |
| |
| |
| vector = element vector { CommonAtt, DefEncAtt, BvarQ, DomainQ, ContExp*} |
| matrix = element matrix { CommonAtt, DefEncAtt, BvarQ, DomainQ, ContExp*} |
| matrixrow = element matrixrow { CommonAtt, DefEncAtt, BvarQ, DomainQ, ContExp*} |
| |
| unary-linalg.class = determinant | transpose |
| ContExp |= unary-linalg.class |
| |
| |
| determinant = element determinant { CommonAtt, DefEncAtt, empty} |
| transpose = element transpose { CommonAtt, DefEncAtt, empty} |
| |
| nary-linalg.class = selector |
| ContExp |= nary-linalg.class |
| |
| |
| selector = element selector { CommonAtt, DefEncAtt, empty} |
| |
| binary-linalg.class = vectorproduct | scalarproduct | outerproduct |
| ContExp |= binary-linalg.class |
| |
| |
| vectorproduct = element vectorproduct { CommonAtt, DefEncAtt, empty} |
| scalarproduct = element scalarproduct { CommonAtt, DefEncAtt, empty} |
| outerproduct = element outerproduct { CommonAtt, DefEncAtt, empty} |
| |
| constant-set.class = integers | reals | rationals | naturalnumbers | complexes | primes | emptyset |
| ContExp |= constant-set.class |
| |
| |
| integers = element integers { CommonAtt, DefEncAtt, empty} |
| reals = element reals { CommonAtt, DefEncAtt, empty} |
| rationals = element rationals { CommonAtt, DefEncAtt, empty} |
| naturalnumbers = element naturalnumbers { CommonAtt, DefEncAtt, empty} |
| complexes = element complexes { CommonAtt, DefEncAtt, empty} |
| primes = element primes { CommonAtt, DefEncAtt, empty} |
| emptyset = element emptyset { CommonAtt, DefEncAtt, empty} |
| |
| constant-arith.class = exponentiale | imaginaryi | notanumber | true | false | pi | eulergamma | infinity |
| ContExp |= constant-arith.class |
| |
| |
| exponentiale = element exponentiale { CommonAtt, DefEncAtt, empty} |
| imaginaryi = element imaginaryi { CommonAtt, DefEncAtt, empty} |
| notanumber = element notanumber { CommonAtt, DefEncAtt, empty} |
| true = element true { CommonAtt, DefEncAtt, empty} |
| false = element false { CommonAtt, DefEncAtt, empty} |
| pi = element pi { CommonAtt, DefEncAtt, empty} |
| eulergamma = element eulergamma { CommonAtt, DefEncAtt, empty} |
| infinity = element infinity { CommonAtt, DefEncAtt, empty} |
