UnitfulParsableString

UnitfulParsableString.jl expand Unitful.jl to add the method Unitful.string which convert Quantity (or some type) to parsable String.

julia> using Unitful julia> string(1.0u"m*s") "1.0 m s" # <- julia cannot parse julia> string(1.0u"m*s") |> Unitful.uparse ERROR: Base.Meta.ParseError("extra token \"m\" after end of expression") julia> using UnitfulParsableString julia> string(1.0u"m*s") "1.0(m*s)" # <- julia can parse julia> string(1.0u"m*s") |> Unitful.uparse 1.0 m s

Unitful.string(unit::Units)

Values of Unitful.Units subtypes are converted to string that julia can parse as following rules.

Multi-units are expressed as basicaly separeted by "*", but sometimes "/" is used exceptionally for simplicity, see below for details. Exponents are expressed as "^x" or "^-x" (x > 0) in principle, except for units with a rational exponent y, which are expressed by wrapping them in parentheses as "^(y)".

When all exponential of the units is positive, all separates are "*".

julia> string(u"m*s^2") "m*s^2"

When all exponential of the units is negative, all separates are "*" and the negative exponential is expressed as "^-|w|".

julia> string(u"(m*s)^-1") # all exponents are negative "m^-1*s^-1" # -> separater is "*"

When both positive and negative exponentials coexist, if there are rational exponentials, all separates are "*" and the negative exponential is expressed as "^-|w|".

julia> string(u"m^(1/2)*s^-2") # positive and negative exponent coexist "m^(1/2)*s^-2" # if rational exponent exist -> separater is "*"

When both positive and negative exponentials coexist, if not there are rational exponentials, the separates of the units with negative exponential are "/" and the negative exponential is expressed as "^|w|".

julia> string(u"m*s^-2") # positive and negative exponent coexist "m/s^2" # if rational exponent never exist -> "/" can be use for separater

When the exponentials are rational, if the velue n//m is strictly same as n/m, it is expressed as "^(n/m)".

julia> string(u"m^(1//2)") # 1//2 == 1/2 "m^(1/2)"

If not the velue n//m is strictly same as n/m, it is expressed as "^(n//m)".

julia> string(u"m^(1//3)") # 1//3 != 1/3 "m^(1//3)"

Unitful.string(x::Quantity)

Values of Unitful.Quantity subtypes to string that julia can parse as following rules.

The Unitful.Quantity x have value and units (they can be get x.val and unit(x)). Thus, the work of this function is simply shown as follows:

string( ["(",] string(value), [")",] ["*",] ["(",] string(units) [,")"] )

The presence or absence of each bracket is determined by the return values of the has_value_bracket(x) and has_unit_bracket(x) functions. And the sepaprator "*" is inserted, if has_value_bracket(x) && has_unit_bracket(x) == true.

The has_value_bracket(x) returns false if string(x) contains only digits, and true if it contains non-digits. However, if typeof(x) is a specific type, the process is lightened by multiple dispatching.

The has_unit_bracket(x) returns false if the unit(x) consists of single type unit, and true if it consists of multi type units.

Note: see Unitful.string(x::Unitlike) about the string expression of unit.
Note: if unit(x) == NoUnits, this method output only string(x.val).

At the case of Int the bracket is absence and, at the case of the unit consists of only s the bracket is absence.
has_value_bracket(x) = false && has_unit_bracket(x) == false

julia> string(u"1s^2")# u"1s^2" -> 1 s² "1s^2"

At the case of Float64 the bracket is absence and, at the case of the unit consists of kg and m the bracket is presence.
has_value_bracket(x) = false && has_unit_bracket(x) == true

julia> string(u"1.0m*kg")# u"1.0m*kg" -> 1.0 kg m "1.0(kg*m)"

At the case of Rational the bracket is presence and, at the case of the unit consists of m the bracket is absence.
has_value_bracket(x) = true && has_unit_bracket(x) == false

julia> string((1//2)u"m")# (1//2)u"m" -> 1//2 m "(1//2)m"

At the case of Rational the bracket is presence and, at the case of the unit consists of m and s the bracket is presence.
has_value_bracket(x) = true && has_unit_bracket(x) == true

julia> string((1+2im)u"m/s")# (1+2im)u"m/s" -> (1 + 2im) m s⁻¹ "(1 + 2im)*(m/s)"

julia> using UnitfulParsableString julia> x = u"1.0m^2/K^(1//3)" 1.0 m² K⁻¹ᐟ³ julia> x |> string |> uparse == x true julia> x = 2u"m"//3u"s" 2//3 m s⁻¹ julia> x |> string |> uparse == x true

See more test/runtest.jl.

UnitfulParsableString.jl not change the display, show and print functions about Unitful.jl.

julia> using Unitful julia> 1.0u"m" 1.0 m julia> 1.0u"m*s" 1.0 m s julia> using UnitfulParsableString julia> 1.0u"m" 1.0 m julia> 1.0u"m*s" 1.0 m s

This package not support Logscaled units i.e., Gain or Lebel yet. Array of Quantity is now supported, but implementation is too rough. Please use at your own risk.

• Unitful.jl - Implements dimensional numerical quantities for Julia