nora_mark 0.2beta3 → 0.2beta4

data/spec/epub30-schemas/mod/mathml/mathml3-content.rnc

@@ -0,0 +1,373 @@
+
+#     This is the Mathematical Markup Language (MathML) 3.0, an XML
+#     application for describing mathematical notation and capturing
+#     both its structure and content.
+#
+#     Copyright 1998-2010 W3C (MIT, ERCIM, Keio)
+# 
+#     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}?, 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
+}
+
+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 | 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}
+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 = set | \list
+ContExp |= nary-setlist-constructor.class
+
+
+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}