Efficient unit conversion in array

[DylanMMarques]

Hello, thanks for this package. I just started using it and it is helping me a lot in my work.

I looked into the documentation looking for a function that allow me to convert an Array described in Hz into the same Array but in described in MHz.
The way that I found would be:

using Unitful
a = rand(10) * 1u"Hz"
@time b = uconvert.(u"MHz", a)
#0.000018 seconds (4 allocations: 8.008 KiB)

However, this creates a new array and therefore allocates memory which I would like to avoid. I was wondering if there is a uconvert!(unit, a) available, that allows in place conversion of the array. This should be easy to do and may be already implemented. Something like:

a = rand(10) * 1u"Hz"
uconvert_Hz_to_MHz!(a) =  b = ustrip(a); b  .*= 1E-6;
@time b = uconvert_Hz_to_MHz!(a) 
# 0.000007 seconds (1 allocation: 32 bytes)

Is there already a function implemented that does this? If not, would it be possible to implement?

[giordano]

You can't possibly modify in-place the unit of the elements of a vector, as the unit is part of the type:

julia> using Unitful

julia> a = rand(10) * 1u"Hz"
10-element Vector{Quantity{Float64, 𝐓^-1, Unitful.FreeUnits{(Hz,), 𝐓^-1, nothing}}}:
 0.08201771338298702 Hz
 0.03238985967176833 Hz
   0.577826574830663 Hz
  0.2344653139102032 Hz
  0.3416999750152707 Hz
  0.9284780051619349 Hz
 0.21584367185417408 Hz
  0.5158698223276047 Hz
  0.4052601715620976 Hz
  0.9800312628378945 Hz

Note that Hz is a parameter of the eltype of the vector.

[DylanMMarques]

Thanks for your answer. You are right about this, as in my example I didn't change the type. But I still think that what I am asking could be done. If I understand correctly, an Array{Quantity{T, "Hz"}} is pointing at an Array{T} but has a different type assigned to it. Thus, it should be possible to transform the array of floats (as in the function uconvert_Hz_to_MHz!) and then creating an Array{Quantity{T,"MHz"} pointing to the Array{T}.

[giordano]

No: that very operation means creating a brand new array. You can't possibly change the type of a container.

[giordano]

The only thing you could do is to divide the vector in-place by 10^6 and then reinterpret a as MHz:

julia> a = rand(10) * 1u"Hz"
10-element Vector{Quantity{Float64, 𝐓^-1, Unitful.FreeUnits{(Hz,), 𝐓^-1, nothing}}}:
  0.6800885074641225 Hz
  0.4868498888573509 Hz
  0.7025637522986492 Hz
 0.35945297982633695 Hz
   0.549268517952012 Hz
  0.4236315407579766 Hz
 0.41568410062314953 Hz
 0.03019889291716671 Hz
  0.6927337193185646 Hz
 0.24453642116505514 Hz

julia> a ./= 10^6
10-element Vector{Quantity{Float64, 𝐓^-1, Unitful.FreeUnits{(Hz,), 𝐓^-1, nothing}}}:
  6.800885074641226e-7 Hz
  4.868498888573509e-7 Hz
  7.025637522986492e-7 Hz
 3.5945297982633693e-7 Hz
   5.49268517952012e-7 Hz
  4.236315407579766e-7 Hz
  4.156841006231495e-7 Hz
  3.019889291716671e-8 Hz
  6.927337193185646e-7 Hz
 2.4453642116505515e-7 Hz

julia> reinterpret(typeof(1.0u"MHz"), a)
10-element reinterpret(Quantity{Float64, 𝐓^-1, Unitful.FreeUnits{(MHz,), 𝐓^-1, nothing}}, ::Vector{Quantity{Float64, 𝐓^-1, Unitful.FreeUnits{(Hz,), 𝐓^-1, nothing}}}):
  6.800885074641226e-7 MHz
  4.868498888573509e-7 MHz
  7.025637522986492e-7 MHz
 3.5945297982633693e-7 MHz
   5.49268517952012e-7 MHz
  4.236315407579766e-7 MHz
  4.156841006231495e-7 MHz
  3.019889291716671e-8 MHz
  6.927337193185646e-7 MHz
 2.4453642116505515e-7 MHz

But this is a stupid hack: with reintepret you're only temporarily "viewing" a as if it had a different unit, but a is still actually:

julia> a
10-element Vector{Quantity{Float64, 𝐓^-1, Unitful.FreeUnits{(Hz,), 𝐓^-1, nothing}}}:
  6.800885074641226e-7 Hz
  4.868498888573509e-7 Hz
  7.025637522986492e-7 Hz
 3.5945297982633693e-7 Hz
   5.49268517952012e-7 Hz
  4.236315407579766e-7 Hz
  4.156841006231495e-7 Hz
  3.019889291716671e-8 Hz
  6.927337193185646e-7 Hz
 2.4453642116505515e-7 Hz

which is likely the last thing you want. Again, with the way Unitful currently works (embedding the unit in the type) you have no choice but allocating a new array.

[giordano]

Another option is to use a container which doesn't embed the unit in the eltype:

julia> a = Quantity[rand() * u"Hz" for _ in 1:10]
10-element Vector{Quantity}:
  0.2753426045191617 Hz
 0.19636185727463118 Hz
  0.8123286922381421 Hz
  0.1593041765563631 Hz
  0.8734434630999457 Hz
  0.6055030587600458 Hz
  0.9708728315770758 Hz
  0.3536930156850906 Hz
  0.5420351761261153 Hz
  0.3346952306511479 Hz

julia> a .= a .|> u"MHz"
10-element Vector{Quantity}:
  2.753426045191617e-7 MHz
 1.9636185727463117e-7 MHz
  8.123286922381421e-7 MHz
 1.5930417655636307e-7 MHz
  8.734434630999456e-7 MHz
  6.055030587600458e-7 MHz
  9.708728315770758e-7 MHz
  3.536930156850906e-7 MHz
  5.420351761261152e-7 MHz
  3.346952306511479e-7 MHz

But this can lead to type-instabilities and memory allocations elsewhere. You're just shifting the problem.

[DylanMMarques]

Thanks for you help. This makes sense! What I was suggesting was something like your second reply.

Thanks again!