Copying a variable with only arithmetic operators - variables

Question

What is the best way to copy the value of one variable to another without a direct assignment function?
Variables are 2 byte fixed point numbers with a max value of 2147483.647. The available operators are (reformatted for clarity):
add(<variable>, <constant>) which adds a constant value to the given variable
subtract(<variable>, <constant>) which subtracts
multiply(<variable>, <constant>) which multiplies
divide(<variable>, <constant>) which divides
check(<variable1>, <op>, <variable2/constant>) which compares the value of variable1 with that of <variable2/constant> using the operator op and returns a boolean. op can be =, <, <=, >= or >
set(<variable>, <constant>) which sets the value of the variable.
The scripting language has basic control flow, it has while and if (but not else) as well as basic boolean operators AND, OR, NOT and NOR.
Our first attempt was simply:
while = {
count = var1 //loop var1 times
change_variable = { which = var2 value = 1 } //increment by one
}
My next attempt was:
set_variable = { which = new value = 1 }
while = {
limit = { NOT = { check_variable = { which = old value = new} } }
if = {
limit = {
check_variable = { which = old value > new }
check_variable = { which = stage value = 0 }
}
multiply_variable = { which = new value = 10 }
}
if = {
limit = {
check_variable = { which = stage value = 0 }
check_variable = { which = old value < new }
}
set_variable = { which = stage value = 1 }
}
if = {
limit = {
check_variable = { which = stage value = 1 }
check_variable = { which = old value < new }
}
subtract_variable = { which = new value = 1 }
}
}
E.g., start with 1, multiply by 10 until greater than the target, then subtract 1 until at the target.
But I'm sure there's a much better way to do this.
Context:
A recent patch of the scripting language used in the game "Stellaris" has broken the variable assignment function. set above should be set(<variable>, <variable/constant>). This has broken a lot of existing code, and it's unknown how long it will remain broken.

Answer 1

because 2147483.647 is a (power of 2 - 1) /1000 I can use the successive powers of 2 to approach the solution 1 bit at a time: (written in C using only equivalent operations)
result = 0;
result += 1073741.824;
if( var < result )
result -= 1073741.824;
result += 536870.912;
if( var < result)
result -= 536870.912;
result += 268435.456;
if( var < result)
result -= 268435.456;
result += 134217.728;
if( var < result)
result -= 134217.728;
result += 67108.864;
if( var < result)
result -= 67108.864;
result += 33554.432;
if( var < result)
result -= 33554.432;
result += 16777.216;
if( var < result)
result -= 16777.216;
result += 8388.608;
if( var < result)
result -= 8388.608;
result += 4194.304;
if( var < result)
result -= 4194.304;
result += 2097.152;
if( var < result)
result -= 2097.152;
result += 1048.576;
if( var < result)
result -= 1048.576;
result += 524.288;
if( var < result)
result -= 524.288;
result += 262.144;
if( var < result)
result -= 262.144;
result += 131.072;
if( var < result)
result -= 131.072;
result += 65.536;
if( var < result)
result -= 65.536;
result += 32.768;
if( var < result)
result -= 32.768;
result += 16.384;
if( var < result)
result -= 16.384;
result += 8.192;
if( var < result)
result -= 8.192;
result += 4.096;
if( var < result)
result -= 4.096;
result += 2.048;
if( var < result)
result -= 2.048;
result += 1.024;
if( var < result)
result -= 1.024;
result += 0.512;
if( var < result)
result -= 0.512;
result += 0.256;
if( var < result)
result -= 0.256;
result += 0.128;
if( var < result)
result -= 0.128
result += 0.064;
if( var < result)
result -= 0.064;
result += 0.032;
if( var < result)
result -= 0.032;
result += 0.016;
if( var < result)
result -= 0.016;
result += 0.008;
if( var < result)
result -= 0.008;
result += 0.004;
if( var < result)
result -= 0.004;
result += 0.002;
if( var < result)
result -= 0.002;
result += 0.001;
if( var < result)
result -= 0.001;
only 32 comparisons needed (less if you can live with less precision or know the upper bound).