Avoid exponential growth when scaling tl;dr;
If I have to add a scale to a value which I expect to be X but is instead Y and the result, Z, is the most important part then how do I recalculate the scale to give result Z for Y instead of X?
Full problem
I need to scale a geometrical object when I develop a program and I don't have control of the actual scaling, just calculating the new scale. My problem is that when I send in the new scale it's always applied to the current state of the object and not its base.
So basically, if the width of the object is 100 and I grow it 1% unit for every iteration I want:
Step1: 100*1.01=101
Step2: 100*1.02=102
Step3: 100*1.03=103
etc...

But what I get is:
Step1: 100*1.01=101
Step2: 101*1.02=103.02
Step3: 103.02*1.03=106.1106
etc...

So my initial thought was that, since I control the scale value I could perhaps re-calculate the next scale based on the discrepancy between the expected and the actual value, i.e.:
Expected (step 2): 100*.1.02=102
Actual (step 2): 101*.1.02=103.02
Possible solution (step 2): Recalculating the scale (1.02) to give the result 102 if applied to 103.02

I will have to add my scale to 101 instead of 100 since I don't control that part, but perhaps I could, instead of sending in 1.02 in the second step send in the equivalent of 1.02 that gives me the expected outcome (102). My math skills, however, don't really help me here but the variables are
BaseValue (The value on to which the scale is applied. This value will always have the scale applied to it after every iteration)
Scale (The new scale in ever iteration. I will know how much I want to scale, such as 1.02 in the second iteration, but the outcome is the most important part, in this case 102, so if 1.02 have to be say 1.0068 to get the result that's ok and it's probably what I'm looking for here)
Result (The outcome after scaling is applied. In the second iteration I expect the result to be 102 after applying a 1.02 Scaling to a BaseValue of 100 but I am in fact adding 1.02 to the previous result)
 A: You could keep track of the scales you have applied in the past. I will use your example as an illustration. 
At time step t we would like to scale the object by a factor 1 + 0.01 * t. We will use the variable c to keep track of the current scale of the object. At the beginning, the current scale is of course c=1. As we apply transformations, we will keep track of the current state of the object. Here's some (pseudo-)code which you can run in python.
# Initialise variables
c = 1
num_steps = 10
# Iterate over the time steps
for t in range(num_steps):
    # Evaluate the desired scale
    desired_scale = 1 + 0.01 * t
    # Evaluate the factor to pass to your other program
    factor = desired_scale / c
    # Update the state of the object
    c *= factor
    # Report values
    print "State: {}; Factor: {}".format(c, factor)

The output will look like
State: 1.0; Factor: 1.0
State: 1.01; Factor: 1.01
State: 1.02; Factor: 1.0099009901
State: 1.03; Factor: 1.00980392157
State: 1.04; Factor: 1.00970873786
State: 1.05; Factor: 1.00961538462
State: 1.06; Factor: 1.00952380952
State: 1.07; Factor: 1.00943396226
State: 1.08; Factor: 1.00934579439
State: 1.09; Factor: 1.00925925926

As you can see, the factor that is applied is very close to 1.01 at every step but diminishes slightly because we are accounting for the transformations we have already applied.
