plurimath 0.10.7 → 0.10.9.pre.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 14c446bc1c84d523b37daea2d902eb69ecc7a5ee9b586dc425da9780b8d84560
-  data.tar.gz: 69f9e89f24bb17ebb5d9b2d8b9f5f91faeb7469d0b838b8e20e63b7fadef08c7
+  metadata.gz: e399a104da75213be9f312c84c413650fd5a52c15f159ffa53587ea7edb8da50
+  data.tar.gz: d2aeea44e7ebaf4a761337b534a9720a8da261b5e3f552c1ddc8b50edaff7599
 SHA512:
-  metadata.gz: b1f55afb6b629f26a4766bbc5839cce6814b5d47c743c91c7c232639d13ea3411c5b73531976b094b5de57157ef12f6df0ce1586f33c1a529916c9af4c275ec1
-  data.tar.gz: 8c07b342deb4e97f1993a5825ea5d53cdb1e8f96ccd65e37efdee90d1b4b960773bbcb41737df348ca1ca2c055e222f30837c173d234334fc368d0e30375fd21
+  metadata.gz: 676a1e8b22a782617673e665b0fa53bdb5fe6e6c348cf893517dcb648984ad58418d43a6cca7a6e7d5bbe1bdaae66339a0995aeff096292fee0f51827dc2bd1f
+  data.tar.gz: 8e2e2c44156b845ca0f0e9aa3354586c89cb3d057ef8dd9b7072e4a23232b785a217ef068cc8beb42d4f00d6e376a2ef4022065dfeaa53c6c573b64a9047da2a

data/.github/workflows/release.yml

@@ -10,8 +10,8 @@ on:
           Next release version. Possible values: x.y.z, major, minor, patch or pre|rc|etc
         required: true
         default: 'skip'
-  push:
-    tags: [ v* ]
+  repository_dispatch:
+    types: [ do-release ]
 
 jobs:
   release:
@@ -23,3 +23,4 @@ jobs:
       next_version: ${{ github.event.inputs.next_version }}
     secrets:
       rubygems-api-key: ${{ secrets.PLURIMATH_CI_RUBYGEMS_API_KEY }}
+      pat_token: ${{ secrets.PLURIMATH_CI_PAT_TOKEN }}

data/README.adoc

@@ -160,6 +160,72 @@ asciimath = "sin(1)"
 formula = Plurimath::Math.parse(asciimath, :asciimath)
 ----
 
+==== Localized decimal input
+
+AsciiMath, LaTeX, HTML, and UnicodeMath input can use a locale decimal marker
+from `Plurimath::Formatter::SupportedLocales::LOCALES` when parsing numbers.
+Pass `locale:` to `Plurimath::Math.parse` for one parse, or use
+`Plurimath.configure` for persistent defaults.
+
+For AsciiMath, LaTeX, and HTML, the configured marker is the decimal marker.
+When a locale uses a non-full-stop marker, `1.2` is parsed as `1`, `.`, and
+`2`, not as one decimal number.
+
+[source,ruby]
+----
+formula = Plurimath::Math.parse("1,2", :asciimath, locale: :fr)
+----
+
+When the locale decimal marker is a comma, unspaced digit-comma-digit input is
+read as a decimal number.
+
+[source,asciimath]
+----
+1,2      # decimal number
+1 , 2    # comma separator
+----
+
+AsciiMath uses commas for expression and table separators, so separator commas
+between digit tokens should be written with spaces around them when the
+configured decimal marker is a comma.
+
+HTML can use the same configured decimal marker inside plain text or tags.
+
+[source,html]
+----
+1,2
+<span>1,2</span>
+----
+
+Locales are not limited to full stop and comma markers. For example, Arabic and
+Persian locales use the Arabic decimal separator.
+
+[source,ruby]
+----
+formula = Plurimath::Math.parse("1٫2", :unicode, locale: :ar)
+----
+
+LaTeX ordinary spaces are removed during parser preprocessing, so `1, 2` is
+equivalent to `1,2` for this parser. With a comma decimal marker, only
+digit-comma-digit is parsed as a decimal number; a leading comma remains a comma
+symbol followed by a number. To write a comma separator between two digits,
+wrap the comma or the following value in a group, such as `1{,}2` or `1,{}2`.
+
+[source,latex]
+----
+1,2      % decimal number
+1{,}2    % comma separator
+1,{}2    % comma separator
+----
+
+UnicodeMath is different: it keeps its existing full stop and comma decimal
+grammar, including leading markers such as `.2` and `,2`, and also accepts the
+configured locale marker.
+
+Localized decimal parsing preserves the parsed number text, such as `1,2` or
+`1٫2`. Number formatter input remains canonical decimal input; locale decimal
+and grouping symbols are applied when formatting output.
+
 ==== MathML Formula example
 
 [source,ruby]
@@ -403,6 +469,11 @@ priority, ordered from highest to lowest precedence:
 . The `localizer_symbols` hash in the creation of a `Plurimath::NumberFormatter`
 . The **default configuration** of the locale of the `Plurimath::NumberFormatter`
 
+`precision` is resolved separately: the `precision:` keyword passed to
+`localized_number`, which defaults to the formatter instance's `precision`
+value, takes precedence over any `precision` provided through the formatter
+symbols or `format` hash.
+
 
 [example]
 .Formatting a number to group every 2 digits
@@ -488,6 +559,9 @@ formatter = Plurimath::NumberFormatter.new(:en)
 The `Plurimath::NumberFormatter` object can be configured using either the
 `localize_number` or `localizer_symbols` options.
 
+`Plurimath::Formatter::Standard` exposes the same configuration through the
+`string_format` and `options` initializer arguments.
+
 
 [[localizer_symbols]]
 ===== Via "format options" using `localizer_symbols`
@@ -499,14 +573,17 @@ This Hash object is called the "format options Hash".
 
 Available options are explained below.
 
-NOTE: Each option takes an input of a certain specified type (`String` or
-`Numeric`). Using an input type other than the specified type will result in
-errors or incorrect output.
+NOTE: Each option takes an input of a certain specified type. Using an input
+type other than the specified type will result in errors or incorrect output.
 
 The values passed to `localizer_symbols` persist as long as the initialized
 `NumberFormatter` instance is accessible. It is therefore useful in scenarios
 when configuration will be static or changes are not required very often.
 
+The same option keys can be passed through `localizer_symbols`, through the
+per-call `format:` hash, or through `Plurimath::Formatter::Standard`'s
+`options:` argument.
+
 
 `decimal`:: (`String` value)
 Symbol to use for the decimal point. Accepts a character.
@@ -566,6 +643,60 @@ Accepts an integer value. (default is 3 in most locales.)
 "32232.232" => "3 22 32.232"
 ====
 
+`number_sign`:: (`Symbol` or `String` value)
+Controls whether positive numbers are rendered with an explicit sign. Use
+`:plus` or `"plus"` to add a leading `+` to positive values. Negative values
+keep their normal `-` sign. The sign is applied before base prefixes and before
+notation rendering.
++
+.Showing a positive number sign
+[example]
+====
+When `base` is used, the input string is still the source decimal value; `base`
+controls the rendered output base.
+
+"14236.39239" with `number_sign: :plus` => "+14,236.39239"
+"10" with `base: 2, number_sign: :plus, group_digits: 2, group: ","` => "+0b10,10"
+====
+
+`padding`:: (`String` value)
+Character to use when padding the integer portion. Defaults to `0`.
++
+.Using spaces as integer padding
+[example]
+====
+"32" with `padding_digits: 6, padding: " ", group: ""` => "    32"
+====
+
+`padding_digits`:: (`Numeric` value)
+Minimum number of integer digits to render. Missing integer digits are inserted
+before grouping using the configured `padding` character. Do not use it together
+with `padding_group_digits`.
++
+Padding is applied before integer grouping, so padding characters are grouped
+with the rest of the integer digits.
++
+.Padding to a fixed integer width
+[example]
+====
+"32"    with `padding_digits: 6, group: ""` => "000032"
+"32123" with `padding_digits: 6, group: ""` => "032123"
+"32"    with `padding_digits: 6, group_digits: 3, group: " "` => "000 032"
+====
+
+`padding_group_digits`:: (`Numeric` value)
+Pads the integer portion to the lowest multiple of the configured digit count.
+Missing integer digits are inserted before grouping using the configured
+`padding` character. Do not use it together with `padding_digits`.
++
+.Padding to an integer width multiple
+[example]
+====
+"32"    with `padding_group_digits: 4, group: ""` => "0032"
+"32123" with `padding_group_digits: 4, group: ""` => "00032123"
+====
+====
+
 `base`:: (`Numeric` value)
 Sets the numeric base (radix) used to render both the integer and fractional parts of the number.
 Supported values are 2 (binary), 8 (octal), 10 (decimal, default) and 16 (hexadecimal).
@@ -593,30 +724,39 @@ When omitted, standard prefixes are used (`0b` for base 2, `0o` for base 8, `0x`
 "255" with `base: 16, base_prefix: ""`   => "ff"
 ====
 
-`base_postfix`:: (`String` value)
-If present, a postfix is appended to the converted number instead of using any base prefix.
+`base_postfix`:: (`String` or `nil` value)
+If present without `base_prefix`, a postfix is appended to the converted number
+instead of using the default base prefix. When `base_prefix` is also provided,
+the prefix and postfix are both rendered.
 This is applied after digit grouping.
-`nil` or an empty string can be used to omit the postfix.
+Because the formatter checks whether the `base_postfix` key is present, setting
+it to `nil` or an empty string omits both the postfix and the default base
+prefix.
 +
 .Using postfix notation
 [example]
 ====
 "255" with `base: 16, base_postfix: "_16"` => "ff_16"
+"255" with `base: 16, base_prefix: "16#", base_postfix: "_16"` => "16#ff_16"
 "255" with `base: 16, base_postfix: nil` => "ff"
 "255" with `base: 16, base_postfix: ""` => "ff"
 ====
 
-`hex_capital`:: (`Boolean` value)
-When `true` and `base: 16`, all characters in the range `a`-`f` in the converted output
-are rendered using uppercase letters. This includes both hexadecimal digits and any
-separators (such as `decimal`, `group`, `fraction_group`) that happen to be letters
-in the `a`-`f` range. The `base_prefix` and `base_postfix` values are never modified.
-It has no effect for other bases.
+`hex_capital`:: (`Boolean` or `:numbers_only` value)
+Controls uppercase rendering for hexadecimal output. When `true` and `base: 16`,
+all characters in the range `a`-`f` in the converted output are rendered using
+uppercase letters. This includes both hexadecimal digits and any separators
+(such as `decimal`, `group`, `fraction_group`) that happen to be letters in the
+`a`-`f` range. The `base_prefix` and `base_postfix` values are never modified.
++
+Use `:numbers_only` to uppercase generated hexadecimal digits without changing
+separator characters. It has no effect for other bases.
 +
 .Uppercase hexadecimal output
 [example]
 ====
-"48879" with `base: 16, hex_capital: true` => "0xBE,EF"
+"48879" with `base: 16, hex_capital: true, group_digits: 2` => "0xBE,EF"
+"48879" with `base: 16, hex_capital: :numbers_only, group_digits: 2, group: "e"` => "0xBEeEF"
 ====
 +
 WARNING: If you use separator characters in the range `a`-`f` (such as `decimal: "d"` or `fraction_group: "f"`), those separators will also be uppercased when `hex_capital: true`. Choose separators outside this range (e.g., `".", ",", " ", "_"`) if you need them to remain unchanged.
@@ -624,9 +764,9 @@ WARNING: If you use separator characters in the range `a`-`f` (such as `decimal:
 .Separator uppercasing behavior
 [example]
 ====
-"48879" with `base: 16, hex_capital: true, group: "g"` => "0xBEgEF" (g remains lowercase)
+"48879" with `base: 16, hex_capital: true, group_digits: 2, group: "g"` => "0xBEgEF" (g remains lowercase)
 
-"48879" with `base: 16, hex_capital: true, group: "f"` => "0xBEFEF" (f separator becomes F)
+"48879" with `base: 16, hex_capital: true, group_digits: 2, group: "f"` => "0xBEFEF" (f separator becomes F)
 ====
 
 NOTE: When `base` is not 10, both the integer and fractional parts are converted to the specified base.
@@ -638,7 +778,10 @@ as decimal `0.75` for the fractional part) and converts that real value to the r
 ===== Base conversion with other formatting options
 
 Base conversion works seamlessly with other formatting options such as `precision`, `digit_count`,
-`fraction_group`, `fraction_group_digits`, and `significant`.
+`fraction_group`, `fraction_group_digits`, `significant`, and integer padding.
++
+Integer padding is applied after `digit_count` rounding, so padding can add
+integer digits after the total visible-digit budget has been resolved.
 
 .Base conversion with precision
 [example]
@@ -696,8 +839,44 @@ right. Accepts an integer value.
 "32232.232131" => "32232.23 21 31"
 ====
 
+[[format_option_significant]]
 `significant`:: (`Numeric` value)
 Sets the number of significant digits to show, with the value rounded.
+Leading zeros before the first non-zero digit are not counted as significant.
++
+.Using significant digits
+[example]
+====
+"112"    with `significant: 2` => "110"
+"1999"   with `significant: 2` => "2,000"
+"0.1999" with `significant: 3` => "0.200"
+====
++
+Significant-digit rounding is applied before localized rendering. This means
+the formatter does not re-parse an already grouped or localized output string,
+so `decimal` and `group` may use the same symbol without changing which digits
+are rounded.
++
+.Using significant digits with overlapping decimal and group symbols
+[example]
+====
+"327428.7432878432992" with `decimal: ","`, `group_digits: 3`, `fraction_group_digits: 2`, `fraction_group: "'"`, `significant: 9`
+=> "327,428,74'3"
+====
++
+When `base` is not 10 and `precision` is omitted, Plurimath infers the
+fractional precision needed in the target base where possible. That inference
+is capped by the source number's significant digits, so finite converted values
+can keep required trailing zeros while repeating fractional conversions are not
+expanded only to fill the requested count.
++
+.Using significant digits with base conversion
+[example]
+====
+"48879"  with `base: 16, significant: 3, group_digits: 2, group: ","` => "0xbe,f0"
+"123.25" with `base: 16, significant: 5, group_digits: 10` => "0x7b.400"
+"0.1"    with `base: 16, significant: 5, group_digits: 10` => "0x0.1"
+====
 
 `notation`:: (`String` value)
 Specifies the mathematical notation to be used. Accepts the following values.
@@ -751,12 +930,12 @@ modes: `scientific` and `engineering`). Defaults to `×`.
 ----
 ====
 
-`exponent_sign`:: (`String` value)
+`exponent_sign`:: (`Symbol` or `String` value)
 Whether to use a plus sign to indicate positive exponents, in exponent-based
 notation (used in the modes: `e`, `scientific`, `engineering`). Legal values
 are:
 
-`plus`::: The `+` symbol is used.
+`:plus`, `"plus"`::: The `+` symbol is used.
 +
 .Using the plus sign to indicate positive exponents
 [example]
@@ -773,13 +952,27 @@ These options are to be grouped under a single Hash object.
 ----
 {
   decimal: ",",             # replaces the decimal point with the passed string
-  group_digits: 2,          # groups integer part into passed integer
-  group: "'",               # places the string between grouped parts of the integer
-  fraction_group_digits: 3, # groups fraction part into passed integer
-  fraction_group: ",",      # places the string between grouped parts of the fraction
+  group_digits: 2,          # groups integer digits into groups of the passed size
+  group: "'",               # places the string between grouped integer digits
+  fraction_group_digits: 3, # groups fraction digits into groups of the passed size
+  fraction_group: ",",      # places the string between grouped fraction digits
+  number_sign: :plus,       # adds a plus sign to positive numbers
+  digit_count: 6,           # limits the total rendered digit count
+  significant: 4,           # limits the rendered significant digit count
+  precision: 2,             # controls rendered fractional precision
+  notation: :scientific,    # renders the number using the selected notation
+  e: "E",                   # sets the exponent marker for E notation
+  times: "x",               # sets the multiplication symbol for power notation
+  exponent_sign: :plus,     # adds a plus sign to positive exponents
+  base: 16,                 # renders the number in the selected base
+  base_prefix: "0x",        # prefixes non-decimal base output when no postfix key is present
+  base_postfix: "_16",      # appends a postfix and takes precedence over base_prefix
+  hex_capital: :numbers_only, # uppercases generated hexadecimal digits only
 }
 ----
 
+Only include the keys needed for the formatter behavior being configured.
+
 
 [[localize_number]]
 ===== Via the `localize_number` option
@@ -1131,13 +1324,15 @@ The steps to format numbers within a formula are:
 . Create a number formatter that can be configured;
 
 . Apply the number formatter to a formula through the `Formula.to_{format}`
-method using a `formatter` option, which serializes the formula into an math
-representation language.
+method using a `formatter` option, or configure a default formatter through
+`Plurimath.configure`.
 
 The formatter should be an instance of `Plurimath::NumberFormatter` or a custom
 formatter derived from `Plurimath::Formatter::Standard`. Custom formatters can
-define a `format(formula, number)` method to make context-aware formatting
-decisions based on the surrounding formula (see <<Contextual number formatting>>).
+define a `format_number(formula, number)` method to make context-aware
+formatting decisions based on the surrounding formula (see
+<<Contextual number formatting>>). Existing custom formatters that define
+`format(formula, number)` remain supported.
 
 The quick example below demonstrates how to format a number in a formula.
 
@@ -1191,6 +1386,58 @@ print formula.to_mathml(formatter: custom_formatter)
 ----
 ====
 
+[example]
+.Configuring a default number formatter for formula rendering
+====
+[source,ruby]
+----
+Plurimath.configure do |config|
+  config.number_formatter = Plurimath::Formatter::Standard.new
+end
+
+formula = Plurimath::Math.parse("10000 + 2000", :asciimath)
+formula.to_latex
+# => "10,000 + 2,000"
+----
+
+Passing `formatter:` to a formula serialization method takes precedence over
+the configured default formatter.
+====
+
+
+==== Deprecation notices
+
+Plurimath exposes deprecation behavior through the shared configuration object.
+The current number formatter arguments documented above remain supported; this
+setting controls how Plurimath handles deprecation notices when a deprecated
+feature is used.
+
+[source,ruby]
+----
+Plurimath.configure do |config|
+  config.deprecation.behavior = :collect
+end
+
+# Retrieve collected notices after parsing
+Plurimath::Deprecation.notices.each do |notice|
+  puts notice.to_s  # => "[plurimath][DEPRECATION] ..."
+  puts notice.severity  # => :warning
+  puts notice.feature   # => "feature_name"
+end
+----
+
+Supported behaviors are:
+
+`collect`:: Default behavior. Collects deprecation notices in
+`Plurimath::Deprecation.notices` for the caller to retrieve. Each notice is a
+`Plurimath::DeprecationError` with `severity`, `feature`, `replacement`,
+`since`, `remove_in`, and `to_s`.
+
+`raise`:: Raises `Plurimath::DeprecationError` immediately when a deprecated
+feature is used.
+
+`silence`:: Suppresses deprecation notices entirely.
+
 
 ==== Defining a number formatter
 
@@ -1231,15 +1478,29 @@ There are two types of number formatting configuration to change:
 
 . Overriding options through the `options` argument.
 
+.Syntax for creating a `Plurimath::Formatter::Standard` object
+[source,ruby]
+----
+formatter = Plurimath::Formatter::Standard.new(
+  locale: :en,
+  string_format: nil,
+  options: {},
+  precision: nil,
+)
+----
+
 The arguments are:
 
 `locale`:: (default: `:en` for English) a symbol or string value. The supported
 locales are listed in the link:/blog/2024-07-09-number-formatter[number formatter blog post].
 
-`options`:: (default: empty) a hash of options (`localizer_symbols`). The options
-are listed in the link:/blog/2024-07-09-number-formatter[number formatter blog post].
+`options`:: (default: empty) a hash of options. This is the
+`Plurimath::Formatter::Standard` alias for
+`Plurimath::NumberFormatter`'s `localizer_symbols` argument.
 
-`string_format`:: (default: `nil`, disabled) a string value (`localize_number`)
+`string_format`:: (default: `nil`, disabled) a string value. This is the
+`Plurimath::Formatter::Standard` alias for
+`Plurimath::NumberFormatter`'s `localize_number` argument.
 
 `precision`:: (default: `nil`, disabled) an integer value.
 
@@ -1282,7 +1543,7 @@ The custom formatter is to be subclassed from `Plurimath::Formatter::Standard`.
 [source,ruby]
 ----
 class MyCustomFormatter < Plurimath::Formatter::Standard <1>
-  def initialize(locale:, precision:, options:, string_format:) <2>
+  def initialize(locale: :en, precision: nil, options: {}, string_format: nil) <2>
     super
   end
 end
@@ -1297,7 +1558,7 @@ The default options of the custom formatter are set using the
 [source,ruby]
 ----
 class MyCustomFormatter < Plurimath::Formatter::Standard
-  def initialize(locale:, precision:, options:, string_format:)
+  def initialize(locale: :en, precision: nil, options: {}, string_format: nil)
     super
   end
 
@@ -1354,24 +1615,30 @@ In some cases, certain numbers within a formula should be formatted differently
 depending on their context. For example, a year like "2024" should not have digit
 grouping applied, while other numbers in the same formula should.
 
-The `format` method on the formatter receives both the root
+The `format_number` method on the formatter receives both the root
 `Plurimath::Math::Formula` tree and the current `Plurimath::Math::Number` node
 being processed, allowing context-aware formatting decisions.
 
-.Signature of the `format` method
+.Signature of the `format_number` method
 [source,ruby]
 ----
-def format(formula, number)
+def format_number(formula, number)
   # formula: the root Plurimath::Math::Formula containing the full equation
   # number:  the Plurimath::Math::Number node currently being formatted
   # returns: a formatted string
 end
 ----
 
-Formatters that do not define `format` will fall back to `localized_number`, so
-existing formatters continue to work without changes.
+Formula rendering uses the first formatter method available in this order:
+`format_number(formula, number)`, then `format(formula, number)`, then
+`localized_number(number.value.to_s)`. This keeps existing custom formatters
+working while giving new custom formatters a method name specific to formula
+number formatting.
 
-To implement contextual formatting, define a `format` method in a custom
+New custom formatters should define `format_number`; the `format` fallback
+exists for compatibility with existing custom formatters.
+
+To implement contextual formatting, define a `format_number` method in a custom
 formatter subclass.
 
 .Creating a year-aware formatter that skips digit grouping for year-like numbers
@@ -1380,7 +1647,7 @@ formatter subclass.
 [source,ruby]
 ----
 class YearFormatter < Plurimath::Formatter::Standard
-  def format(formula, number) <1>
+  def format_number(formula, number) <1>
     int_value = Integer(number.value, exception: false)
     if int_value && int_value > 1800 && int_value < 2200 <2>
       number.value.to_s
@@ -1395,7 +1662,7 @@ formula = Plurimath::Math.parse("2024 + 1000000", :asciimath)
 formula.to_latex(formatter: formatter)
 # => "2024 + 1,000,000" <4>
 ----
-<1> Define `format` to receive the formula tree and number node.
+<1> Define `format_number` to receive the formula tree and number node.
 <2> Detect year-like numbers and return them unformatted.
 <3> Call `localized_number` to apply locale-based formatting for other numbers.
 <4> "2024" is left as-is, while "1000000" is formatted with digit grouping.
@@ -1405,8 +1672,8 @@ formula.to_latex(formatter: formatter)
 [[standard_configuration]]
 === Default number formatting configuration
 
-The default configuration for formatting numbers is as follows, set in the
-`Plurimath::Formatter::Standard` class.
+The effective default configuration for `Plurimath::Formatter::Standard` is as
+follows.
 
 |===
 |Option key |Description |Value
@@ -1421,7 +1688,11 @@ The default configuration for formatting numbers is as follows, set in the
 
 |`exponent_sign`
 |The sign used for the exponent part of the number
-|`"plus"`
+|`nil`
+
+|`number_sign`
+|The sign used for positive numbers
+|`nil`
 
 |`fraction_group`
 |The character used to separate groups of digits in the fraction part
@@ -1435,6 +1706,18 @@ The default configuration for formatting numbers is as follows, set in the
 |The number of digits in each group of the integer part
 |`3`
 
+|`padding`
+|The character used to pad the integer part
+|`"0"`
+
+|`padding_digits`
+|The minimum number of integer digits to display
+|`0`
+
+|`padding_group_digits`
+|The multiple of integer digits to pad to
+|`0`
+
 |`significant`
 |The number of significant digits to display
 |`0`
@@ -1445,7 +1728,23 @@ The default configuration for formatting numbers is as follows, set in the
 
 |`precision`
 |The number of decimal places to display
-|`0`
+|`nil`
+
+|`base`
+|The numeric base used to render the number
+|`10`
+
+|`base_prefix`
+|The prefix used for non-decimal bases
+|standard prefix for the selected base
+
+|`base_postfix`
+|The postfix used for non-decimal bases
+|`nil`
+
+|`hex_capital`
+|Whether hexadecimal output is capitalized
+|`nil`
 
 |`decimal`
 |The character used as the decimal separator
@@ -1460,7 +1759,7 @@ The default configuration for formatting numbers is as follows, set in the
 |`"x"`
 
 |`e`
-|The character used for exponentiation
+|The character used for E notation
 |`"e"`
 
 |===

data/lib/plurimath/asciimath/parse.rb

@@ -10,7 +10,7 @@ module Plurimath
       rule(:comma)  { str(",") >> space? }
       rule(:space?) { space.maybe }
       rule(:number) do
-        (match("[0-9]").repeat(1) >> str(".") >> match("[0-9]").repeat(1)).as(:number) |
+        (match("[0-9]").repeat(1) >> decimal_marker >> match("[0-9]").repeat(1)).as(:number) |
           match("[0-9]").repeat(1).as(:number) |
           str(".").as(:symbol)
       end
@@ -78,7 +78,7 @@ module Plurimath
           binary_classes |
           ternary_classes |
           hash_to_expression(Constants.precompile_constants) |
-          (match(/[0-9]/).as(:number) >> str(",").as(:comma)).repeat(1).as(:comma_separated) |
+          (match(/[0-9]/).as(:number) >> (decimal_marker >> match("[0-9]")).absent? >> str(",").as(:comma)).repeat(1).as(:comma_separated) |
           quoted_text |
           (str("d").as(:d) >> str("x").as(:x)).as(:intermediate_exp) |
           ((str("left").absent? >> str("right").absent?) >> match["a-zA-Z"].as(:symbol)) |
@@ -196,6 +196,10 @@ module Plurimath
         end
       end
 
+      def decimal_marker
+        str(Plurimath.configuration.decimal)
+      end
+
       def unary_functions(first_value)
         if ["'underbrace'", "'ubrace'"].include?(first_value.to_s)
           (first_value.as(:unary_class) >> space? >> str("_").as(:symbol)).as(:unary) |

data/lib/plurimath/configuration.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+module Plurimath
+  class Configuration
+    DEFAULT_DECIMAL = "."
+
+    attr_accessor :number_formatter, :locale
+
+    def deprecation
+      Deprecation
+    end
+
+    def decimal
+      Formatter::SupportedLocales.decimal_for(locale, default: DEFAULT_DECIMAL)
+    end
+  end
+end