Carry Forward Rounding - clickhouse

Question

I have set of arrays
[0.21, 0.21, 0.21, 0.21] as a,
[0.31, 0.31, 0.31, 0.31] as b,
[0.48, 0.48, 0.48, 0.48] as c
If you notice, a1+b1+c1 = 1 (where a1 is the first element of array a).
I want to implement a rounding wherein the answer is
[0, 0, 1, 0] for a
[0, 1, 0, 0] for b
[1, 0, 0, 1] for c
Step 1.
Do a round function for a1, b1, c1 -> this will give us a value of a1=0, b1=0 and c1=0 (resulting in a carryforward value of 0.21, 0.31 and 0.48 for next set of values i.e., a2, b2, and c2.
Step 2.
However since after Step 1, the round(a1) + round(b1) + round(c1) < a1+b1+c1, the idea is to roundup the element that got rounded down the maximum (so that we get the rounded sum equal to sum of unrounded values) and then carry forward the excess to decrement from the next value.
For e.g.
after the first allocation, c1 will get rounded up to 1 (getting an excess of 0.52 which we should decrement from c2 0.48-0.52=-0.04). Similarly, since a1 and b1 were 0 and 0 after rounding, we will carryforward 0.21 and 0.31 to a2, b2 giving us a2=0.21+0.21=0.42 and b2=0.31+0.31=0.62 and c2=0.48-0.52=-0.04
Step 3:
Repeat Step 1 for 2nd elements, which in this case will become round(a2) = round(0.42) =0, round(b2) = round(0.62)=1, round(c2)=round(-0.04) = 0.
Carryforwrd the difference, from a2 -> 0.42, from b2 -> -0.38, from c2 = -0.04 to next element
a3 will become 0.21 + 0.42 = 0.63, b3 will become =0.31-0.38 = -0.07, and c3 will become 0.48 - 0.04 = 0.44
After rounding the 3rd element, a3 round will become 1, b3 -> 0, c3 -> 0
... and so on so forth.
Is there any way we can do this using the all-powerful arrays?

Answer 1

It's not a well-suited task for ClickHouse, but you can utilize the fact that an array won't be splitted into two rows and use a custom function to process the array.
The idea is simple. First assemble three arrays into an array of array using groupArrayForEach. So
[0.21, 0.21, 0.21, 0.21] as a,
[0.31, 0.31, 0.31, 0.31] as b,
[0.48, 0.48, 0.48, 0.48] as c
becomes
[[0.21, 0.31, 0.48], [0.21, 0.31, 0.48], [0.21, 0.31, 0.48]]
Then create a arrayReduce like function that does Carry Forward Rounding. Take a look at how arrayReduce is implemented in https://github.com/yandex/ClickHouse/blob/master/dbms/src/Functions/arrayReduce.cpp#L169
In fact you don't need an aggregator, a simple loop should be enough.
It would be better if ClickHouse supports stateful lambdas. I'd expect something like this
select
arrayCum
(
arr, old_carry =>
with
arrayMap(x, y -> x + y, arr, old_carry) as arr,
arrayEnumerate(arr) as idx,
arrayReduce('max', arr) as m
arrayFirstIndex(e -> e = m, arr) as i,
arrayMap(j -> if(i = j, 1, 0), idx) as rounded,
arrayMap(x, y -> x - y, arr, rounded) as carry
--
rounded, carry
, arr, arrayMap(x -> 0, arr)
)
from
( select groupArrayForEach(a) arr from data )