I have a min and max position of an object and I want to represent an arbitrary point between them as a float between 0.0 and 1.0. This feels relatively basic math, but I can’t quite figure out what I need to do with this. Is there a special name for this sort of thing? Also, are there any built-in methods that would be useful for this?

    • @MossBearOP
      link
      21 year ago

      I think that may work! Thanks!

  • @amtwon
    link
    English
    31 year ago

    I think /u/breadsmasher has your answer, but FWIW, mapping from an arbitrary range onto the range of 0.0 to 1.0 is called normalization

    Not sure if there’s a name for the opposite operation

  • @TropicalDingdong
    link
    2
    edit-2
    1 year ago

    Well there is normalization , regularization, and standardization, but it basically depends on what you want to do and what implications that has for your data.

    X is the set and x is a value in that set.

    So:

    1 - { [ max(X) - x ] / [ max(X)- min(X) ] }

    or alternatively,

    [x- min(X)] / [max(X)-min(X)]

    Should do what you are asking, which sounds like normalization. That will normalize your values between 0 and 1. However, it wont do anything about your data being skewed to one side or the other. So the mean of this value won’t be 0.5, the halfway point between 0 and 1.

    If you want something like that, you will need to standardize your data prior to running the above algorithm:

    Something like:

    [ x - mean(X) ] / std(X)

    This will center your data around 0. If you then apply the first function (normalization), it should now be centered around 0.5 (even if it is not normally distributed).

    • @[email protected]
      link
      fedilink
      21 year ago

      OP might also be interested in the reverse operation. If s is your number from 0 to 1, the corresponding position in the “real” space is min + s * (max-min), which can also be written as (1-s)min + smax . This is sometimes called a linear interpolation, or a weighted average. Note that you can also use the same formulas with s smaller than zero and larger than one, thus performing linear extrapolation. Finally, these same formulas apply in higher dimensions, just think of min and max as the coordinates of two vectors, and appy these formulas for each coordinate, and you get linear interpolation between your two vectors.

  • @[email protected]
    link
    fedilink
    11 year ago

    Related, note that division is much slower than multiplication.

    Instead of:

    n / d
    

    see if you can refactor it to:

    n * (1.0/d)
    

    where that inverse can then be hoisted out of loops.

    • @shotgun_crab
      link
      English
      3
      edit-2
      1 year ago

      Just to clarify, the value in parentheses must be precalculated.

      For example, instead of:

      n / 2
      

      Do:

      n * 0.5
      
    • Murderturd
      link
      21 year ago

      If multiplication vs division is causing perf issues you fucked up somewhere or shouldn’t be asking on Lemmy for help because your performance critical system is of the safety and health type.

      I’ve never had division actually be a real issue.