4

I've been trying to find a Javascript version of a handy method I'd used (not written) a while ago in LPC, it was called dimval(), and it took this form:

NAME
     dimval() - returns values with a reduced increase in output
                as input values grow larger.

SYNOPSIS
     float dimval(float input, float max_input, float max_output,
                  float min_input, float min_output, float rate);

DESCRIPTION
     Returns (as a float) a value between min_output and max_output,
     with values increasing at a reduced rate as they move from
     min_input toward max_output.

     Input is the input value.

     Max_input is the maximum acceptable input. Any higher input
     value will be capped to this.

     Max_output is the maximum value returned.

     Min_input is the (optional) minimum input. Default is zero.

     Min_output is the (optional) minimum output. Default is zero.

     Rate determines how quickly the cost increases to achieve
     greater return values. Higher numbers are faster, lower numbers
     are slower.

I read this article, but it doesn't seem to capture what I want (it looks much simpler for a start). I also read this SO question and... well I think this could work... but the Math is beyond me, to be honest. I understand the description above and how the parameters work together to produce the kind of result I want.

I'd greatly appreciate it if someone could provide a method which has the above constraints, in Javascript.

cheers!

EDIT: Sample outputs from original method.

  • eval return dimval(5.0, 100.0, 100.0, 0.0, 0.0, 1.0) => 22.360680
  • eval return dimval(10.0, 100.0, 100.0, 0.0, 0.0, 1.0) => 31.622776

  • eval return dimval(50.0, 100.0, 100.0, 0.0, 0.0, 1.0) => 70.710678

  • eval return dimval(10.0, 100.0, 100.0, 0.0, 0.0, 2.0) => 15.811388

  • eval return dimval(10.0, 100.0, 100.0, 0.0, 0.0, 10.0) => 3.162278

  • eval return dimval(200.0, 100.0, 100.0, 0.0, 0.0, 10.0) => 10.000000

  • eval return dimval(200.0, 100.0, 100.0, 0.0, 0.0, 1.0) => 100.000000

  • eval return dimval(1.0, 100.0, 100.0, 10.0, 0.0, 10.0) => 0.000000

Let me know if you want me to run any more samples.

Community
  • 1
  • 1
danjah
  • 2,939
  • 2
  • 30
  • 47
  • You know, I'm not even sure if the title of this question is quite accurate, I'm basing it on the name of the method I once used, and the research done so far. Please correct it if it's wrong. – danjah Apr 10 '12 at 12:05
  • "they move from min_input toward max_output" is that really right? Not from `min_input` towards `max_input`? – thejh Apr 10 '12 at 12:13
  • I'll do an edit in a sec with some sample values, I can actually still run the old LPC method, but don't have the code. – danjah Apr 10 '12 at 12:18

3 Answers3

2

Maybe something like this?

function dimval(n, min_in, max_in, min_out, max_out, exponent) {
  // unscale input
  n -= min_in
  n /= max_in - min_in

  n = Math.pow(n, exponent)

  // scale output
  n *= max_out - min_out
  n += min_out
  return n
}

0 < exponent < 1 for fast increase first, then smaller increase, exponent > 1 for the reverse.

Example:

> dimval(0, 0, 1, 0, 100, 2)
0
> dimval(0.1, 0, 1, 0, 100, 2)
1.0000000000000002
> dimval(0.2, 0, 1, 0, 100, 2)
4.000000000000001


> dimval(0, 0, 1, 0, 100, 0.5)
0
> dimval(0.1, 0, 1, 0, 100, 0.5)
31.622776601683793
> dimval(0.2, 0, 1, 0, 100, 0.5)
44.721359549995796
> dimval(0.3, 0, 1, 0, 100, 0.5)
54.77225575051661
> dimval(0.4, 0, 1, 0, 100, 0.5)
63.245553203367585
> dimval(0.5, 0, 1, 0, 100, 0.5)
70.71067811865476
> dimval(0.6, 0, 1, 0, 100, 0.5)
77.45966692414834
> dimval(0.7, 0, 1, 0, 100, 0.5)
83.66600265340756
> dimval(0.8, 0, 1, 0, 100, 0.5)
89.44271909999159
> dimval(0.9, 0, 1, 0, 100, 0.5)
94.86832980505137
> dimval(1, 0, 1, 0, 100, 0.5)
100
thejh
  • 44,854
  • 16
  • 96
  • 107
  • I'm getting a return value = to whatever min_out and/or min_in is, with that currently, sample used: Math.dimval(69, 1, 100, 1, 1, 10). – danjah Apr 10 '12 at 12:29
  • Hmm, ok, with some further trial am I using this correctly? "Math.dimval(1.5, 0, 1, 0, 1, 1)" so input is greater than the provided 'max_in' param, and the return value is 1.5? – danjah Apr 10 '12 at 12:43
  • @Danjah: Well, yes, I assumed you'd only use inputs in the allowed input range. Feel free to add some code to catch invalid input. – thejh Apr 10 '12 at 12:44
1

Function:

function dimval( input, max_in, max_out, min_in, min_out, rate) {
    if (rate < 0.000001) {rate = 0.000001}
    if (input > max_in) {input = max_in}
    if (input < min_in) {input = min_in}
    mult = (max_out - min_out);

    input = (input - min_in) / (max_in - min_in);
    input = Math.sqrt(input) / rate;
    input = (input * mult) + min_out;
    if (input > max_out) {input = max_out}
    return input;
}

Test:

dim1 = 'dimval(5.0, 100.0, 100.0, 0.0, 0.0, 1.0)';
dim2 = 'dimval(10.0, 100.0, 100.0, 0.0, 0.0, 1.0)';
dim3 = 'dimval(50.0, 100.0, 100.0, 0.0, 0.0, 1.0)';
dim4 = 'dimval(10.0, 100.0, 100.0, 0.0, 0.0, 2.0)';
dim5 = 'dimval(10.0, 100.0, 100.0, 0.0, 0.0, 10.0)';
dim6 = 'dimval(200.0, 100.0, 100.0, 0.0, 0.0, 10.0)';
dim7 = 'dimval(200.0, 100.0, 100.0, 0.0, 0.0, 1.0)';
dim8 = 'dimval(1.0, 100.0, 100.0, 10.0, 0.0, 10.0)';


console.log(dim1 + ' => ' + eval(dim1).toFixed(6));
console.log(dim2 + ' => ' + eval(dim2).toFixed(6));
console.log(dim3 + ' => ' + eval(dim3).toFixed(6));
console.log(dim4 + ' => ' + eval(dim4).toFixed(6));
console.log(dim5 + ' => ' + eval(dim5).toFixed(6));
console.log(dim6 + ' => ' + eval(dim6).toFixed(6));
console.log(dim7 + ' => ' + eval(dim7).toFixed(6));
console.log(dim8 + ' => ' + eval(dim8).toFixed(6));

Results:

dimval(5.0, 100.0, 100.0, 0.0, 0.0, 1.0) => 22.360680
dimval(10.0, 100.0, 100.0, 0.0, 0.0, 1.0) => 31.622777
dimval(50.0, 100.0, 100.0, 0.0, 0.0, 1.0) => 70.710678
dimval(10.0, 100.0, 100.0, 0.0, 0.0, 2.0) => 15.811388
dimval(10.0, 100.0, 100.0, 0.0, 0.0, 10.0) => 3.162278
dimval(200.0, 100.0, 100.0, 0.0, 0.0, 10.0) => 10.000000
dimval(200.0, 100.0, 100.0, 0.0, 0.0, 1.0) => 100.000000
dimval(1.0, 100.0, 100.0, 10.0, 0.0, 10.0) => 0.000000
jalbright015
  • 11
  • 2
1

I just went through an exercise to create something similar, and came up with:

z*(max - max-x)

Where z is the starting value, max is the asymptote, and x is the varying value.

singpolyma
  • 10,999
  • 5
  • 47
  • 71