• Status: Solved
• Priority: Medium
• Security: Public
• Views: 422

Linear Decrease Algorithm

Hello,

Could someone please provide a PHP Algorithm which will result in a smaller value being returned when a larger value is provided.

E.g.

x(25); //returns say 50
x(50); //returns say 49.3
x(100000); //returns say 1 etc

function x(\$value) {
code..
return(\$value) {
}

Also i would like it where negative values will not be returned.

Regards Shinji.
0
nerotech
• 7
• 5
• 4
• +2
1 Solution

Commented:
Maybe this:
``````function x(\$a)
{
return rand(0, \$a-1);
}
echo x(25);
``````
0

Author Commented:
Thanks for the response, but this is not what i'm after.

I need it so that the return value is constant, not randomized.
0

Author Commented:
Note: i should have named the topic "nonlinear decrease algorithm", as i wish to cause the decrease to become more significant as the provided value increases.
0

Commented:
Nerotech: What rules would you apply to determine how much smaller the return value should be?
0

Commented:
Strange solution:
``````<?PHP
function x(\$a)
{
\$b = substr(abs(crc32(\$a)), 0, 1);
return (\$a-\$b > 0 ? \$a-\$b : 1);
}
echo x(46);
?>
``````
0

Author Commented:
Well initially I would prefer the returned value to be ~10% less of the provided value, as the value increments I would like the percentage to decrease more rapidly and Eventually the returned value would be 99.9% less than the original.

The point at which 99.9% less should be >=10,000

To summarize:

Start value >=0 && <=25 (-10%)
End value >=10,000 (-99.9%)

Percentage removed per increment will initially start slow, but will become more apparent at ~1,000.
0

Commented:
What kind of calculations are you doing? Something like showing an animation in x seconds with a varying start/end or something?
0

Commented:

``````function non_linear_decrease(\$input)
{
if (\$input < 0 ) { return 0; }

\$input_temp = \$input;
\$multiplier = 1;
while ((\$input_temp / 10) )  > 10) {
\$multiplier = \$multiplier * .9;
\$input_temp = \$input_temp / 10;
}

return \$input * \$multiplier;
}
``````
0

Commented:
Still not sure I understand the function.  Could you sketch a curve that would show what you're seeking?
nerotech-function.gif
0

Author Commented:
Yes Ray, thats exactly what i'm after.
0

Commented:
shinji,
how do the results of the function i supplied compare to what you want?
0

Author Commented:
Virmaior: its not what i'm after.

Test values:
25-100 (0% difference)
101 (9.1% difference)
10,000 (19% difference)
0

Commented:
Shinji: I have to leave and can't work on this, but it looks like you need a parabola with a horizontal axis.

http://www.intmath.com/Plane-analytic-geometry/4_Parabola.php

Good luck! ~Ray
0

Commented:
K‰“Uc_hFg‚mSŒoiFgYK

function nonlinear_decrease(\$input)
{
if ((\$input > 25) and (\$input < 100)) { return \$input; }
return \$input * (1 - log(\$input,1.62));
}

that gets the values you are looking for
(19% for 10000) and (9% for 100)
0

Commented:
or rather return \$input * (1 - ( log(\$input,1.62) / 100));

kore de ha nihon no kanji wo kaite dekimasen. shikashi, saisho no hoshikatta no kotae to ima no sagashiteru no kotae ha chigaimashita no?
0

Author Commented:
Sorry Virmaior, i should have been less ambiguous with my response (and original question).
Those were the test values & results i used on the function that you provided earlier.

The values i need are:

Start value >=0 && <=25 (-10%)
End value >=10,000 (-99.9%)

with nonlinear increase (see the graph Ray posted).

Ray is correct in pointing out that I require a parabolic function (Quadrant I).
0

Commented:
nerotech, I looked at this again.  I think you may want an asymptotic curve - not truly a half-parabola, but it meets all the needs you expressed.  HTH, ~Ray
``````<?php

// CONSTRAINED ASYMPTOTE ALGORITHM
// http://en.wikipedia.org/wiki/Asymptote

define("MINMIN", 0.0);
define("MAXMIN", 25.0); // NOT USED, PRESENT FOR ILLUSTRATION
define("MAXMAX", 10000.0);
define("MINPCT", 0.1);
define("MAXPCT", 0.999);

function asymptote(\$value) {

// NO VALUES BELOW MINIMUM THRESHOLD
if (\$value <= MINMIN) {
return FALSE;
}

// COMPUTE A PERCENTAGE
\$percent = \$value / MAXMAX;

// CONSTRAIN MINIMUM
if (\$percent < MINPCT) {
return \$value - ( \$value * MINPCT );
}

// CONSTRAIN MAXIMUM
if (\$percent > MAXPCT) {
return \$value - ( \$value * MAXPCT );
}

// WITHIN CONSTRAINTS RETURN DIMINISHED VALUE
return \$value - ( \$value * \$percent );

} // END function asymptote()

\$kount = 1.0;
while (\$kount < MAXMAX) {
\$asymptote = asymptote(\$kount);
\$pctg = 1.0 - \$asymptote / \$kount; // PERCENTAGE OF REDUCTION INCREASES AS VALUE INCREASES
echo "<br /> \$kount \$asymptote \$pctg \n";
\$kount++;
}

?>
``````
0

Author Commented:
Great, thanks alot Ray, works perfect! :)
0

Commented:
Glad to help!  BTW, that algorithm (when unconstrained) is the central element of single-server queueing theory.  Response Time = Service Time divided by (1 - Percent Busy).  I have used it for years to predict computer performance under increasing loads.  Nice to see it serves your needs, too.
0

Featured Post

• 7
• 5
• 4
• +2
Tackle projects and never again get stuck behind a technical roadblock.