real units (not fake)

[tfiers]

julia> using Unitful

julia> @code_typed 3u"m"*8u"s"
CodeInfo(
1 ─ %1 = Base.getfield(x, :val)::Int64
│   %2 = Base.getfield(y, :val)::Int64
│   %3 = Base.mul_int(%1, %2)::Int64
│   %4 = %new(Quantity{Int64, 𝐋  𝐓 , Unitful.FreeUnits{(m, s), 𝐋  𝐓 , nothing}}, %3)::Quantity{Int64, 𝐋 𝐓, Unitful.FreeUnits{(m, s), 𝐋 𝐓, nothing}}
└──      return %4
) => Quantity{Int64, 𝐋  𝐓 , Unitful.FreeUnits{(m, s), 𝐋  𝐓 , nothing}}

julia> @code_typed 3u"m"+8u"s"
CodeInfo(
1 ─ %1 = Unitful.DimensionError::Type{Unitful.DimensionError}
│   %2 = %new(%1, x, y)::Unitful.DimensionError
│        Unitful.throw(%2)::Union{}
└──      unreachable
) => Union{}

very impressive

implementation:

# Addition / subtraction
for op in [:+, :-]
    @eval ($op)(x::AbstractQuantity{S,D,U}, y::AbstractQuantity{T,D,U}) where {S,T,D,U} =
        Quantity(($op)(x.val, y.val), U())

    @eval function ($op)(x::AbstractQuantity{S,D,SU}, y::AbstractQuantity{T,D,TU}) where {S,T,D,SU,TU}
        ($op)(promote(x,y)...)
    end

    @eval ($op)(x::AbstractQuantity, y::AbstractQuantity) = throw(DimensionError(x,y))
    @eval ($op)(x::AbstractQuantity) = Quantity(($op)(x.val), unit(x))
end

[tfiers]

Problem with the "switch between fake and real units": global constants / typeds

[tfiers]

The monster:

@code_typed 3u"mV"/8u"s"
CodeInfo(
1 ─ %1 = Base.getfield(x, :val)::Int64
│   %2 = Base.getfield(y, :val)::Int64
│   %3 = Base.sitofp(Float64, %1)::Float64
│   %4 = Base.sitofp(Float64, %2)::Float64
│   %5 = Base.div_float(%3, %4)::Float64
│   %6 = %new(Quantity{Float64, 𝐋 ^2 𝐌  𝐈 ^-1 𝐓 ^-4, Unitful.FreeUnits{(s^-1, mV), 𝐋 ^2 𝐌  𝐈 ^-1 𝐓 ^-4, nothing}}, %5)::Quantity{Float64, 𝐋^2 𝐌 𝐈^-1 𝐓^-4, Unitful.FreeUnits{(s^-1, mV), 𝐋^2 𝐌 𝐈^-1 𝐓^-4, nothing}}
└──      return %6
) => Quantity{Float64, 𝐋 ^2 𝐌  𝐈 ^-1 𝐓 ^-4, Unitful.FreeUnits{(s^-1, mV), 𝐋 ^2 𝐌  𝐈 ^-1 𝐓 ^-4, nothing}}

Simplification of Unitful types, maybe:

Quantity{Float64, Unit{(mV, s^-1), L^2 M I^-1 T^-4}}
Quantity{Float64, Unit{(mV, s⁻¹), L² M I⁻¹ T⁻⁴}}
Quantity{Float64, Unit{(mV/s), M L² / (T⁴ I)}
Quantity{Float64, Unit{(mV /s), M L² /T⁴ /I)}
Quantity{Float64, Unit{mV/s, Voltage/Time}}
Quantity{Float64, Unit{V, T⁻¹}}
Val{Float64, Unit{V, T⁻¹}}

(ofc, yes, "try not to display types; display values instead". ofc in practice that's no go, starting with just having a Vector of those. grrr. (#julia annoyance))

[tfiers]

what's those thangs in type

julia> q = 3m / 8s
0.375 m s^-1

julia> u = unit(q)
m s^-1

julia> T = typeof(u)
Unitful.FreeUnits{(m, s^-1), 𝐋  𝐓 ^-1, nothing}

julia> T.parameters[1][2]
s^-1

julia> typeof(T.parameters[1][2])
Unitful.Unit{:Second, 𝐓 }

wat. where'd the -1 go.

julia> typeof(Unitful.s)
Unitful.FreeUnits{(s,), 𝐓 , nothing}

[tfiers]

ah:

julia> x=T.parameters[1][2];
s^-1

julia> dump(x)
Unitful.Unit{:Second, 𝐓 }
  tens: Int64 0
  power: Rational{Int64}
    num: Int64 -1
    den: Int64 1

julia> isbits(x)
true

[tfiers]

The above means that a s⁻¹ repr is for sure possible :)

[tfiers]

Problem with the "switch between fake and real units": global constants / typeds

Well, we'll just export two modules :) And then user just needs to switch the using stmt. (SpikeWorks.Units and SpikeWorks.FakeUnits, or sth)