A simple approach to translate a value from its original range to another range

[TempodiBasic]

Hi guys and gals

what do you think about the QB45 instuction PMAPhttp://www.qb64.org/wiki/PMAP? It is a useful function set to translate between physical screen cohordinates and WINDOW logical cohordinates...
but what do you think if it was possible to translate a value (cohordinate or scalar value) from a range to another with a simple function?
Here I post a simple approach to this issue comparing two methods...
Proportion vs Normalization

Code: QB64: [Select]

1. DIM iValue AS INTEGER, iMin AS INTEGER, iMax AS INTEGER
2. DIM iNewMin AS INTEGER, iNewMax AS INTEGER
3. DIM dNewValue AS DOUBLE, dNewValue2 AS DOUBLE
4.  
5.  
6. iMin = 1
7. iMax = 10
8. iNewMin = 10
9. iNewMax = 100
10. PRINT " StartValue    Proportion    Translation"
11. FOR i = 2 TO 7 STEP 1
12.     iValue = i
13.     dNewValue = Proportion#
14.     dNewValue2 = Normalize#
15.     PRINT iValue, dNewValue, dNewValue2
16. NEXT i
17.  
18.  
19.  
20. END ' local end of the program
21.  
22. FUNCTION Proportion#
23.     DIM Delta1 AS INTEGER, Delta2 AS INTEGER
24.     SHARED iValue AS INTEGER, iMin AS INTEGER, iMax AS INTEGER
25.     SHARED iNewMin AS INTEGER, iNewMax AS INTEGER
26.     ' Delta1:Delta2 = iValue : iValue2
27.     ' iValue2 = (Delta2 * ivalue) /Delta1
28.     Delta1 = iMax - iMin
29.     Delta2 = iNewMax - iNewMin
30.     Proportion# = (iValue * Delta2) / Delta1
31. END FUNCTION
32.  
33. FUNCTION Normalize#
34.     SHARED iValue AS INTEGER, iMin AS INTEGER, iMax AS INTEGER
35.     SHARED iNewMin AS INTEGER, iNewMax AS INTEGER
36.  
37.     'valore normalizzato =  minimoscala+
38.     '((osservazione-MIN(intervallo))/
39.     '(MAX(intervallo)-MIN(intervallo))*
40.     '(massimoscala-minimoscala)
41.  
42.     Normalize# = iNewMin + ((iValue - iMin) / (iMax - iMin) * (iNewMax - iNewMin))
43. END FUNCTION
44.  

what method do you prefer?
Thanks to read

[Richard Frost]

Variables prefixed with an "i" are reserved for Apple products.

My translation method uses a hammer.  Yours is far better, since
it works to expand too.  Your 2nd SUB (Normalize#) is best, because
it's only one line.  Both your methods should test for zero, as
dividing by it makes a CPU very grumpy.

[bplus]

@TempodiBasic

I thought Fellippe's map function covered things quite well.

reminder:

Code: QB64: [Select]

1. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
2.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
3. END FUNCTION
4.  

Using WINDOW automatically does most of this.

[TempodiBasic]

@bplus
I'm glad you know the map! function of pj library. 
you're right about all except that
   1. the map! function has been translated into QB64 by  Fellippe & Ashish
   2. it releases a single value
   3. my normalize# function has the same radix but it releases a double value
in this post my goal was to evaluate 2 mathematical methods... the Proportion vs the Normalization formulas...
I have used the double type of data to see if there was a significant difference between the two formulas because from my hobbyst point of view I don't know if the difference in calculations is significant or not...

Code: QB64: [Select]

1. DIM iValue AS SINGLE, iMin AS SINGLE, iMax AS SINGLE
2. DIM iNewMin AS SINGLE, iNewMax AS SINGLE
3. DIM dNewValue AS DOUBLE, dNewValue2 AS DOUBLE
4.  
5.  
6. iMin = 1
7. iMax = 10
8. iNewMin = 10
9. iNewMax = 100
10. PRINT " StartValue    Proportion    Translation"
11. FOR i = 2 TO 7 STEP .7
12.     iValue = i
13.     dNewValue = Proportion#
14.     dNewValue2 = Normalize#
15.     PRINT iValue, dNewValue, dNewValue2
16. NEXT i
17.  
18.  
19.  
20. END ' local end of the program
21.  
22. FUNCTION Proportion#
23.     DIM Delta1, Delta2
24.     SHARED iValue, iMin, iMax
25.     SHARED iNewMin, iNewMax
26.     ' Delta1:Delta2 = iValue : iValue2
27.     ' iValue2 = (Delta2 * ivalue) /Delta1
28.     Delta1 = iMax - iMin
29.     Delta2 = iNewMax - iNewMin
30.     Proportion# = (iValue * Delta2) / Delta1
31. END FUNCTION
32.  

If you change the STEP of FOR to 0.6 or 0.8 you get more different values
Thanks for feedback I love to know your opinion on this last issue (proportion vs normalization)

[bplus]

Hi TempodiBasic,

Looks like Fellippe's is the only one that is working correctly, yours don't seem capable of negative scales and are knocked out when divided by 0 as mentioned by Mr Frost:

Code: QB64: [Select]

1. DIM iValue AS SINGLE, iMin AS SINGLE, iMax AS SINGLE
2. DIM iNewMin AS SINGLE, iNewMax AS SINGLE
3. DIM dNewValue AS DOUBLE, dNewValue2 AS DOUBLE
4.  
5.  
6. iMin = 0
7. iMax = 10
8. iNewMin = -100
9. iNewMax = 0
10. PRINT " StartValue    Proportion    Translation"
11. FOR i = 2 TO 7 STEP .7
12.     iValue = i
13.     dNewValue = Proportion#
14.     dNewValue2 = Normalize#
15.     PRINT iValue, dNewValue, dNewValue2, map!(iValue, iMin, iMax, iNewMin, iNewMax)
16. NEXT i
17.  
18. END ' local end of the program
19.  
20. FUNCTION Proportion#
21.     DIM Delta1, Delta2
22.     SHARED iValue, iMin, iMax
23.     SHARED iNewMin, iNewMax
24.     ' Delta1:Delta2 = iValue : iValue2
25.     ' iValue2 = (Delta2 * ivalue) /Delta1
26.     Delta1 = iMax - iMin
27.     Delta2 = iNewMax - iNewMin
28.     Proportion# = (iValue * Delta2) / Delta1
29. END FUNCTION
30.  
31. FUNCTION Normalize#
32.     SHARED iValue AS INTEGER, iMin AS INTEGER, iMax AS INTEGER
33.     SHARED iNewMin AS INTEGER, iNewMax AS INTEGER
34.  
35.     'valore normalizzato =  minimoscala+
36.     '((osservazione-MIN(intervallo))/
37.     '(MAX(intervallo)-MIN(intervallo))*
38.     '(massimoscala-minimoscala)
39.  
40.     Normalize# = iNewMin + ((iValue - iMin) / (iMax - iMin) * (iNewMax - iNewMin))
41. END FUNCTION
42.  
43.  
44. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
45.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
46. END FUNCTION
47.  

[TempodiBasic]

@Richard Frost
I'm sorry to make this mistake about "i" prefix!
I'll correct the typemismatch as soon as I can!

I agree totally about the issue of division by zero, but in this case the range is not a range because imin == imax  && inewmin == inewmax
if only one of the extreme points of the range is 0 it's not matter

Here the Proportion# function in one line

Code: QB64: [Select]

1. DIM iValue AS SINGLE, iMin AS SINGLE, iMax AS SINGLE
2. DIM iNewMin AS SINGLE, iNewMax AS SINGLE
3. DIM dNewValue AS DOUBLE, dNewValue2 AS DOUBLE
4.  
5.  
6. iMin = 1
7. iMax = 10
8. iNewMin = 10
9. iNewMax = 100
10. PRINT " StartValue    Proportion    Translation"
11. FOR i = 2 TO 7 STEP .6
12.     iValue = i
13.     dNewValue = Proportion#
14.     dNewValue2 = Normalize#
15.     PRINT iValue, dNewValue, dNewValue2
16. NEXT i
17.  
18.  
19.  
20. END ' local end of the program
21.  
22. FUNCTION Proportion#
23.     '    DIM Delta1, Delta2
24.     SHARED iValue, iMin, iMax
25.     SHARED iNewMin, iNewMax
26.     ' Delta1:Delta2 = iValue : iValue2
27.     ' iValue2 = (Delta2 * ivalue) /Delta1
28.     '   Delta1 = iMax - iMin
29.     '  Delta2 = iNewMax - iNewMin
30.     Proportion# = (iValue * (iNewMax - iNewMin)) / (iMax - iMin)
31. END FUNCTION
32.  
33. FUNCTION Normalize#
34.     SHARED iValue, iMin, iMax
35.     SHARED iNewMin, iNewMax
36.  
37.     'valore normalizzato =  minimoscala+
38.     '((osservazione-MIN(intervallo))/
39.     '(MAX(intervallo)-MIN(intervallo))*
40.     '(massimoscala-minimoscala)
41.  
42.     Normalize# = iNewMin + ((iValue - iMin) / (iMax - iMin) * (iNewMax - iNewMin))
43. END FUNCTION
44.  

About your opinion how is significative the difference of results of the two function?

[TempodiBasic]

Hi Bplus
glad to get your feedback

the code posted by you for comparison among proportion#, Normalization# and the superlative PMAP! gives to me this result

 

I cannot see the difference for now. However my goal is not to post a duplicate  (better or worse than) PMAP! of Fellippe, but to evaluate if the difference got with the 2 methods is significant or not for ordinary calculation, because I think that it is important for calculation of NASA. As you can remember the proportion method has been used by Talete from Mileto to calculate the radium of the earth using the pyramid of Aegipt and a pole.  On the other hand Normalization is a statistical method.
Thaks to talk about this.

[bplus]

Here's what I got from code I posted, I copy pasted into QB64 IDE from forum looks OK to me:
 

Running in Windows 10-64 laptop QB64 v 1.4 stable

(better or worse than) PMAP! of Fellippe,

PS not using PMAP, using Fellippe's map! function.

because I think that it is important for calculation of NASA.

:-)) I am thinking if NASA used your code they might be firing rockets into the center of the earth!

[TempodiBasic]

@bplus
yes you're right PMAP is a QB45 keyword, that of Fellippe & Ashish is map!, but I have it in so much consideration that I have made a Freudian's lapsus.

so you're thinking that the earth is hollow... mmmh but in this case it is simpler to reach the center of the earth by pole's hole,is it? :))  Nevertheless I can pass my code to the NASA if you think that this is useful.

about my  C++ compiling error, in the following attemps I got your results.... QB64 1.5 dev in Windows 8 Pro 64bits.

My curiosity is about the result of Normalization#... nan? Is it an alien number that comes out?
However thanks Bplus you let see nearer my code so I see now that I have translate bad this template formula

Code: QB64: [Select]

1.     'valore normalizzato =  minimoscala+
2.     '((osservazione-MIN(intervallo))/
3.     '(MAX(intervallo)-MIN(intervallo))*
4.     '(massimoscala-minimoscala)

with this code

Code: QB64: [Select]

1.     Normalize# = iNewMin + ((iValue - iMin) / (iMax - iMin) * (iNewMax - iNewMin))

as you can see the last rounded parenthesis must be put  after (imax-iMin) and before * (iNewMax-iNewMin)!
a typo error!

about proportion# it has been build only for positive numbers...
but if we want adapt it to all combinations (like your example where it manages negative numbers) we must use the ABSolute value of the variable passed to it and adding at the end the iNewMin because the counting of numbers starts from there.
So here the code!

Code: QB64: [Select]

1. DIM iValue AS SINGLE, iMin AS SINGLE, iMax AS SINGLE
2. DIM iNewMin AS SINGLE, iNewMax AS SINGLE
3. DIM dNewValue AS DOUBLE, dNewValue2 AS DOUBLE
4.  
5.  
6. iMin = 0
7. iMax = 10
8. iNewMin = -100
9. iNewMax = 0
10. PRINT " StartValue    Proportion    Translation"
11. FOR i = 2 TO 7 STEP .6
12.     iValue = i
13.     dNewValue = Proportion#
14.     dNewValue2 = Normalize#
15.     PRINT iValue; " "; dNewValue; " "; dNewValue2; " "; map!(iValue, iMin, iMax, iNewMin, iNewMax)
16. NEXT i
17.  
18. END ' local end of the program
19.  
20. FUNCTION Proportion#
21.     SHARED iValue, iMin, iMax
22.     SHARED iNewMin, iNewMax
23.     ' Delta1:Delta2 = iValue : iValue2
24.     ' iValue2 = (Delta2 * ivalue) /Delta1
25.     ' Delta1 = Absolute( iMax - iMin)
26.     'Delta2 = Absolute(iNewMax - iNewMin)
27.     Proportion# = (iValue * ABS(iNewMax - iNewMin)) / ABS(iMax - iMin) + iNewMin
28. END FUNCTION
29.  
30. FUNCTION Normalize#
31.     SHARED iValue, iMin, iMax
32.     SHARED iNewMin, iNewMax
33.  
34.     'valore normalizzato =  minimoscala+
35.     '((osservazione-MIN(intervallo))/
36.     '(MAX(intervallo)-MIN(intervallo))*
37.     '(massimoscala-minimoscala)
38.  
39.     Normalize# = iNewMin + ((iValue - iMin) / (iMax - iMin)) * (iNewMax - iNewMin)
40. END FUNCTION
41.  
42.  
43. FUNCTION map! (value!, minRange!, maxRange!, newMinRange!, newMaxRange!)
44.     map! = ((value! - minRange!) / (maxRange! - minRange!)) * (newMaxRange! - newMinRange!) + newMinRange!
45. END FUNCTION
46.  

in this you can see that the differences between Normalize# and map! are apparents and not real, the only that stands still on is that normalize gives a double type back while map gives a single type back.

Now that you have helped me to correct my first code... do you want say me your opinion about Proportion method vs Normalize method?

[bplus]

Now that you have helped me to correct my first code... do you want say me your opinion about Proportion method vs Normalize method?

Hi TempodiBasic,

I rewrote each equation using like terms and applied Algebra
(ABS was not needed I am pretty sure in proportion.)

They worked out to this

Code: QB64: [Select]

1. Proportion# = (NewMax - NewMin) * (Value - 0) / (Max - Min) + NewMin
2.  
3. Normalize# = (NewMax - NewMin) * (Value - Min) / (Max - Min) + NewMin
4.  
5. map! = (NewMax - NewMin) * (Value - Min) / (Max - Min) + NewMin
6.  
7.  
8.  
9. I would start like this:
10.  
11. something is to a min of a total range as something else is to another min of another different total range
12.  
13. (Value - Min) / (Max - Min) = (X - newMin) / (newMax - newMin)  solve for x
14.  
15. (newMax - newMin) * (Value - Min) / (Max - Min)  = X - newMin
16.  
17. (newMax - newMin) * (Value - Min) / (Max - Min) + newMin = X   or
18.  
19. X = (newMax - newMin) * (Value - Min) / (Max - Min) + newMin
20.  
21. QED
22.  

Normalize is identical to map and proportion only works if Min = 0

So between Proportion and Normalize, NASA engineers prefer Normalize 99.99 %  ;-))


But hey!  What if all Mins are 0 which is very likely case with lengths of things then our formula simplifies to

X = newMax * Value / Max 
or
X is to NewMax AS Value is to Max

which is what Proportional means to me.