blocks|key|1044499|text|如果您希望达到某种形式的饱和(请参阅Sigmoid函数)，请看我的答案这里。另一个常见的函数形状是线性或指数增长。如果你需要晚一点的话请告诉我。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|1044500|entityMap|0|LINK|mutability|MUTABLE|url|http://en.wikipedia.org/wiki/Sigmoid_function|1|https://stackoverflow.com/questions/706952/smooth-movement-to-ascend-through-the-atmosphere/707035#707035|2|http://en.wikipedia.org/wiki/Exponential_growth^0|I|9|0|Z|2|1|1D|7|2|0^^$0|@$1|2|3|4|5|6|7|P|8|@]|9|@$A|Q|B|R|1|S]|$A|T|B|U|1|V]|$A|W|B|X|1|Y]]|C|$]]|$1|D|3|-4|5|6|7|Z|8|@]|9|@]|C|$]]]|E|$F|$5|G|H|I|C|$J|K]]|L|$5|G|H|I|C|$J|M]]|N|$5|G|H|I|C|$J|O]]]]

If you desire some form of saturation (see <a href="http://en.wikipedia.org/wiki/Sigmoid_function" rel="nofollow noreferrer">Sigmoid function</a>), have a look at my answer <a href="https://stackoverflow.com/questions/706952/smooth-movement-to-ascend-through-the-atmosphere/707035#707035">here</a>. Another common function shape would be <a href="http://en.wikipedia.org/wiki/Exponential_growth" rel="nofollow noreferrer">linear or exponential growth</a>. Just let me know if you need one of the later.

blocks|key|1043444|text|我想你需要的是一些宽松的功能。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1043445|有一套著名的宽松函数是由罗伯特·彭纳创立的。你可以试着看看：Tweener转换备忘单，它形象化了Robert的方程。|offset|length|1043446|Robert的原始代码应该在他的网页。|1043447|entityMap|0|LINK|mutability|MUTABLE|url|http://labs.zeh.com.br/blog/?p=120|1|http://www.robertpenner.com/easing/^0|0|U|C|0|0|E|4|1|0^^$0|@$1|2|3|4|5|6|7|R|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|S|8|@]|9|@$D|T|E|U|1|V]]|A|$]]|$1|F|3|G|5|6|7|W|8|@]|9|@$D|X|E|Y|1|Z]]|A|$]]|$1|H|3|-4|5|6|7|10|8|@]|9|@]|A|$]]]|I|$J|$5|K|L|M|A|$N|O]]|P|$5|K|L|M|A|$N|Q]]]]

I think what you need is some easing function.

There is a set of famous easing functions created by Robert Penner. You may try to look at:
<a href="http://labs.zeh.com.br/blog/?p=120" rel="nofollow noreferrer">Tweener transition cheat sheets</a> which visualize Robert Penner's equations.

Robert Penner's original code should be at <a href="http://www.robertpenner.com/easing/" rel="nofollow noreferrer">his webpage</a>.

blocks|key|1044452|text|值=+(endValue+-+StartValue)+/(时间/+stepSize)+*+currentStep；|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1044453|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

value = (endValue - StartValue) / (time / stepSize) * currentStep;

blocks|key|1043287|text|见鬼，每次计时器一响就加一个。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1043288|entityMap^0|0^^$0|@$1|2|3|4|5|6|7|D|8|@]|9|@]|A|$]]|$1|B|3|-4|5|6|7|E|8|@]|9|@]|A|$]]]|C|$]]

heck just add one each time the timer goes off

blocks|key|2551945|text|如果我正确理解了，为什么不这样做(使用您定义的“变量”)：您需要改进整个结束值--起始值值。|type|unstyled|depth|inlineStyleRanges|offset|length|style|BOLD|entityRanges|data|2551946|使用时间变量，您可以计算出每毫秒增加多少(让我们称之为增加量)。|2551947|Step只是告诉你在每一个值之间“睡眠”的时间。每次引发新值时，只需执行last%2B(毫秒-自-increase*递增-)。|2551948|注意:我不知道为什么需要使用第一个变量(算法)，因为在我看来，它的角色是由其他变量定义的。|2551949|entityMap^0|10|8|0|0|10|N|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|Q|8|@]|D|@]|E|$]]|$1|H|3|I|5|6|7|R|8|@$9|S|A|T|B|C]]|D|@]|E|$]]|$1|J|3|K|5|6|7|U|8|@]|D|@]|E|$]]|$1|L|3|-4|5|6|7|V|8|@]|D|@]|E|$]]]|M|$]]

If I understood correctly, why not do this (using the "variables" you defined):
You need to progress overall ending value - starting value values.

Using the time variable, you can figure out how much of an increase you want every millisecond (let's call this increase-amount).

Step just tells you how much time to "sleep" between each value you raise. Every time a new value is raised, you just do last-value + (milliseconds-since-last_step * increase-amount).

Note: I'm not sure why you need the first variable (algorithm to use), since it seems to me that its role is defined by the other variables.

blocks|key|1025864|text|Pseduo逻辑对您的问题：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1025865|设给定步骤x的函数为F(a%2Bb*x)，起始值为起始值，结束值为结束，起始时间为0，最后时刻为时间，InverseF为F的反函数。|1025866|当x=0，F(A)=开始时，当x=time，F(a%2Bb*time)=end，b=(InverseF(end)-a)/time降为b=+(inverseF(End)-inverseF(Start)/time)时|1025867|对于任何x=step来说，|1025868|值是F(a%2Bb*step)，它只不过是|1025869|F(+inverseF(start)%2B+(inverseF(end)-inverseF(start))/time+*+step+)|1025870|就是答案。|1025871|例如，如果|1025872|F(x)是线性ie)+f(x)=x|1025873|值=start%2B(结束-启动)/time*step|1025874|如果F(x)是x*x，那么|1025875|值=(+sqrt(start)+%2B+(sqrt(end)-sqrt(start))/time+*+step)+*(+sqrt(start)+%2B+(sqrt(end)-sqrt(start))/time+*+step)|1025876|如果F(x)是exp(x)，那么|1025877|值=+Exp+(+log(start)+%2B+(log(end)-log(start))/time*step+)|1025878|如果F(x)是log(x)，那么|1025879|value+=+Log(+(exp(start)+%2B+(exp(end)-exp(start))/time*step+)|1025880|以此类推。|1025881|另一种不使用反函数的方法解释如下。|1025882|对于给定的步骤x，函数为a%2Bb*F(x)，起始值为开始，结束值为结束，开始时间为0，最后时间为时间。|1025883|然后a%2B+b+*+F(0)+=+start和a%2Bb*+F(time)+=+end，在求解a&b时，|1025884|你会得到|1025885|值=开始%2B(结束-开始)/(F(时间)-F(0))*+(F(x)-F(0)+)|1025886|在第一步中，|1025887|值=开始%2B(结束-开始)/(F(时间)-F(0))*+(F(step)-F(0)+)|1025888|我希望上面的任何一个都能解决你的问题。|1025889|entityMap^0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|1P|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|1Q|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|1R|8|@]|9|@]|A|$]]|$1|F|3|G|5|6|7|1S|8|@]|9|@]|A|$]]|$1|H|3|I|5|6|7|1T|8|@]|9|@]|A|$]]|$1|J|3|K|5|6|7|1U|8|@]|9|@]|A|$]]|$1|L|3|M|5|6|7|1V|8|@]|9|@]|A|$]]|$1|N|3|O|5|6|7|1W|8|@]|9|@]|A|$]]|$1|P|3|Q|5|6|7|1X|8|@]|9|@]|A|$]]|$1|R|3|S|5|6|7|1Y|8|@]|9|@]|A|$]]|$1|T|3|U|5|6|7|1Z|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|20|8|@]|9|@]|A|$]]|$1|X|3|Y|5|6|7|21|8|@]|9|@]|A|$]]|$1|Z|3|10|5|6|7|22|8|@]|9|@]|A|$]]|$1|11|3|12|5|6|7|23|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|24|8|@]|9|@]|A|$]]|$1|15|3|16|5|6|7|25|8|@]|9|@]|A|$]]|$1|17|3|18|5|6|7|26|8|@]|9|@]|A|$]]|$1|19|3|1A|5|6|7|27|8|@]|9|@]|A|$]]|$1|1B|3|1C|5|6|7|28|8|@]|9|@]|A|$]]|$1|1D|3|1E|5|6|7|29|8|@]|9|@]|A|$]]|$1|1F|3|1G|5|6|7|2A|8|@]|9|@]|A|$]]|$1|1H|3|1I|5|6|7|2B|8|@]|9|@]|A|$]]|$1|1J|3|1K|5|6|7|2C|8|@]|9|@]|A|$]]|$1|1L|3|1M|5|6|7|2D|8|@]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|2E|8|@]|9|@]|A|$]]]|1O|$]]

Pseduo logic to your problem:

let the function be F(a+b*x) for given step x,
let the starting value is start, 
let the ending value is end
let the starting time is 0 and final time is time
and InverseF is the inverse function of F.

when x=0, F(a)=start Hence a= InverseF(start)
when x=time, F(a+b*time)=end, Hence b=(InverseF(end)-a)/time which reduces to b= (inverseF(end)-inverseF(start))/time

Finaly for any x=step,

value is F(a+b*step) which is
nothing but

F( inverseF(start)+ (inverseF(end)-inverseF(start))/time * step ) 

is the answer.

For example if 

F(x) is liner ie) f(x)=x

value = start+(end-start)/time*step

if F(x) is x*x, then

value = ( sqrt(start) + (sqrt(end)-sqrt(start))/time * step) * ( sqrt(start) + (sqrt(end)-sqrt(start))/time * step) 

if F(x) is exp(x) then

value = Exp ( log(start) + (log(end)-log(start))/time*step )

if F(x) is log(x) then

value = Log( (exp(start) + (exp(end)-exp(start))/time*step )

and so on..

another approach without using inverse function is explained below.

let the function be a+b*F(x) for given step x,
let the starting value is start, 
let the ending value is end
let the starting time is 0 and final time is time

then a+ b * F(0) = start and a + b * F(time) = end, on solving a &amp; b,

you will get

value = start + (end-start) / (F(time)-F(0) ) * (F(x)-F(0) )

and for a step x,

value = start + (end-start) / (F(time)-F(0) ) * (F(step)-F(0) )

and I hope, any one of the above will solve your problem..

blocks|key|2552138|text|我将重新使用我的回答来回答另一个问题。这个答案给出的函数不会花很多时间做低负载，但是很快就会转到中等重的负载，然后缓慢地增加负载以达到最大值。如果您需要在可能的负载中间有更多的值，或者在低负载中需要更多的值，只需传递适当的分布函数即可。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|2552139|给定您的输入参数，我会这样称呼它：|2552140|Spread(startingValue,+endingValue,+time/step,+x+=>+1-(1-x)*(1-x))|code-block|syntax|javascript|2552141|示例算法功能：|2552142|FocusOnHighLoad+++=+x+=>+1-(1-x)*(1-x)
FocusOnLowLoad++++=+x+=>+x+*+x
FocusOnMediumLoad+=+x+=>+(1+%2B+Math.Pow(x+*+2+-+1,+3))+/+2|2552143|样本输出：|2552144|foreach+(double+load+in+Spread(50,+1000,+9,+FocusOnHighLoad))
++++Console.WriteLine("Working+with+{0}+load",+load);

Working+with+50+load
Working+with+272.65625+load
Working+with+465.625+load
Working+with+628.90625+load
Working+with+762.5+load
Working+with+866.40625+load
Working+with+940.625+load
Working+with+985.15625+load
Working+with+1000+load|2552145|entityMap|0|LINK|mutability|MUTABLE|url|https://stackoverflow.com/questions/1204128/c-formula-to-distribute-numbers/1205172#1205172^0|6|4|0|0|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|10|8|@]|9|@$A|11|B|12|1|13]]|C|$]]|$1|D|3|E|5|6|7|14|8|@]|9|@]|C|$]]|$1|F|3|G|5|H|7|15|8|@]|9|@]|C|$I|J]]|$1|K|3|L|5|6|7|16|8|@]|9|@]|C|$]]|$1|M|3|N|5|H|7|17|8|@]|9|@]|C|$I|J]]|$1|O|3|P|5|6|7|18|8|@]|9|@]|C|$]]|$1|Q|3|R|5|H|7|19|8|@]|9|@]|C|$I|J]]|$1|S|3|-4|5|6|7|1A|8|@]|9|@]|C|$]]]|T|$U|$5|V|W|X|C|$Y|Z]]]]

I'll reuse <a href="https://stackoverflow.com/questions/1204128/c-formula-to-distribute-numbers/1205172#1205172">my answer</a> to another question. The functions given for that answer will not spend much time doing low load, but quickly go to medium-heavy load and then increase load slower to reach maximum. If you need more values on the in the middle of the possible loads, or more values in the low load - just pass appropriate distribution function.

Given your input parameters I would call it like this:

<pre><code>Spread(startingValue, endingValue, time/step, x =&gt; 1-(1-x)*(1-x))
</code></pre>

Sample algorithm functions:

<pre><code>FocusOnHighLoad = x =&gt; 1-(1-x)*(1-x)
FocusOnLowLoad = x =&gt; x * x
FocusOnMediumLoad = x =&gt; (1 + Math.Pow(x * 2 - 1, 3)) / 2
</code></pre>

Sample output:

<pre><code>foreach (double load in Spread(50, 1000, 9, FocusOnHighLoad))
 Console.WriteLine("Working with {0} load", load);

Working with 50 load
Working with 272.65625 load
Working with 465.625 load
Working with 628.90625 load
Working with 762.5 load
Working with 866.40625 load
Working with 940.625 load
Working with 985.15625 load
Working with 1000 load
</code></pre>

I am writing a test tool which places a large amount of load on a network service. I would like this tool to start with little load and gradually increase over time. I am sure that there is some triganometry which can do this sort of calculation in one line of code but I am not a math guru (yet). Is there some sort of library (or simple algorithm) which can help with this calculation?

The code would ideally take a few arguments:

<ul>
<li>algorithm to use (determine how quickly the value increases</li>
<li>starting value</li>
<li>ending value (maximum)</li>
<li>time (amount of time between starting and ending value)</li>
<li>step (granularity in milliseconds)</li>
</ul>

So every [step] an event would be raised indicating what the value is at that point in time.

This is an ideal implementation though, so I am open to suggestion.

Any input would be greatly appreciated, thank you :)

EDIT:

Let me be more clear ... the amount which the value increases is not linear, it is a curve.

Increase value over time using mathematical algorithm

33 天实现自己的 AI 进化论？发文瓜分机械键盘、耳机等万元奖池！点击参加活动：<a href="https://cloud.tencent.com/developer/article/2503022" target="_blank">https://cloud.tencent.com/developer/article/2503022</a> 
 <img src="https://qcloudimg.tencent-cloud.cn/raw/01543e0407db10898a7ee9f420794432.jpg"/>

技术创作特训营有奖征文

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋 

腾讯云AI代码助手

CODING DevOps

Cloud Studio

SDK中心

API中心

命令行工具

文章&问答评论现已支持表情

我正在编写一个测试工具，它将大量的负载放置在网络服务上。我希望这个工具从小负荷开始，并随着时间的推移逐渐增加。我确信有一些三角计量学可以在一行代码中完成这种计算，但我还不是数学大师。是否有某种库(或简单的算法)可以帮助此计算？理想情况下，代码将采用几个参数：要使用的算法(确定值增长的速度)起始值期末价值(最高)时间(起始值和结束值之间的时间量)步骤(粒度以毫秒为单位)因此，每一步都会引发事件，指示

问使用数学算法随时间增加值
EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用数学算法随时间增加值EN

回答 7

Stack Overflow用户

Stack Overflow用户

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问使用数学算法随时间增加值
EN